GlobalFieldManagerTool Class Reference

Tool for setting up a detector-global magnetic field manager. More...

#include "G4AtlasTools/GlobalFieldManagerTool.h"

Inheritance diagram for GlobalFieldManagerTool:

Collaboration diagram for GlobalFieldManagerTool:

Public Member Functions
	GlobalFieldManagerTool (const std::string &type, const std::string &name, const IInterface *parent)
	Standard constructor.
	~GlobalFieldManagerTool ()
	Empty destructor.
StatusCode	initializeField () override final
	Initialize a field manager.
virtual StatusCode	initialize () override
	Initialize method.

Protected Member Functions
G4MagIntegratorStepper *	getStepper (const std::string &stepperType, G4MagneticField *field) const
	Common method to construct a stepper of requested type.
StatusCode	setFieldParameters (G4FieldManager *fieldMgr) const
	Common method to apply configuredfield parameters.

Protected Attributes
Gaudi::Property< bool >	m_useTightMuonStepping
	Tight muon stepping parameters via the field manager's configure for track.
ServiceHandle< IG4FieldSvc >	m_fieldSvc {this, "FieldSvc", "G4FieldSvc", "Service providing a G4MagneticField"}
	Handle to the G4 field service.
Gaudi::Property< bool >	m_fieldOn {this, "FieldOn", true, "Toggles field on/off"}
Gaudi::Property< std::string >	m_integratorStepper {this, "IntegratorStepper", "AtlasRK4", "Integrator stepper name"}
	The type of stepper to use.
ToolHandle< IEquationOfMotionTool >	m_equationOfMotion {this, "EquationOfMotion", "", ""}
	The type of equation of motion to use.
Field parameters
Gaudi::Property< double >	m_minEps {this, "MinimumEpsilonStep", -1.0, "Minimum epsilon (see G4 documentation)"}
Gaudi::Property< double >	m_maxEps {this, "MaximumEpsilonStep", -1.0, "Maximum epsilon (see G4 documentation)"}
Gaudi::Property< double >	m_deltaChord {this, "DeltaChord", -1.0, "Missing distance for the chord finder"}
Gaudi::Property< double >	m_deltaOneStep {this, "DeltaOneStep", -1.0, "Delta(one-step)"}
Gaudi::Property< double >	m_deltaIntersection {this, "DeltaIntersection", -1.0, "Accuracy for boundary intersection"}
Gaudi::Property< double >	m_maxStep {this, "MaximumStep", -1.0, "Maximum step length in field (see G4 documentation)"}
Gaudi::Property< double >	m_minStep {this, "MinimumStep",1e-2, "Minimum step length in field (see G4 documentation)"}

Detailed Description

Tool for setting up a detector-global magnetic field manager.

Author

Andrea Dell'Acqua

Date

2016-03-25

Definition at line 19 of file GlobalFieldManagerTool.h.

Constructor & Destructor Documentation

GlobalFieldManagerTool()

GlobalFieldManagerTool::GlobalFieldManagerTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Standard constructor.

Definition at line 24 of file GlobalFieldManagerTool.cxx.

  : G4FieldManagerToolBase(type, name, parent)
{
}

~GlobalFieldManagerTool()

GlobalFieldManagerTool::~GlobalFieldManagerTool ( )

inline

Empty destructor.

Definition at line 29 of file GlobalFieldManagerTool.h.

{};

Member Function Documentation

getStepper()

G4MagIntegratorStepper * G4FieldManagerToolBase::getStepper ( const std::string & stepperType, G4MagneticField * field ) const

protectedinherited

Common method to construct a stepper of requested type.

Definition at line 190 of file G4FieldManagerToolBase.cxx.

{
  ATH_MSG_DEBUG("getStepper");
  G4Mag_EqRhs* eqRhs(nullptr);
  if (!m_equationOfMotion.empty())
    {
      eqRhs = m_equationOfMotion->makeEquationOfMotion(field);
      ATH_MSG_INFO("Configuring alternative equation of motion using " <<
                   m_equationOfMotion.name() );
    }
  else
    {
      ATH_MSG_VERBOSE("Using G4Mag_UsualEqRhs as the equation of motion.");
      eqRhs = new G4Mag_UsualEqRhs(field);
    }
  // @TODO Add some way of confirming that the choices of Equation of
  // motion and stepper are compatible.
  // @TODO consider moving the stepper choice into a tool as well?
  // Only worthwhile if we envisage adding more stepper choices in the
  // future.
  if (name=="HelixImplicitEuler") return new G4HelixImplicitEuler(eqRhs);
  else if (name=="HelixSimpleRunge") return new G4HelixSimpleRunge(eqRhs);
  else if (name=="HelixExplicitEuler") return new G4HelixExplicitEuler(eqRhs);
  else if (name=="NystromRK4") return new G4NystromRK4(eqRhs);
  else if (name=="ClassicalRK4") return new G4ClassicalRK4(eqRhs);
  else if (name=="AtlasRK4") return new G4AtlasRK4(eqRhs);
  else if (name=="BogackiShampine23") return new G4BogackiShampine23(eqRhs);
  else if (name=="BogackiShampine45") return new G4BogackiShampine45(eqRhs);
  else if (name=="CashKarpRKF45") return new G4CashKarpRKF45(eqRhs);
  else if (name=="DoLoMcPriRK34") return new G4DoLoMcPriRK34(eqRhs);
  else if (name=="DormandPrince745") return new G4DormandPrince745(eqRhs);
  else if (name=="DormandPrinceRK56") return new G4DormandPrinceRK56(eqRhs);
  else if (name=="DormandPrinceRK78") return new G4DormandPrinceRK78(eqRhs);
  else if (name=="RK547FEq1") return new G4RK547FEq1(eqRhs);
  else if (name=="RK547FEq2") return new G4RK547FEq2(eqRhs);
  else if (name=="RK547FEq3") return new G4RK547FEq3(eqRhs);
  else if (name=="RKG3_Stepper") return new G4RKG3_Stepper(eqRhs);
  else if (name=="TsitourasRK45") return new G4TsitourasRK45(eqRhs);
  else {
    ATH_MSG_ERROR("Stepper " << name << " not available! returning NystromRK4!");
    return new G4NystromRK4(eqRhs);
  }
}

initialize()

StatusCode G4FieldManagerToolBase::initialize ( )

overridevirtualinherited

Initialize method.

Definition at line 62 of file G4FieldManagerToolBase.cxx.

{
  ATH_MSG_DEBUG("G4FieldManagerToolBase::initialize()");
 
  // Skip field svc retrieval if field disabled.
  if(m_fieldOn) {
    ATH_CHECK( m_fieldSvc.retrieve() );
  }
  else {
    ATH_MSG_DEBUG("Field disabled. Not retrieving G4 field svc.");
  }
  if (!m_equationOfMotion.empty())
    {
      ATH_CHECK(m_equationOfMotion.retrieve());
    }
  return StatusCode::SUCCESS;
}

initializeField()

StatusCode GlobalFieldManagerTool::initializeField ( )

finaloverride

Initialize a field manager.

Definition at line 34 of file GlobalFieldManagerTool.cxx.

{
  ATH_MSG_DEBUG("initializeField");
 
  if (m_fieldOn) {
 
    // Retrieve the G4MagneticField
    G4MagneticField* field = m_fieldSvc->getField();
 
    // Retrieve the global field manager
    auto transpManager = G4TransportationManager::GetTransportationManager();
 
    auto* field_manager = [&] () -> G4FieldManager* {
      if (m_useTightMuonStepping){
        // In the case of tight stepping we need to make our own global field manager
        // Create a new field manager
        auto* stepping_field_manager = new TightMuonSteppingFieldManager();
 
        // Assign it to the global field manager
        transpManager->SetFieldManager(stepping_field_manager);
        return stepping_field_manager;
      } else {
        // Otherwise get the default from the transportation manager
        return transpManager->GetFieldManager();
      }
    }();
 
    // Configure the field manager
    field_manager->SetDetectorField(field);
    ATH_CHECK( setFieldParameters(field_manager) );
 
    // Create and configure the ChordFinder
    field_manager->CreateChordFinder(field);
 
#if G4VERSION_NUMBER < 1040
    ATH_MSG_DEBUG("Old style stepper setting");
    G4MagIntegratorStepper* stepper = getStepper(m_integratorStepper, field);
    G4MagInt_Driver* magDriver = field_manager->GetChordFinder()->GetIntegrationDriver();
    magDriver->RenewStepperAndAdjust(stepper);
#else
    ATH_MSG_DEBUG("New style stepper setting");
    G4VIntegrationDriver* driver = createDriverAndStepper(m_integratorStepper, field);
    G4ChordFinder* chordFinder = field_manager->GetChordFinder();
    chordFinder->SetIntegrationDriver(driver);
#endif
 
    // Configure the propagator
    G4PropagatorInField* propagator = transpManager->GetPropagatorInField();
    if (m_maxStep>0) propagator->SetLargestAcceptableStep(m_maxStep);
  }
 
  return StatusCode::SUCCESS;
}

setFieldParameters()

StatusCode G4FieldManagerToolBase::setFieldParameters ( G4FieldManager * fieldMgr ) const

protectedinherited

Common method to apply configuredfield parameters.

Definition at line 238 of file G4FieldManagerToolBase.cxx.

{
  ATH_MSG_DEBUG("setFieldParameters");
  if (fieldMgr) {
    if (m_deltaChord>0) fieldMgr->GetChordFinder()->SetDeltaChord(m_deltaChord);
    if (m_deltaOneStep>0) fieldMgr->SetDeltaOneStep(m_deltaOneStep);
    if (m_deltaIntersection>0) fieldMgr->SetDeltaIntersection(m_deltaIntersection);
 
    auto minEps_actual = m_minEps > 0 ? m_minEps.value() : fieldMgr->GetMinimumEpsilonStep();
    auto maxEps_actual = m_maxEps > 0 ? m_maxEps.value() : fieldMgr->GetMaximumEpsilonStep();
    G4FieldManagerHelper::SetMinAndMaxEpsilonStep(fieldMgr, minEps_actual, maxEps_actual);
  }
  else {
    ATH_MSG_ERROR("setFieldParameters received NULL field mgr!");
    return StatusCode::FAILURE;
  }
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_deltaChord

Gaudi::Property<double> G4FieldManagerToolBase::m_deltaChord {this, "DeltaChord", -1.0, "Missing distance for the chord finder"}

protectedinherited

Definition at line 81 of file G4FieldManagerToolBase.h.

{this, "DeltaChord", -1.0, "Missing distance for the chord finder"};

m_deltaIntersection

Gaudi::Property<double> G4FieldManagerToolBase::m_deltaIntersection {this, "DeltaIntersection", -1.0, "Accuracy for boundary intersection"}

protectedinherited

Definition at line 83 of file G4FieldManagerToolBase.h.

{this, "DeltaIntersection", -1.0, "Accuracy for boundary intersection"};

m_deltaOneStep

Gaudi::Property<double> G4FieldManagerToolBase::m_deltaOneStep {this, "DeltaOneStep", -1.0, "Delta(one-step)"}

protectedinherited

Definition at line 82 of file G4FieldManagerToolBase.h.

{this, "DeltaOneStep", -1.0, "Delta(one-step)"};

m_equationOfMotion

ToolHandle<IEquationOfMotionTool> G4FieldManagerToolBase::m_equationOfMotion {this, "EquationOfMotion", "", ""}

protectedinherited

The type of equation of motion to use.

Definition at line 74 of file G4FieldManagerToolBase.h.

{this, "EquationOfMotion", "", ""};

m_fieldOn

Gaudi::Property<bool> G4FieldManagerToolBase::m_fieldOn {this, "FieldOn", true, "Toggles field on/off"}

protectedinherited

Todo

TODO why is this duplicated in the g4 field svc?

Definition at line 68 of file G4FieldManagerToolBase.h.

{this, "FieldOn", true, "Toggles field on/off"};

m_fieldSvc

ServiceHandle<IG4FieldSvc> G4FieldManagerToolBase::m_fieldSvc {this, "FieldSvc", "G4FieldSvc", "Service providing a G4MagneticField"}

protectedinherited

Handle to the G4 field service.

Definition at line 65 of file G4FieldManagerToolBase.h.

{this, "FieldSvc", "G4FieldSvc", "Service providing a G4MagneticField"};

m_integratorStepper

Gaudi::Property<std::string> G4FieldManagerToolBase::m_integratorStepper {this, "IntegratorStepper", "AtlasRK4", "Integrator stepper name"}

protectedinherited

The type of stepper to use.

Definition at line 71 of file G4FieldManagerToolBase.h.

{this, "IntegratorStepper", "AtlasRK4", "Integrator stepper name"};

m_maxEps

Gaudi::Property<double> G4FieldManagerToolBase::m_maxEps {this, "MaximumEpsilonStep", -1.0, "Maximum epsilon (see G4 documentation)"}

protectedinherited

Definition at line 80 of file G4FieldManagerToolBase.h.

{this, "MaximumEpsilonStep", -1.0, "Maximum epsilon (see G4 documentation)"};

m_maxStep

Gaudi::Property<double> G4FieldManagerToolBase::m_maxStep {this, "MaximumStep", -1.0, "Maximum step length in field (see G4 documentation)"}

protectedinherited

Definition at line 84 of file G4FieldManagerToolBase.h.

{this, "MaximumStep", -1.0, "Maximum step length in field (see G4 documentation)"};

m_minEps

Gaudi::Property<double> G4FieldManagerToolBase::m_minEps {this, "MinimumEpsilonStep", -1.0, "Minimum epsilon (see G4 documentation)"}

protectedinherited

Definition at line 79 of file G4FieldManagerToolBase.h.

{this, "MinimumEpsilonStep", -1.0, "Minimum epsilon (see G4 documentation)"};

m_minStep

Gaudi::Property<double> G4FieldManagerToolBase::m_minStep {this, "MinimumStep",1e-2, "Minimum step length in field (see G4 documentation)"}

protectedinherited

Definition at line 85 of file G4FieldManagerToolBase.h.

{this, "MinimumStep",1e-2, "Minimum step length in field (see G4 documentation)"};

m_useTightMuonStepping

Gaudi::Property<bool> GlobalFieldManagerTool::m_useTightMuonStepping

protected

Initial value:

{this, "UseTightMuonStepping", false,
        "Use tight muon stepping parameters by default"}

Tight muon stepping parameters via the field manager's configure for track.

Definition at line 37 of file GlobalFieldManagerTool.h.

                                              {this, "UseTightMuonStepping", false,
        "Use tight muon stepping parameters by default"};

---

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

• GlobalFieldManagerTool.h
• GlobalFieldManagerTool.cxx