ExtManager Class Reference

It is the main interface for the user to define the setup and start the propagation. More...

#include <ExtManager.h>

Public Member Functions
	~ExtManager ()
	destructor
void	EventTermination (G4ErrorMode)
	Terminate an event and set state to G4ErrorState_Init.
void	RunTermination ()
	Terminate a run and set state to G4ErrorState_Init.
void	Initialize (const char[], const std::string &, double, double, bool, int, const std::vector< std::string > &)
	Initialize Geant4 and Geant4e.
void	InitTrackPropagation (G4ErrorMode)
	Initialize for propagation of a track and set state to G4ErrorState_Propagating.
G4int	PropagateOneStep (G4ErrorTrajState *currentTS, G4ErrorMode mode=G4ErrorMode_PropForwards)
	Propagate a track by one step.
G4ErrorPropagator *	GetPropagator () const
	Get the propagator.

Static Public Member Functions
static ExtManager *	GetManager ()
	Get pointer to the instance of this singleton class (create if needed)

Private Member Functions
	ExtManager ()
	constructor is hidden: user calls ExtManager::GetManager() instead
	ExtManager (ExtManager &)=delete
	copy constructor is undefined for singleton; user calls ExtManager::GetManager() instead
ExtManager &	operator= (ExtManager &)=delete
	Assignment operator is undefined for singleton; user calls ExtManager::GetManager() instead.

Private Attributes
G4ApplicationState	m_G4State
	Initial state of the G4RunManager (=PreInitif FullSimModule not present)
G4ErrorPropagator *	m_Propagator
	Stores pointer to the propagator.
G4RunManager *	m_G4RunMgr
	Pointer to the simulation's G4RunManager (if any)
G4UserTrackingAction *	m_TrackingAction
	Pointer to the simulation's TrackingAction (if any)
G4UserSteppingAction *	m_SteppingAction
	Pointer to the simulation's SteppingAction (if any)
G4VExceptionHandler *	m_StepExceptionHandler
	Pointer to the G4VExceptionHandler used in PropagateOneStep()
G4MagneticField *	m_MagneticField
	Pointer to the (un)cached magnetic field.
G4MagneticField *	m_UncachedField
	Pointer to the uncached magnetic field (might be superseded by its cached version)
G4Mag_UsualEqRhs *	m_MagFldEquation
	Pointer to the equation of motion in the magnetic field (if not the default)
G4MagIntegratorStepper *	m_Stepper
	Pointer to the equation-of-motion stepper (if not the default)
G4ChordFinder *	m_ChordFinder
	Pointer to the equation-of-motion chord finder (if not the default)
G4MagIntegratorStepper *	m_StdStepper
	Pointer to the standard equation-of-motion stepper.
G4EquationOfMotion *	m_ForwardEquationOfMotion
	Pointer to the forward-propagation equation of motion.
G4EquationOfMotion *	m_BackwardEquationOfMotion
	Pointer to the equation of motion that accommodates back-propagation.
G4VisManager *	m_VisManager
	Pointer to the visualization manager (if used)

Static Private Attributes
static ExtManager *	m_Manager = nullptr
	Stores pointer to the singleton class.

Detailed Description

It is the main interface for the user to define the setup and start the propagation.

Initializes GEANT4 for the propagation.

Definition at line 50 of file ExtManager.h.

Constructor & Destructor Documentation

~ExtManager()

~ExtManager

(

)

destructor

Definition at line 100 of file ExtManager.cc.

{
  delete m_StepExceptionHandler;
  if (m_Propagator) { delete m_Propagator; m_Propagator = NULL; }
}

ExtManager()

ExtManager ( )

private

constructor is hidden: user calls ExtManager::GetManager() instead

Definition at line 78 of file ExtManager.cc.

                       :
  m_G4State(G4StateManager::GetStateManager()->GetCurrentState()),
  m_Propagator(nullptr),
  m_G4RunMgr(nullptr),
  m_TrackingAction(nullptr),
  m_SteppingAction(nullptr),
  m_MagneticField(nullptr),
  m_UncachedField(nullptr),
  m_MagFldEquation(nullptr),
  m_Stepper(nullptr),
  m_ChordFinder(nullptr),
  m_StdStepper(nullptr),
  m_ForwardEquationOfMotion(nullptr),
  m_BackwardEquationOfMotion(nullptr),
  m_VisManager(nullptr)
{
  // This flag will be PreInit if FullSimModule is not present
  G4ErrorPropagatorData::GetErrorPropagatorData()->SetState(G4ErrorState_PreInit);
  // Create a private handler for G4Exceptions during PropagateOneStep
  m_StepExceptionHandler = new StepExceptionHandler();
}

Member Function Documentation

EventTermination()

void EventTermination

(

G4ErrorMode

mode

)

Terminate an event and set state to G4ErrorState_Init.

Definition at line 136 of file ExtManager.cc.

{
  G4ErrorPropagatorData::GetErrorPropagatorData()->SetState(G4ErrorState_Init);
  if (m_G4RunMgr) {
    m_G4RunMgr->SetUserAction(m_TrackingAction);
    m_G4RunMgr->SetUserAction(m_SteppingAction);
  }
  if (mode == G4ErrorMode_PropBackwards) {
    if (m_StdStepper) {
      m_StdStepper->SetEquationOfMotion(m_ForwardEquationOfMotion);
    }
  }
}

GetManager()

ExtManager * GetManager ( )

static

Get pointer to the instance of this singleton class (create if needed)

Definition at line 72 of file ExtManager.cc.

{
  if (m_Manager == nullptr) m_Manager = new ExtManager;
  return m_Manager;
}

GetPropagator()

G4ErrorPropagator * GetPropagator ( ) const

inline

Get the propagator.

Definition at line 76 of file ExtManager.h.

{ return m_Propagator; }

Initialize()

void Initialize	(	const char	caller[],
		const std::string &	magneticFieldName,
		double	magneticCacheDistance,
		double	deltaChordInMagneticField,
		bool	enableVisualization,
		int	trackingVerbosity,
		const std::vector< std::string > &	uiCommands
	)

Initialize Geant4 and Geant4e.

Definition at line 176 of file ExtManager.cc.

{
 
  int status = (m_G4State == G4State_PreInit) ? 0 : 2;
 
  if (G4ErrorPropagatorData::GetErrorPropagatorData()->GetState() == G4ErrorState_Init) {
    status += 1;
    if (status == 1) {
      B2INFO("ExtManager::Initialize(): " << caller << " will run without FullSim; the extrapolator has already been initialized");
    } else {
      B2INFO("ExtManager::Initialize(): " << caller << " will run with FullSim; the extrapolator has already been initialized");
    }
    return;
  }
 
  G4FieldManager* fieldManager = G4TransportationManager::GetTransportationManager()->GetFieldManager();
  if (status == 2) {
    m_G4RunMgr = G4RunManager::GetRunManager();
    m_TrackingAction = const_cast<G4UserTrackingAction*>(m_G4RunMgr->GetUserTrackingAction());
    m_SteppingAction = const_cast<G4UserSteppingAction*>(m_G4RunMgr->GetUserSteppingAction());
  } else { // status == 0
 
    RunManager& myRunMgr = RunManager::Instance();
 
    // This is duplicated from FullSimModule::initialize() to use the Geant4/Geant4e
    // machinery for extrapolation only (no simulation)
 
    // Create the magnetic field for the geant4e extrapolation
    if (magneticFieldName != "none") {
      m_MagneticField = new MagneticField();
      if (magneticCacheDistance > 0.0) {
        m_UncachedField = m_MagneticField;
        m_MagneticField = new G4CachedMagneticField(m_UncachedField, magneticCacheDistance);
      }
      fieldManager->SetDetectorField(m_MagneticField);
      if (magneticFieldName != "default") {
 
        //We only use Magnetic field so let's try the specialized steppers
        m_MagFldEquation = new G4Mag_UsualEqRhs(m_MagneticField);
        if (magneticFieldName == "nystrom") {
          m_Stepper = new G4NystromRK4(m_MagFldEquation);
        } else if (magneticFieldName == "expliciteuler") {
          m_Stepper = new G4HelixExplicitEuler(m_MagFldEquation);
        } else if (magneticFieldName == "simplerunge") {
          m_Stepper = new G4HelixSimpleRunge(m_MagFldEquation);
        } else {
          B2FATAL("Unknown magnetic field option: " << magneticFieldName);
        }
 
        //Set a minimum stepsize (stepMinimum): The chordfinder should not attempt to limit
        //the stepsize to something less than 10µm (which is the default value of Geant4).
        m_ChordFinder = new G4ChordFinder(m_MagneticField, 1e-2 * CLHEP::mm, m_Stepper);
        fieldManager->SetChordFinder(m_ChordFinder);
      } else {
        fieldManager->CreateChordFinder(m_MagneticField);
      }
 
      //Change DeltaCord (the max. miss-distance between the trajectory curve and its linear chord(s) approximation, if asked.
      G4ChordFinder* chordFinder = fieldManager->GetChordFinder();
      B2DEBUG(1, "Geant4 default deltaChord = " << chordFinder->GetDeltaChord());
      chordFinder->SetDeltaChord(deltaChordInMagneticField * CLHEP::mm);
      B2DEBUG(1, "DeltaChord after reset = " << chordFinder->GetDeltaChord());
      //This might be a good place to optimize the Integration parameters (DeltaOneStep, DeltaIntersection, MinEpsilon, MaxEpsilon)
    }
 
    //Set the verbosity level of Geant4 according to the logging settings of the module
    int g4VerboseLevel = 0;
    switch (LogSystem::Instance().getCurrentLogLevel()) {
      case LogConfig::c_Debug : g4VerboseLevel = 2;
        break;
      case LogConfig::c_Info  : g4VerboseLevel = 1;
        break;
      default: g4VerboseLevel = 0;
    }
    G4EventManager::GetEventManager()->SetVerboseLevel(g4VerboseLevel);
    G4RunManager::GetRunManager()->SetVerboseLevel(g4VerboseLevel);
    G4EventManager::GetEventManager()->GetTrackingManager()->SetVerboseLevel(
      trackingVerbosity); //turned out to be more useful as a parameter.
    G4LossTableManager::Instance()->SetVerbose(g4VerboseLevel);
 
    if (enableVisualization) {
      m_VisManager = new G4VisExecutive;
      m_VisManager->Initialize();
    }
 
    //Apply the Geant4 UI commands
    if (uiCommands.size() > 0) {
      G4UImanager* uiManager = G4UImanager::GetUIpointer();
      for (std::vector<std::string>::const_iterator iter = uiCommands.begin(); iter != uiCommands.end(); ++iter) {
        uiManager->ApplyCommand(*iter);
      }
    }
 
    // Construct the detector and bare-bones physics list
    myRunMgr.SetUserInitialization(new DetectorConstruction());
    G4Region* region = (*(G4RegionStore::GetInstance()))[0];
    region->SetProductionCuts(G4ProductionCutsTable::GetProductionCutsTable()->GetDefaultProductionCuts());
    myRunMgr.SetUserInitialization(new ExtPhysicsList());
    myRunMgr.Initialize();
    B2INFO("ExtManager::Initialize(): Perform Geant4 final initialization: Geometry optimization, ExtPhysicsList calculations...");
    myRunMgr.beginRun(0);
    B2INFO("ExtManager::Initialize(): done, Geant4 ready (for extrapolation only)");
    G4StateManager::GetStateManager()->SetNewState(G4State_Idle);
  }
 
  // Prepare for the possibility of back-extrapolation
  if (m_MagneticField != NULL) {
    m_StdStepper = const_cast<G4MagIntegratorStepper*>(fieldManager->GetChordFinder()->GetIntegrationDriver()->GetStepper());
    m_ForwardEquationOfMotion = m_StdStepper->GetEquationOfMotion();
    m_BackwardEquationOfMotion = new G4ErrorMag_UsualEqRhs(m_MagneticField);
  }
 
  G4ErrorPropagatorData::GetErrorPropagatorData()->SetState(G4ErrorState_Init);
  if (status == 0) {
    B2INFO("ExtManager::Initialize(): " << caller << " will run without FullSim and has initialized the extrapolator");
  } else {
    B2INFO("ExtManager::Initialize(): " << caller << " will run with FullSim and has initialized the extrapolator");
  }
  return;
}

InitTrackPropagation()

void InitTrackPropagation

(

G4ErrorMode

mode

)

Initialize for propagation of a track and set state to G4ErrorState_Propagating.

Definition at line 106 of file ExtManager.cc.

{
  if (m_G4RunMgr) {
    m_G4RunMgr->SetUserAction((G4UserTrackingAction*)NULL);
    m_G4RunMgr->SetUserAction((G4UserSteppingAction*)NULL);
  }
  if (mode == G4ErrorMode_PropBackwards) {
    if (m_StdStepper) {
      m_StdStepper->SetEquationOfMotion(m_BackwardEquationOfMotion);
    }
  }
  if (m_Propagator == NULL) m_Propagator = new G4ErrorPropagator();
  m_Propagator->SetStepN(0);
  G4ErrorPropagatorData::GetErrorPropagatorData()->SetState(G4ErrorState_Propagating);
}

PropagateOneStep()

G4int PropagateOneStep	(	G4ErrorTrajState *	currentTS,
		G4ErrorMode	mode = G4ErrorMode_PropForwards
	)

Propagate a track by one step.

Definition at line 122 of file ExtManager.cc.

{
  G4ErrorPropagatorData::GetErrorPropagatorData()->SetMode(mode);
  // Remember the existing G4Exception handler
  G4VExceptionHandler* savedHandler = G4StateManager::GetStateManager()->GetExceptionHandler();
  // Set our own exception handler temporarily
  G4StateManager::GetStateManager()->SetExceptionHandler(m_StepExceptionHandler);
  // Propagate one step via geant4e
  G4int result = m_Propagator->PropagateOneStep(currentTS);
  // Restore the saved exception handler
  G4StateManager::GetStateManager()->SetExceptionHandler(savedHandler);
  return result;
}

RunTermination()

void RunTermination

(

)

Terminate a run and set state to G4ErrorState_Init.

Definition at line 150 of file ExtManager.cc.

{
  if (G4ErrorPropagatorData::GetErrorPropagatorData()->GetState() == G4ErrorState_PreInit) return;
 
  if (m_G4RunMgr) {
    m_G4RunMgr->SetUserAction(m_TrackingAction);
    m_G4RunMgr->SetUserAction(m_SteppingAction);
  } else {
    // Copied from FullSimModule
    //We used one Geant4 run for all Belle2 runs so end the geant4 run here
    RunManager& myRunMgr = RunManager::Instance();
    myRunMgr.endRun();
    //And clean up the run manager
    if (m_VisManager) delete m_VisManager;
    myRunMgr.destroy();
    // Delete the objects associated with transport in magnetic field
    if (m_ChordFinder) delete m_ChordFinder;
    if (m_Stepper) delete m_Stepper;
    if (m_MagFldEquation) delete m_MagFldEquation;
    if (m_UncachedField) delete m_UncachedField;
    if (m_MagneticField) delete m_MagneticField;
  }
  if (m_BackwardEquationOfMotion) delete m_BackwardEquationOfMotion;
  G4ErrorPropagatorData::GetErrorPropagatorData()->SetState(G4ErrorState_PreInit);
}

Member Data Documentation

m_BackwardEquationOfMotion

G4EquationOfMotion* m_BackwardEquationOfMotion

private

Pointer to the equation of motion that accommodates back-propagation.

Definition at line 134 of file ExtManager.h.

m_ChordFinder

G4ChordFinder* m_ChordFinder

private

Pointer to the equation-of-motion chord finder (if not the default)

Definition at line 125 of file ExtManager.h.

m_ForwardEquationOfMotion

G4EquationOfMotion* m_ForwardEquationOfMotion

private

Pointer to the forward-propagation equation of motion.

Definition at line 131 of file ExtManager.h.

m_G4RunMgr

G4RunManager* m_G4RunMgr

private

Pointer to the simulation's G4RunManager (if any)

Definition at line 101 of file ExtManager.h.

m_G4State

G4ApplicationState m_G4State

private

Initial state of the G4RunManager (=PreInitif FullSimModule not present)

Definition at line 95 of file ExtManager.h.

m_MagFldEquation

G4Mag_UsualEqRhs* m_MagFldEquation

private

Pointer to the equation of motion in the magnetic field (if not the default)

Definition at line 119 of file ExtManager.h.

m_MagneticField

G4MagneticField* m_MagneticField

private

Pointer to the (un)cached magnetic field.

Definition at line 113 of file ExtManager.h.

m_Manager

ExtManager * m_Manager = nullptr

staticprivate

Stores pointer to the singleton class.

Definition at line 92 of file ExtManager.h.

m_Propagator

G4ErrorPropagator* m_Propagator

private

Stores pointer to the propagator.

Definition at line 98 of file ExtManager.h.

m_StdStepper

G4MagIntegratorStepper* m_StdStepper

private

Pointer to the standard equation-of-motion stepper.

Definition at line 128 of file ExtManager.h.

m_StepExceptionHandler

G4VExceptionHandler* m_StepExceptionHandler

private

Pointer to the G4VExceptionHandler used in PropagateOneStep()

Definition at line 110 of file ExtManager.h.

m_Stepper

G4MagIntegratorStepper* m_Stepper

private

Pointer to the equation-of-motion stepper (if not the default)

Definition at line 122 of file ExtManager.h.

m_SteppingAction

G4UserSteppingAction* m_SteppingAction

private

Pointer to the simulation's SteppingAction (if any)

Definition at line 107 of file ExtManager.h.

m_TrackingAction

G4UserTrackingAction* m_TrackingAction

private

Pointer to the simulation's TrackingAction (if any)

Definition at line 104 of file ExtManager.h.

m_UncachedField

G4MagneticField* m_UncachedField

private

Pointer to the uncached magnetic field (might be superseded by its cached version)

Definition at line 116 of file ExtManager.h.

m_VisManager

G4VisManager* m_VisManager

private

Pointer to the visualization manager (if used)

Definition at line 137 of file ExtManager.h.

---

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

• simulation/kernel/include/ExtManager.h
• simulation/kernel/src/ExtManager.cc