g4b::G4Helper Class Reference

#include "G4Helper.h"

Public Member Functions
	G4Helper ()
	Standard constructor and destructor for an FMWK module. More...
	G4Helper (std::string const &g4macropath, std::string const &g4physicslist="QGSP_BERT", std::string const &gdmlFile="")
virtual	~G4Helper ()
void	SetParallelWorlds (std::vector< G4VUserParallelWorld * > pworlds)
void	SetVolumeStepLimit (std::string const &volumeName, double maxStepSize)
void	SetOverlapCheck (bool check)
void	SetValidateGDMLSchema (bool validate)
void	ConstructDetector (std::string const &gdmlFile)
void	InitPhysics ()
	Initialization for the Geant4 Monte Carlo. More...
void	SetUserAction ()
	Initialization for the Geant4 Monte Carlo. More...
bool	G4Run (std::vector< const simb::MCTruth * > &primaries)
bool	G4Run (art::Ptr< simb::MCTruth > &primary)
bool	G4Run (const simb::MCTruth *primary)
G4RunManager *	GetRunManager ()

Protected Member Functions
void	SetPhysicsList (std::string physicsList)

Protected Attributes
std::string	fG4MacroPath
	to be executed before main MC processing. More...
std::string	fG4PhysListName
	Name of physics list to use. More...
std::string	fGDMLFile
	Name of the gdml file containing the detector Geometry. More...
bool	fCheckOverlaps
	Have G4GDML check for overlaps? More...
bool	fValidateGDMLSchema
	Have G4GDML validate geometry schema? More...
bool	fUseStepLimits
	Set in SetVolumeStepLimit. More...
G4RunManager *	fRunManager
	Geant4's run manager. More...
G4UImanager *	fUIManager
	Geant4's user-interface manager. More...
ConvertMCTruthToG4 *	fConvertMCTruth
	Geant4 event generator. More...
DetectorConstruction *	fDetector
	DetectorConstruction object. More...
std::vector< G4VUserParallelWorld * >	fParallelWorlds
	list of parallel worlds More...

Detailed Description

Definition at line 47 of file G4Helper.h.

Constructor & Destructor Documentation

g4b::G4Helper::G4Helper

(

)

Standard constructor and destructor for an FMWK module.

Definition at line 51 of file G4Helper.cxx.

References fParallelWorlds.

  : fCheckOverlaps     (false  )
  , fValidateGDMLSchema(false  )
  , fUseStepLimits     (false  )
  , fUIManager         (nullptr)
  , fConvertMCTruth    (nullptr)
  , fDetector          (nullptr)
  {
    fParallelWorlds.clear();
  }

g4b::G4Helper::G4Helper	(	std::string const &	g4macropath,
		std::string const &	g4physicslist = "QGSP_BERT",
		std::string const &	gdmlFile = ""
	)

Definition at line 64 of file G4Helper.cxx.

References fParallelWorlds, fRunManager, and fUIManager.

  : fG4MacroPath       (g4macropath  )
  , fG4PhysListName    (g4physicslist)
  , fGDMLFile          (gdmlFile     )
  , fCheckOverlaps     (false        )
  , fValidateGDMLSchema(true         )
  , fUseStepLimits     (false        )
  , fUIManager         (nullptr      )
  , fConvertMCTruth    (nullptr      )
  , fDetector          (nullptr      )
  {
    // Geant4 run manager.  Nothing happens in Geant4 until this object
    // is created.
    fRunManager = new G4RunManager;

    // Get the pointer to the User Interface manager
    fUIManager = G4UImanager::GetUIpointer();

    fParallelWorlds.clear();
  }

g4b::G4Helper::~G4Helper ( )

virtual

Definition at line 89 of file G4Helper.cxx.

References g4b::UserActionManager::Close(), g4b::UserActionManager::DoesAnyActionProvideStacking(), fParallelWorlds, fRunManager, g4b::UserActionManager::Instance(), MF_LOG_ERROR, and g4b::vm_.

  {
    if( vm_ ) delete vm_;

    if ( fRunManager != 0 ){
      // In SetUserAction(), we set all the G4 user-action classes to be the
      // same action: G4Base::UserActionManager This is convenient, but
      // it creates a problem here: First the G4RunManager deletes the
      // G4UserRunAction, then it tries to delete the
      // G4UserEventAction... but that's the same object, which has
      // already been deleted.  Crash.

      // To keep this from happening, handle the UserActionManager
      // clean-up manually, then tell the G4RunManager that all those
      // classes no longer exist.

      g4b::UserActionManager* uaManager = UserActionManager::Instance();
      bool wasStacking = uaManager->DoesAnyActionProvideStacking();
      uaManager->Close();

      // Each one of these G4RunManager::SetUserAction methods calls a
      // different method, based on the type of the argument.  We want
      // to use "0" (a null pointer), but we have to cast that "0" to a
      // particular type in order for the right SetUserAction method to
      // be called.

      fRunManager->SetUserAction( static_cast<G4UserRunAction*>(0) );
      fRunManager->SetUserAction( static_cast<G4UserEventAction*>(0) );
      fRunManager->SetUserAction( static_cast<G4UserTrackingAction*>(0) );
      fRunManager->SetUserAction( static_cast<G4UserSteppingAction*>(0) );
      if ( wasStacking ) {
        fRunManager->SetUserAction( static_cast<G4UserStackingAction*>(0) );
      }

      delete fRunManager;
    }
    else{
      MF_LOG_ERROR("G4Helper")
      << "G4Helper never initialized; probably because there were no input primary events";
    }

    for(size_t i = 0; i < fParallelWorlds.size(); ++i){
      if(fParallelWorlds[i]) delete fParallelWorlds[i];
    }
    fParallelWorlds.clear();

  }

Member Function Documentation

void g4b::G4Helper::ConstructDetector

(

std::string const &

gdmlFile

)

Definition at line 342 of file G4Helper.cxx.

References fCheckOverlaps, fDetector, and fValidateGDMLSchema.

Referenced by InitPhysics().

  {
    // Build the Geant4 detector description.
    bool checkOverlaps      = fCheckOverlaps;
    bool validateGDMLSchema = fValidateGDMLSchema;
    fDetector = new DetectorConstruction(gdmlFile,
                                         checkOverlaps,
                                         validateGDMLSchema);

    return;
  }

bool g4b::G4Helper::G4Run

(

std::vector< const simb::MCTruth * > &

primaries

)

Definition at line 477 of file G4Helper.cxx.

References g4b::ConvertMCTruthToG4::Append(), fConvertMCTruth, fUIManager, and g4b::ConvertMCTruthToG4::Reset().

Referenced by G4Run().

  {
    // Get the event converter ready.
    fConvertMCTruth->Reset();

    // Pass all the MCTruths to our event generator.
    for(auto primary : primaries)
      fConvertMCTruth->Append( primary );

    // Start the simulation for this event.  Note: The following
    // statement increments the G4RunManager's run number.  Because of
    // this, it's important for events to use the run/event number
    // from the EventDataModel Header, not G4's internal numbers.
    fUIManager->ApplyCommand("/run/beamOn 1");

    return true;
  }

bool g4b::G4Helper::G4Run

(

art::Ptr< simb::MCTruth > &

primary

)

Definition at line 453 of file G4Helper.cxx.

References G4Run(), and art::Ptr< T >::get().

  {
    return this->G4Run( primary.get() );
  }

bool g4b::G4Helper::G4Run

(

const simb::MCTruth *

primary

)

Definition at line 459 of file G4Helper.cxx.

References g4b::ConvertMCTruthToG4::Append(), fConvertMCTruth, fUIManager, and g4b::ConvertMCTruthToG4::Reset().

  {
    // Get the event converter ready.
    fConvertMCTruth->Reset();

    // Pass the MCTruth to our event generator.
    fConvertMCTruth->Append( primary );

    // Start the simulation for this event.  Note: The following
    // statement increments the G4RunManager's run number.  Because of
    // this, it's important for events to use the run/event number
    // from the EventDataModel Header, not G4's internal numbers.
    fUIManager->ApplyCommand("/run/beamOn 1");

    return true;
  }

G4RunManager* g4b::G4Helper::GetRunManager ( )

inline

Definition at line 100 of file G4Helper.h.

{ return fRunManager; }

void g4b::G4Helper::InitPhysics

(

)

Initialization for the Geant4 Monte Carlo.

Definition at line 381 of file G4Helper.cxx.

References ConstructDetector(), fConvertMCTruth, fDetector, fG4PhysListName, fGDMLFile, fParallelWorlds, fRunManager, and SetPhysicsList().

  {
    if(!fDetector) this->ConstructDetector(fGDMLFile);

    for(auto pWorld : fParallelWorlds)
      fDetector->RegisterParallelWorld(pWorld);

    // define the physics list to use
    this->SetPhysicsList(fG4PhysListName);

    // Pass the detector geometry on to Geant4.
    fRunManager->SetUserInitialization(fDetector);

    // Tell the Geant4 run manager how to generate events.  The
    // ConvertMCTruthToG4 class will "generate" events by
    // converting MCTruth objects from the input into G4Events.
    fConvertMCTruth = new ConvertMCTruthToG4;
    fRunManager->SetUserAction(fConvertMCTruth);

    return;
  }

void g4b::G4Helper::SetOverlapCheck ( bool  check )

inline

Definition at line 128 of file G4Helper.h.

{ fCheckOverlaps      = check;    }

void g4b::G4Helper::SetParallelWorlds

(

std::vector< G4VUserParallelWorld * >

pworlds

)

Definition at line 331 of file G4Helper.cxx.

References fParallelWorlds, and MF_LOG_DEBUG.

  {
    for(auto const& pw : pworlds){
      MF_LOG_DEBUG("G4Helper") << pw->GetName();
      fParallelWorlds.push_back(pw);
    }

    return;
  }

void g4b::G4Helper::SetPhysicsList ( std::string  physicsList )

protected

Set up the physics list for Geant4, and pass it to Geant4's run manager. Without a physics list, Geant4 won't do anything. G4 comes with a number of pre-constructed lists, and for now I plan to use "QGSP_BERT". It has the following properties:

• Standard EM physics processes.
• Quark-gluon string model for high energies (> 20GeV)
• Low Energy Parameterized (LEP) for medium energies (10<E<20GeV)
• Gertini-style cascade for low energies (< 10GeV)
• LEP, HEP for all anti-baryons (LEP,HEP = low/high energy parameterized, from GHEISHA)
• Gamma-nuclear model added for E<3.5 GeV (comments from "Guided Tour of Geant4 Physics List II", talk given at JPL by Dennis Wright)

if we decide that QGSP_BERT is not what we want, then we will have to write a new physics list class that derives from G4VUserPhysicsList that does what we want.

Definition at line 138 of file G4Helper.cxx.

References fRunManager, fUIManager, fUseStepLimits, MF_LOG_ERROR, MF_LOG_VERBATIM, and MF_LOG_WARNING.

Referenced by InitPhysics().

  {

    G4VUserPhysicsList* physics = 0;
    std::string bywhom = "User";
    std::string factoryname = "g4alt::G4PhysListFactory";
    bool list_known_ctors = true;

    // physics list name is the first part, anything afterwards is
    // extra physics processes to be added to the base list
    // ie. "QGSP_BERT ; myspace::MonopolePhysics ; MyOtherSpecialPhysics "
    std::vector< std::string > pstrings;
    // don't use ":" as a separator because it's used in namespaces
    boost::algorithm::split( pstrings, physicsString, boost::is_any_of(";"),
                             boost::token_compress_on );
    // trim lead/trail space
    for (unsigned int j=0; j < pstrings.size(); ++j )
      boost::algorithm::trim(pstrings[j]);

    if ( pstrings.size() < 1 ) pstrings.push_back("");  // non-empty
    std::string phListName = pstrings[0];

    //for (unsigned int j=0; j < pstrings.size(); ++j )
    //  std::cout << "G4Helper pstrings[" << j << "] = \""
    //            << pstrings[j] << "\"" << std::endl;

    // user extensible physics list factory
    g4alt::G4PhysListFactory factory;
    factoryname = "g4alt::G4PhysListFactory";

    if ( factory.IsReferencePhysList(phListName) ) {
      bywhom  = factoryname;
      physics = factory.GetReferencePhysList(phListName);
    }
    else {
      // in the case of non-default name
      if ( phListName != "" ) {
        std::cerr << std::endl << factoryname
                  << " failed to find ReferencePhysList \""
                  << phListName << "\"" << std::endl;
        factory.PrintAvailablePhysLists();
/* #else
            std::vector<G4String> list = factory.AvailablePhysLists();
            MF_LOG_VERBATIM("G4Helper")
            << "For reference: PhysicsLists in G4PhysListFactory are: ";
            for (size_t indx=0; indx < list.size(); ++indx ) {
              MF_LOG_VERBATIM("G4Helper")
              << " [" << std::setw(2) << indx << "] "
              << "\"" << list[indx] << "\"";
            }
#endif */
      }

      if ( ! physics ) {
        MF_LOG_ERROR("G4Helper")
          << bywhom << "  could not construct \""
          << phListName
          << "\","
          << std::endl
          << "FAIL hard if we don't succeed"; //"fall back to using QGSP_BERT";

        physics = 0; //new QGSP_BERT; // FAIL if not succeed
        phListName = "<none>"; // "QGSP_BERT";

      } else {
        MF_LOG_VERBATIM("G4Helper")
        << bywhom
        << " constructed G4VUserPhysicsList \""
        << phListName
        << "\"";
      }

    }

    // Extend the physics list with additional physics processes
    // Already used pstrings[0] entry for physics list name.
    // The rest should be semi-colon separated list of:
    //    physicsProcessName ( optional UI command , more UI commands )
    for (unsigned int k=1; k < pstrings.size(); ++k ) {
      std::string physProcAddition = pstrings[k];

      // break off UI commands from process name
      std::vector< std::string > physProcParts;
      boost::algorithm::split( physProcParts, physProcAddition,
                               boost::is_any_of("(,)"),
                               boost::token_compress_on );
      // trim lead/trail spaces
      for (unsigned int j=0; j < physProcParts.size(); ++j )
        boost::algorithm::trim(physProcParts[j]);

      // element 0 is the physics process name
      std::string physProcName = physProcParts[0];
      if ( physProcName == "" ) continue;  // not real, user has trailing ";"

      G4PhysicsConstructorRegistry* pcRegistry =
        G4PhysicsConstructorRegistry::Instance();

      if ( ! pcRegistry->IsKnownPhysicsConstructor(physProcName) ) {

        MF_LOG_VERBATIM("G4Helper")
        << "G4PhysicsProcessFactorySingleton could not "
        << "construct a \""
        << physProcName
        << "\"";

        if ( ! list_known_ctors ) continue;
        // make sure we only do this once
        list_known_ctors = false;
        std::vector<G4String> list = pcRegistry->AvailablePhysicsConstructors();
        MF_LOG_VERBATIM("G4Helper")
        << "For reference: PhysicsProcesses in "
        << "G4PhysicsProcessFactorySingleton are: ";

        if ( list.empty() )
          MF_LOG_VERBATIM("G4Helper")
          << " ... no registered processes";
        else {
          for (size_t indx=0; indx < list.size(); ++indx ) {
            MF_LOG_VERBATIM("G4Helper")
            << " [" << std::setw(2) << indx << "] "
            << "\"" << list[indx] << "\"";
          }
        }
        continue;
      }

      MF_LOG_VERBATIM("G4Helper")
      << "Adding \""
      << physProcName
      << "\" physics process to \""
      << phListName
      << "\"";

      // construct physics process, add it to the base physics list
      G4VPhysicsConstructor* pctor =
        pcRegistry->GetPhysicsConstructor(physProcName);


      G4VModularPhysicsList* mpl = dynamic_cast<G4VModularPhysicsList*>(physics);
      if      ( ! pctor ) MF_LOG_VERBATIM("G4Helper") << " ... failed with null pointer";
      else if ( ! mpl )   MF_LOG_VERBATIM("G4Helper") << " ... failed, physics list wasn't a G4VModularPhysicsList";
      else                mpl->RegisterPhysics(pctor);

      // Handle associated UI commands
      // One must do it here for cases where values need to be set *before*
      // one calls SetUserInitialization(physics)

      for ( unsigned int i=1; i < physProcParts.size(); ++i ) {
        if ( physProcParts[i] == "" ) continue;
        MF_LOG_VERBATIM("G4Helper")
        << physProcParts[i];

        fUIManager->ApplyCommand(physProcParts[i]);
      }

    }

    // User should have called SetVolumeStepLimit before calling this
    // method, otherwise fUseStepLimits is always false.
    if(fUseStepLimits){
      auto mpl = dynamic_cast<G4VModularPhysicsList*>(physics);
      if(mpl) mpl->RegisterPhysics(new G4StepLimiterPhysics());
      else
        MF_LOG_WARNING("G4Helper")
        << "Step limits requested, but unable to register G4StepLimiterPhysics"
        << "\n NO STEP LIMITS WILL BE APPLIED";
    }

    // pass off (possibly augmented) physics list to run manager
    // which calls G4RunManagerKernel->SetPhysics() on it
    //   which itself call ConstructParticle() for the list
    fRunManager->SetUserInitialization(physics);
  }

void g4b::G4Helper::SetUserAction

(

)

Initialization for the Geant4 Monte Carlo.

Tell Geant4 to initialize the run manager. We're ready to simulate events in the detector.

Definition at line 406 of file G4Helper.cxx.

References g4b::UserActionManager::DoesAnyActionProvideStacking(), fG4MacroPath, fRunManager, fUIManager, and g4b::UserActionManager::Instance().

  {
    // Geant4 comes with "user hooks" that allows users to perform
    // special tasks at the beginning and end of runs, events, tracks,
    // steps.  By using the UserActionManager, we've separated each
    // set of user tasks into their own class; e.g., there can be one
    // class for processing particles, one class for histograms, etc.

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

    // Tell the run manager about our user-action classes. We convert
    // the UserActionManager into different types so Geant4's run and
    // event managers will initialize them properly.
    G4UserRunAction*      runAction      = (G4UserRunAction*     ) uaManager;
    G4UserEventAction*    eventAction    = (G4UserEventAction*   ) uaManager;
    G4UserTrackingAction* trackingAction = (G4UserTrackingAction*) uaManager;
    G4UserSteppingAction* steppingAction = (G4UserSteppingAction*) uaManager;
    fRunManager->SetUserAction( runAction      );
    fRunManager->SetUserAction( eventAction    );
    fRunManager->SetUserAction( trackingAction );
    fRunManager->SetUserAction( steppingAction );

    if ( uaManager->DoesAnyActionProvideStacking() ) {
      G4UserStackingAction* stackingAction = (G4UserStackingAction*) uaManager;
      fRunManager->SetUserAction( stackingAction );
    }

    fRunManager->Initialize();

    if(!vm_) vm_ = new G4VisExecutive();
    vm_->Initialize();

    // Tell the manager to execute the contents of the Geant4 macro
    // file.
    if ( ! fG4MacroPath.empty() ) {
      G4String command = "/control/execute " + G4String(fG4MacroPath);
      fUIManager->ApplyCommand(command);
    }


    return;
  }

void g4b::G4Helper::SetValidateGDMLSchema ( bool  validate )

inline

Definition at line 129 of file G4Helper.h.

{ fValidateGDMLSchema = validate; }

void g4b::G4Helper::SetVolumeStepLimit	(	std::string const &	volumeName,
		double	maxStepSize
	)

Definition at line 355 of file G4Helper.cxx.

References fUseStepLimits, and MF_LOG_WARNING.

  {
    // get the logical volume for the desired volume name
    G4LogicalVolume* logVol = G4LogicalVolumeStore::GetInstance()->GetVolume(volumeName);

    if(logVol){
      // the logical volume takes ownership of the G4UserLimits pointer
      G4UserLimits *stepLimit = new G4UserLimits(maxStepSize);
      logVol->SetUserLimits(stepLimit);

      fUseStepLimits = true;
    }
    else{
      MF_LOG_WARNING("G4Helper")
      << "Unable to find volume "
      << volumeName
      << " and set step size limit";
    }

    return;
  }

Member Data Documentation

bool g4b::G4Helper::fCheckOverlaps

protected

Have G4GDML check for overlaps?

Definition at line 113 of file G4Helper.h.

Referenced by ConstructDetector().

ConvertMCTruthToG4* g4b::G4Helper::fConvertMCTruth

protected

Geant4 event generator.

Converts MCTruth objects;

Definition at line 119 of file G4Helper.h.

Referenced by G4Run(), and InitPhysics().

DetectorConstruction* g4b::G4Helper::fDetector

protected

DetectorConstruction object.

Definition at line 121 of file G4Helper.h.

Referenced by ConstructDetector(), and InitPhysics().

std::string g4b::G4Helper::fG4MacroPath

protected

to be executed before main MC processing.

Full directory path for Geant4 macro file

Definition at line 109 of file G4Helper.h.

Referenced by SetUserAction().

std::string g4b::G4Helper::fG4PhysListName

protected

Name of physics list to use.

Definition at line 111 of file G4Helper.h.

Referenced by InitPhysics().

std::string g4b::G4Helper::fGDMLFile

protected

Name of the gdml file containing the detector Geometry.

Definition at line 112 of file G4Helper.h.

Referenced by InitPhysics().

std::vector<G4VUserParallelWorld*> g4b::G4Helper::fParallelWorlds

protected

list of parallel worlds

Definition at line 122 of file G4Helper.h.

Referenced by G4Helper(), InitPhysics(), SetParallelWorlds(), and ~G4Helper().

G4RunManager* g4b::G4Helper::fRunManager

protected

Geant4's run manager.

Definition at line 117 of file G4Helper.h.

Referenced by G4Helper(), InitPhysics(), SetPhysicsList(), SetUserAction(), and ~G4Helper().

G4UImanager* g4b::G4Helper::fUIManager

protected

Geant4's user-interface manager.

Definition at line 118 of file G4Helper.h.

Referenced by G4Helper(), G4Run(), SetPhysicsList(), and SetUserAction().

bool g4b::G4Helper::fUseStepLimits

protected

Set in SetVolumeStepLimit.

Definition at line 115 of file G4Helper.h.

Referenced by SetPhysicsList(), and SetVolumeStepLimit().

bool g4b::G4Helper::fValidateGDMLSchema

protected

Have G4GDML validate geometry schema?

Definition at line 114 of file G4Helper.h.

Referenced by ConstructDetector().

---

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

• nug4/G4Base/G4Helper.h
• nug4/G4Base/G4Helper.cxx