gar::garg4::GArG4 Class Reference

Runs Geant4 simulation and propagation of electrons and photons to readout. More...

Inheritance diagram for gar::garg4::GArG4:

Public Member Functions
	GArG4 (fhicl::ParameterSet const &pset)
	Standard constructor and destructor for an FMWK module. More...
virtual	~GArG4 ()
void	produce (::art::Event &evt)
void	beginJob ()
void	beginRun (::art::Run &run)
Public Member Functions inherited from art::EDProducer
	EDProducer (fhicl::ParameterSet const &pset)
template<typename Config >
	EDProducer (Table< Config > const &config)
std::string	workerType () const
Public Member Functions inherited from art::detail::Producer
virtual	~Producer () noexcept
	Producer (fhicl::ParameterSet const &)
	Producer (Producer const &)=delete
	Producer (Producer &&)=delete
Producer &	operator= (Producer const &)=delete
Producer &	operator= (Producer &&)=delete
void	doBeginJob (SharedResources const &resources)
void	doEndJob ()
void	doRespondToOpenInputFile (FileBlock const &fb)
void	doRespondToCloseInputFile (FileBlock const &fb)
void	doRespondToOpenOutputFiles (FileBlock const &fb)
void	doRespondToCloseOutputFiles (FileBlock const &fb)
bool	doBeginRun (RunPrincipal &rp, ModuleContext const &mc)
bool	doEndRun (RunPrincipal &rp, ModuleContext const &mc)
bool	doBeginSubRun (SubRunPrincipal &srp, ModuleContext const &mc)
bool	doEndSubRun (SubRunPrincipal &srp, ModuleContext const &mc)
bool	doEvent (EventPrincipal &ep, ModuleContext const &mc, std::atomic< std::size_t > &counts_run, std::atomic< std::size_t > &counts_passed, std::atomic< std::size_t > &counts_failed)
Public Member Functions inherited from art::Modifier
	~Modifier () noexcept
	Modifier ()
	Modifier (Modifier const &)=delete
	Modifier (Modifier &&)=delete
Modifier &	operator= (Modifier const &)=delete
Modifier &	operator= (Modifier &&)=delete
Public Member Functions inherited from art::ModuleBase
virtual	~ModuleBase () noexcept
	ModuleBase ()
ModuleDescription const &	moduleDescription () const
void	setModuleDescription (ModuleDescription const &)
std::array< std::vector< ProductInfo >, NumBranchTypes > const &	getConsumables () const
void	sortConsumables (std::string const &current_process_name)
template<typename T , BranchType BT>
ViewToken< T >	consumesView (InputTag const &tag)
template<typename T , BranchType BT>
ViewToken< T >	mayConsumeView (InputTag const &tag)

Private Member Functions
std::unique_ptr< PositionInVolumeFilter >	CreateParticleVolumeFilter (std::set< std::string > const &vol_names) const
	Configures and returns a particle filter. More...
void	SetLimitsAndCuts ()
	Set the user limits and production cuts per region. More...

Private Attributes
g4b::G4Helper *	fG4Help
	G4 interface object. More...
garg4::EnergyDepositAction *	fEDepAction
	Geant4 user action to handle GAr energy depositions. More...
garg4::AuxDetAction *	fAuxDetAction
	Geant4 user action to handle GAr energy depositions. More...
garg4::ParticleListAction *	fParticleListAction
	Geant4 user action to particle information. More...
fhicl::ParameterSet	fEDepActionPSet
	configuration for GArAction More...
fhicl::ParameterSet	fAuxDetActionPSet
	configuration for AuxAction More...
std::vector< std::string >	fDetRegionNames
	Name of the volumes used to defined regions. More...
std::string	fG4PhysListName
	predefined physics list to use if not making a custom one More...
std::string	fG4MacroPath
	executed before main MC processing. More...
bool	fCheckOverlaps
	Whether to use the G4 overlap checker. More...
bool	fdumpParticleList
	Whether each event's sim::ParticleList will be displayed. More...
int	fSmartStacking
	dictate how tracks are put on stack. More...
std::vector< float >	fMaxStepSize
	maximum step size in mm per sub-detector region More...
float	fProductionCut
	G4 will check if a produced particle should travel this far and drop it if not. More...
std::vector< std::string >	fInputLabels
std::vector< std::string >	fKeepParticlesInVolumes
	Only write particles that have trajectories through these volumes. More...
const geo::GeometryCore *	geo
CLHEP::HepRandomEngine &	fEngine

Additional Inherited Members
Public Types inherited from art::EDProducer
using	ModuleType = EDProducer
using	WorkerType = WorkerT< EDProducer >
Public Types inherited from art::detail::Producer
template<typename UserConfig , typename KeysToIgnore = void>
using	Table = Modifier::Table< UserConfig, KeysToIgnore >
Public Types inherited from art::Modifier
template<typename UserConfig , typename UserKeysToIgnore = void>
using	Table = ProducerTable< UserConfig, detail::ModuleConfig, UserKeysToIgnore >
Static Public Member Functions inherited from art::EDProducer
static void	commitEvent (EventPrincipal &ep, Event &e)
Protected Member Functions inherited from art::ModuleBase
ConsumesCollector &	consumesCollector ()
template<typename T , BranchType = InEvent>
ProductToken< T >	consumes (InputTag const &)
template<typename Element , BranchType = InEvent>
ViewToken< Element >	consumesView (InputTag const &)
template<typename T , BranchType = InEvent>
void	consumesMany ()
template<typename T , BranchType = InEvent>
ProductToken< T >	mayConsume (InputTag const &)
template<typename Element , BranchType = InEvent>
ViewToken< Element >	mayConsumeView (InputTag const &)
template<typename T , BranchType = InEvent>
void	mayConsumeMany ()

Detailed Description

Runs Geant4 simulation and propagation of electrons and photons to readout.

Randomness

The random number generators used by this process are:

• 'GEANT' instance: used by Geant4
• 'propagation' instance: used in electron propagation
• 'radio' instance: used for radiological decay

Configuration parameters

• G4PhysListName (string, default "garg4::PhysicsList"): whether to use the G4 overlap checker, which catches different issues than ROOT
• CheckOverlaps (bool, default false): whether to use the G4 overlap checker
• DumpParticleList (bool, default false): whether to print all MCParticles tracked
• SmartStacking (int, default 0): whether to use class to dictate how tracks are put on stack (nonzero is on)
• KeepParticlesInVolumes (vector<string>, default empty): list of volumes in which to keep MCParticles (empty keeps all)
• GeantCommandFile (string, required): G4 macro file to pass to G4Helper for setting G4 command
• Seed (pset key, not defined by default): if defined, override the seed for random number generator used in Geant4 simulation (which is obtained from NuRandomService by default)
• PropagationSeed (pset key, not defined by default): if defined, override the seed for the random generator used for electrons propagation to the wire planes (obtained from the NuRandomService by default)
• RadioSeed (pset key, not defined by default): if defined, override the seed for the random generator used for radiological decay (obtained from the NuRandomService by default)
• InputLabels (vector<string>, defualt unnecessary): optional list of generator labels which produce MCTruth; otherwise look for anything that has made MCTruth

Definition at line 152 of file GArG4_module.cc.

Constructor & Destructor Documentation

gar::garg4::GArG4::GArG4 ( fhicl::ParameterSet const &  pset )

explicit

Standard constructor and destructor for an FMWK module.

Definition at line 205 of file GArG4_module.cc.

        : art::EDProducer{pset}
        ,  fG4Help                (nullptr)
        , fEDepAction            (nullptr)
        , fAuxDetAction          (nullptr)
        , fParticleListAction    (nullptr)
        , fEDepActionPSet        (pset.get<fhicl::ParameterSet>("EDepActionPSet")                         )
        , fAuxDetActionPSet      (pset.get<fhicl::ParameterSet>("AuxDetActionPSet")                       )
        , fDetRegionNames        (pset.get< std::vector< std::string > >("DetRegionName", {})             )
        , fG4PhysListName        (pset.get< std::string       >("G4PhysListName",   "garg4::PhysicsList") )
        , fCheckOverlaps         (pset.get< bool              >("CheckOverlaps",    false)                )
        , fdumpParticleList      (pset.get< bool              >("DumpParticleList", false)                )
        , fSmartStacking         (pset.get< int               >("SmartStacking",    0)                    )
        , fMaxStepSize           (pset.get< std::vector< float > >("MaxStepSize", {}  )                   )//in mm
        , fProductionCut         (pset.get< float             >("ProductionCut",    0.05)                 )//in mm
        , fKeepParticlesInVolumes(pset.get< std::vector< std::string > >("KeepParticlesInVolumes", {})    )
        , fEngine(art::ServiceHandle<rndm::NuRandomService>()->createEngine(*this, pset, "GEANTSeed")     )
        {
            geo = providerFrom<geo::GeometryGAr>();

            // initialize the GArSimulationParameters singleton
            G4SimulationParameters::CreateInstance(pset.get<fhicl::ParameterSet>("GArSimParsPSet"));

            MF_LOG_DEBUG("GArG4") << "Debug: GArG4()";
            //art::ServiceHandle<rndm::NuRandomService>()->createEngine(*this);
            ::art::ServiceHandle<::art::RandomNumberGenerator> rng;

            // setup the random number service for Geant4, the "G4Engine" label is a
            // special tag setting up a global engine for use by Geant4/CLHEP;
            // obtain the random seed from NuRandomService,
            // unless overridden in configuration with key "Seed" or "GEANTSeed"
            // same thing for the propagation engine:
            // and again for radio decay


            //get a list of generators to use, otherwise, we'll end up looking for anything that's
            //made an MCTruth object
            bool useInputLabels = pset.get_if_present< std::vector<std::string> >("InputLabels", fInputLabels);
            if(!useInputLabels) fInputLabels.resize(0);

            produces< std::vector<simb::MCParticle>                 >();
            produces< ::art::Assns<simb::MCTruth, simb::MCParticle> >();

            produces< std::vector<sdp::LArDeposit>                 >();
            produces< std::vector<sdp::EnergyDeposit>               >();
            
            if(geo->HasECALDetector())
            produces< std::vector<sdp::CaloDeposit>                 >("ECAL");//ECAL
            if(geo->HasTrackerScDetector())
            produces< std::vector<sdp::CaloDeposit>                 >("TrackerSc");//TrackerSc
            if(geo->HasMuonDetector())
            produces< std::vector<sdp::CaloDeposit>                 >("MuID");//MuID

            // constructor decides if initialized value is a path or an environment variable
            cet::search_path sp("FW_SEARCH_PATH");

            sp.find_file(pset.get< std::string >("GeantCommandFile"), fG4MacroPath);
            struct stat sb;
            if (fG4MacroPath.empty() || stat(fG4MacroPath.c_str(), &sb)!=0)
            // failed to resolve the file name
            throw cet::exception("NoG4Macro")
            << "G4 macro file "
            << fG4MacroPath
            << " not found!\n";

        }

gar::garg4::GArG4::~GArG4 ( )

virtual

Definition at line 274 of file GArG4_module.cc.

        {
            if(fG4Help) delete fG4Help;
        }

Member Function Documentation

void gar::garg4::GArG4::beginJob ( )

virtual

Reimplemented from art::EDProducer.

Definition at line 335 of file GArG4_module.cc.

        {
            //auto* rng = &*(::art::ServiceHandle<::art::RandomNumberGenerator>());

            fG4Help = new g4b::G4Helper(fG4MacroPath, fG4PhysListName);
            if(fCheckOverlaps) fG4Help->SetOverlapCheck(true);
            fG4Help->ConstructDetector(geo->GDMLFile()); //TO DO!!! This create a problem when we want to use a custom magnetic field!!! (it calls under the service mag::Magnetic field)

            G4LogicalVolumeStore *store = G4LogicalVolumeStore::GetInstance();
            if(store == nullptr) {
                MF_LOG_INFO("GArG4")
                << "G4LogicalVolumeStore::GetInstance() not available";
            }

            // Get the logical volume store and assign material properties
            garg4::MaterialPropertyLoader* MPL = new garg4::MaterialPropertyLoader();
            MPL->GetPropertiesFromServices();
            MPL->UpdateGeometry(store);

            this->SetLimitsAndCuts();

            // Intialize G4 physics and primary generator action
            fG4Help->InitPhysics();

            // Use the UserActionManager to handle all the Geant4 user hooks.
            g4b::UserActionManager* uaManager = g4b::UserActionManager::Instance();

            // User-action class for accumulating particles and trajectories
            // produced in the detector.
            auto g4SimPars = gar::garg4::G4SimulationParameters::Instance();

            fParticleListAction = new garg4::ParticleListAction(g4SimPars->KineticEnergyCut(),
            g4SimPars->StoreTrajectories(),
            g4SimPars->KeepEMShowerDaughters(),
            g4SimPars->EMShowerDaughterMatRegex());

            uaManager->AddAndAdoptAction(fParticleListAction);


            // add UserAction for handling steps in gaseous argon
            fEDepAction = new garg4::EnergyDepositAction(&(fEngine),
            fEDepActionPSet);
            uaManager->AddAndAdoptAction(fEDepAction);

            // add UserAction for handling steps in auxiliary detectors
            fAuxDetAction = new garg4::AuxDetAction(&(fEngine),
            fAuxDetActionPSet);
            uaManager->AddAndAdoptAction(fAuxDetAction);


            // UserActionManager is now configured so continue G4 initialization
            fG4Help->SetUserAction();

            MF_LOG_INFO("GArG4") << "BeginJob() -- end ";

            return;
        }

void gar::garg4::GArG4::beginRun

(

::art::Run &

run

)

Definition at line 394 of file GArG4_module.cc.

        {
            // prepare the filter object (null if no filtering)

            std::set<std::string> volnameset(fKeepParticlesInVolumes.begin(), fKeepParticlesInVolumes.end());
            fParticleListAction->ParticleFilter(CreateParticleVolumeFilter(volnameset));

            return;
        }

std::unique_ptr< PositionInVolumeFilter > gar::garg4::GArG4::CreateParticleVolumeFilter ( std::set< std::string > const &  vol_names ) const

private

Configures and returns a particle filter.

Definition at line 405 of file GArG4_module.cc.

        {

            // if we don't have favourite volumes, don't even bother creating a filter
            if (vol_names.empty()) return {};
            std::vector<std::vector<TGeoNode const*>> node_paths = geo->FindAllVolumePaths(vol_names);

            // collection of interesting volumes
            PositionInVolumeFilter::AllVolumeInfo_t GeoVolumePairs;
            GeoVolumePairs.reserve(node_paths.size()); // because we are obsessed

            //for each interesting volume, follow the node path and collect
            //total rotations and translations
            for(auto const& path : node_paths){

                TGeoTranslation* pTransl = new TGeoTranslation(0.,0.,0.);
                TGeoRotation* pRot = new TGeoRotation();
                for (TGeoNode const* node: path) {
                    TGeoTranslation thistranslate(*node->GetMatrix());
                    TGeoRotation thisrotate(*node->GetMatrix());
                    pTransl->Add(&thistranslate);
                    *pRot=*pRot * thisrotate;
                }

                //for some reason, pRot and pTransl don't have tr and rot bits set correctly
                //make new translations and rotations so bits are set correctly
                TGeoTranslation* pTransl2 = new TGeoTranslation(pTransl->GetTranslation()[0],
                pTransl->GetTranslation()[1],
                pTransl->GetTranslation()[2]);
                double phi=0.,theta=0.,psi=0.;
                pRot->GetAngles(phi,theta,psi);
                TGeoRotation* pRot2 = new TGeoRotation();
                pRot2->SetAngles(phi,theta,psi);

                TGeoCombiTrans* pTransf = new TGeoCombiTrans(*pTransl2,*pRot2);

                GeoVolumePairs.emplace_back(path.back()->GetVolume(), pTransf);

            }

            return std::make_unique<PositionInVolumeFilter>(std::move(GeoVolumePairs));

        } // CreateParticleVolumeFilter()

void gar::garg4::GArG4::produce

(

::art::Event &

evt

)

The main routine of this module: Fetch the primary particles from the event, simulate their evolution in the detctor, and produce the detector response.

Definition at line 451 of file GArG4_module.cc.

        {
            MF_LOG_DEBUG("GArG4") << "produce()";

            // loop over the lists and put the particles and voxels into the event as collections
            std::unique_ptr< std::vector<simb::MCParticle> >                 partCol(new std::vector<simb::MCParticle>                );
            std::unique_ptr< std::vector<sdp::EnergyDeposit>  >              TPCCol  (new std::vector<sdp::EnergyDeposit>              );
            std::unique_ptr< ::art::Assns<simb::MCTruth, simb::MCParticle> > tpassn (new ::art::Assns<simb::MCTruth, simb::MCParticle>);
            std::unique_ptr< std::vector< sdp::CaloDeposit > >          ECALCol  (new std::vector<sdp::CaloDeposit>           );
            std::unique_ptr< std::vector< sdp::CaloDeposit > >          MuIDCol  (new std::vector<sdp::CaloDeposit>           );
            std::unique_ptr< std::vector< sdp::LArDeposit > >           LArCol  (new std::vector<sdp::LArDeposit>           );

            // reset the track ID offset as we have a new collection of interactions
            fParticleListAction->ResetTrackIDOffset();

            // look to see if there is any MCTruth information for this
            // event
            std::vector< ::art::Handle< std::vector<simb::MCTruth> > > mclists;
            if(fInputLabels.size() < 1)
              {
                mclists = evt.getMany< std::vector<simb::MCTruth> >();
              }
            else{
                mclists.resize(fInputLabels.size());
                for(size_t i = 0; i < fInputLabels.size(); ++i)
                  mclists.at(i) = evt.getHandle< std::vector<simb::MCTruth> >(fInputLabels.at(i));
            }

            // create a vector of art::Ptrs to MCTruths for use with the
            // association creation and a vector of const* for use with
            // G4Helper
            std::vector< ::art::Ptr<simb::MCTruth> > mctPtrs;
            std::vector< const simb::MCTruth*      > mcts;

            for(size_t mc = 0; mc < mclists.size(); ++mc){
                for(size_t i = 0; i < mclists[mc]->size(); ++i){
                    art::Ptr<simb::MCTruth> ptr(mclists[mc], i);
                    mctPtrs.push_back(ptr);
                    mcts   .push_back(ptr.get());
                }
            }

            // Process Geant4 simulation for the mctruths
            fG4Help->G4Run(mcts);

            // receive the particle list
            auto       particleList = fParticleListAction->YieldList();
            auto const trackIDToMCT = fParticleListAction->TrackIDToMCTruthIndexMap();

            int    trackID             = std::numeric_limits<int>::max();
            size_t mctidx              = 0;
            size_t nGeneratedParticles = 0;

            // Has the user request a detailed dump of the output objects?
            if (fdumpParticleList){
                MF_LOG_INFO("GArG4")
                << "Dump sim::ParticleList; size() = "
                << particleList.size()
                << "\n"
                << particleList;
            }

            auto iPartPair = particleList.begin();
            while (iPartPair != particleList.end()) {
                simb::MCParticle& p = *(iPartPair->second);

                trackID = p.TrackId();

                partCol->push_back(std::move(p));
                if( trackIDToMCT.count(trackID) > 0){

                    mctidx = trackIDToMCT.find(trackID)->second;

                    util::CreateAssn(*this,
                    evt,
                    *partCol,
                    mctPtrs[mctidx],
                    *tpassn,
                    nGeneratedParticles);
                }
                else
                throw cet::exception("GArG4")
                << "Cannot find MCTruth for Track Id: "
                << trackID
                << " to create association between Particle and MCTruth";

                // FIXME workaround until https://cdcvs.fnal.gov/redmine/issues/12067
                // is solved and adopted in GArSoft, after which moving will suffice
                // to avoid dramatic memory usage spikes;
                // for now, we immediately disposed of used particles
                iPartPair = particleList.erase(iPartPair);

                ++nGeneratedParticles;
            } // while(particleList)


            // Now for the sdp::EnergyDepositions
            for(auto const& tpc : fEDepAction->EnergyDeposits()){
                MF_LOG_DEBUG("GArG4")
                << "adding TPC deposits for track id: "
                << tpc.TrackID();

                TPCCol->emplace_back(tpc);
            }

            // And finally the sdp::CaloDepositions
            std::vector<gar::sdp::CaloDeposit> deposits = fAuxDetAction->CaloDeposits();
            if (geo->HasTrackerScDetector())
                deposits = fAuxDetAction->TrackerScDeposits();

            for (auto const &hit : deposits)
            {
                MF_LOG_DEBUG("GArG4")
                    << "adding calo deposits for track id: "
                    << hit.TrackID();

                ECALCol->emplace_back(hit);
            }

            // And finally the sdp::CaloDepositions
            for(auto const& hit : fAuxDetAction->MuIDDeposits())
            {
                MF_LOG_DEBUG("GArG4")
                << "adding muid deposits for track id: "
                << hit.TrackID();

                MuIDCol->emplace_back(hit);
            }

            // And finally the sdp::CaloDepositions
            for(auto const& hit : fAuxDetAction->LArDeposits())
            {
                MF_LOG_DEBUG("GArG4")
                << "adding LAr deposits for track id: "
                << hit.TrackID();

                LArCol->emplace_back(hit);
            }

            evt.put(std::move(TPCCol));

            std::string instanceName = "ECAL";
            if(geo->HasTrackerScDetector())
            instanceName = "TrackerSc";

            evt.put(std::move(ECALCol), instanceName);

            if(geo->HasMuonDetector())
            evt.put(std::move(MuIDCol), "MuID");
            
            evt.put(std::move(LArCol));

            evt.put(std::move(partCol));
            evt.put(std::move(tpassn));

            return;
        } // GArG4::produce()

void gar::garg4::GArG4::SetLimitsAndCuts ( )

private

Set the user limits and production cuts per region.

Definition at line 280 of file GArG4_module.cc.

        {
            // Regions {TPC, Inner ECAL, Outer ECAL, Endcap ECAL}
            if(fMaxStepSize.size() != fDetRegionNames.size())
            {
                MF_LOG_INFO("GArG4")
                << "Step size vector has "
                << fMaxStepSize.size()
                << " elements != DetRegionName has "
                << fDetRegionNames.size()
                << " elements"
                << " will use default step size of 2 mm";
            }

            unsigned int index = 0;
            for(auto &name : fDetRegionNames)
            {
                G4Region* aRegion = new G4Region(name);
                G4LogicalVolume* calorLogical = G4LogicalVolumeStore::GetInstance()->GetVolume(name);
                calorLogical->SetRegion(aRegion);
                aRegion->AddRootLogicalVolume(calorLogical);

                G4Region* reg = G4RegionStore::GetInstance()->GetRegion(name);

                MF_LOG_INFO("GArG4")
                << "Setting production cuts for region "
                << reg->GetName()
                << " production cut set to "
                << fProductionCut*CLHEP::mm
                << " mm";

                G4ProductionCuts* cuts = new G4ProductionCuts();
                cuts->SetProductionCut(fProductionCut*CLHEP::mm);
                reg->SetProductionCuts(cuts);

                G4UserLimits* limits = new G4UserLimits();

                if(fMaxStepSize.size() != fDetRegionNames.size())
                limits->SetMaxAllowedStep(2.0*CLHEP::mm);
                else{
                    MF_LOG_INFO("GArG4")
                    << "Setting user limits for region "
                    << reg->GetName()
                    << " max step length set to "
                    << fMaxStepSize.at(index)*CLHEP::mm
                    << " mm";
                    limits->SetMaxAllowedStep(fMaxStepSize.at(index)*CLHEP::mm);
                }

                reg->SetUserLimits(limits);
                index++;
            }
        }

Member Data Documentation

garg4::AuxDetAction* gar::garg4::GArG4::fAuxDetAction

private

Geant4 user action to handle GAr energy depositions.

Definition at line 169 of file GArG4_module.cc.

fhicl::ParameterSet gar::garg4::GArG4::fAuxDetActionPSet

private

configuration for AuxAction

Definition at line 172 of file GArG4_module.cc.

bool gar::garg4::GArG4::fCheckOverlaps

private

Whether to use the G4 overlap checker.

Definition at line 177 of file GArG4_module.cc.

std::vector< std::string > gar::garg4::GArG4::fDetRegionNames

private

Name of the volumes used to defined regions.

Definition at line 173 of file GArG4_module.cc.

bool gar::garg4::GArG4::fdumpParticleList

private

Whether each event's sim::ParticleList will be displayed.

Definition at line 178 of file GArG4_module.cc.

garg4::EnergyDepositAction* gar::garg4::GArG4::fEDepAction

private

Geant4 user action to handle GAr energy depositions.

Definition at line 168 of file GArG4_module.cc.

fhicl::ParameterSet gar::garg4::GArG4::fEDepActionPSet

private

configuration for GArAction

Definition at line 171 of file GArG4_module.cc.

CLHEP::HepRandomEngine& gar::garg4::GArG4::fEngine

private

Definition at line 195 of file GArG4_module.cc.

g4b::G4Helper* gar::garg4::GArG4::fG4Help

private

G4 interface object.

Definition at line 167 of file GArG4_module.cc.

std::string gar::garg4::GArG4::fG4MacroPath

private

executed before main MC processing.

directory path for Geant4 macro file to be

Definition at line 175 of file GArG4_module.cc.

std::string gar::garg4::GArG4::fG4PhysListName

private

predefined physics list to use if not making a custom one

Definition at line 174 of file GArG4_module.cc.

std::vector<std::string> gar::garg4::GArG4::fInputLabels

private

Definition at line 183 of file GArG4_module.cc.

std::vector<std::string> gar::garg4::GArG4::fKeepParticlesInVolumes

private

Only write particles that have trajectories through these volumes.

Definition at line 184 of file GArG4_module.cc.

std::vector<float> gar::garg4::GArG4::fMaxStepSize

private

maximum step size in mm per sub-detector region

Definition at line 181 of file GArG4_module.cc.

garg4::ParticleListAction* gar::garg4::GArG4::fParticleListAction

private

Geant4 user action to particle information.

Definition at line 170 of file GArG4_module.cc.

float gar::garg4::GArG4::fProductionCut

private

G4 will check if a produced particle should travel this far and drop it if not.

Definition at line 182 of file GArG4_module.cc.

int gar::garg4::GArG4::fSmartStacking

private

dictate how tracks are put on stack.

Whether to instantiate and use class to

Definition at line 179 of file GArG4_module.cc.

const geo::GeometryCore* gar::garg4::GArG4::geo

private

Definition at line 191 of file GArG4_module.cc.

---

The documentation for this class was generated from the following file:

• garsoft/GArG4/GArG4_module.cc