DetectorFieldManagerTool Class Reference

Tool for setting up a volume-local magnetic field manager. More...

#include "G4AtlasTools/DetectorFieldManagerTool.h"

Inheritance diagram for DetectorFieldManagerTool:

Collaboration diagram for DetectorFieldManagerTool:

Public Member Functions
	DetectorFieldManagerTool (const std::string &type, const std::string &name, const IInterface *parent)
	Standard constructor.
	~DetectorFieldManagerTool ()
	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< std::vector< std::string > >	m_logVolumeList {this, "LogicalVolumes", {}, "List of logical volumes to which the field will be applied"}
	List of volumes to assign this field configuration to.
Gaudi::Property< std::vector< std::string > >	m_physVolumeList {this, "PhysicalVolumes", {}, "List of physical volumes to which the field will be applied"}
Gaudi::Property< bool >	m_muonOnlyField {this, "MuonOnlyField", false, "Only muons experience the magnetic field"}
	Option for muons feeling the B-field only.
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 volume-local magnetic field manager.

Author

Andrea Dell'Acqua

Date

2016-03-25

Definition at line 18 of file DetectorFieldManagerTool.h.

Constructor & Destructor Documentation

DetectorFieldManagerTool()

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

Standard constructor.

Definition at line 25 of file DetectorFieldManagerTool.cxx.

  : G4FieldManagerToolBase(type, name, parent)
{
}

~DetectorFieldManagerTool()

DetectorFieldManagerTool::~DetectorFieldManagerTool ( )

inline

Empty destructor.

Definition at line 28 of file DetectorFieldManagerTool.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 DetectorFieldManagerTool::initializeField ( )

finaloverride

Initialize a field manager.

Definition at line 35 of file DetectorFieldManagerTool.cxx.

{
  ATH_MSG_DEBUG("initializeField");
 
  if (m_fieldOn) {
 
    // If field manager already exists for current thread, error.
    // There is no foreseen use-case for this situation.
 
    // Retrieve the G4MagneticField
    G4MagneticField* field = m_fieldSvc->getField();
 
    // Create a new field manager
    G4FieldManager* field_manager = m_muonOnlyField ? new SwitchingFieldManager(field) : new G4FieldManager();
 
    // Configure the field manager
    field_manager->SetDetectorField(field);
    field_manager->CreateChordFinder(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
 
    // Assign the field manager to volumes
    if (!m_logVolumeList.empty()) {
      auto logVolStore = G4LogicalVolumeStore::GetInstance();
      for (const auto& volume: m_logVolumeList) {
        G4LogicalVolume* logicalVolume = logVolStore->GetVolume(volume);
        if (logicalVolume != nullptr) logicalVolume->SetFieldManager(field_manager, true);
        else
          ATH_MSG_WARNING("No volume called " << volume << " was found in the G4LogicalVolumeStore! Skipping this volume.");
      }
    }
    else if (!m_physVolumeList.empty()) {
      auto physVolStore = G4PhysicalVolumeStore::GetInstance();
      for (const auto& volume: m_physVolumeList) {
        G4VPhysicalVolume* physicalVolume = physVolStore->GetVolume(volume);
        if (physicalVolume != nullptr) physicalVolume->GetLogicalVolume()->SetFieldManager(field_manager, true);
        else
          ATH_MSG_WARNING("No volume called " << volume << " was found in the G4PhysicalVolumeStore! Skipping this volume.");
      }
    }
    else
      ATH_MSG_WARNING("No volumes are provided. Field manager is NOT assigned.");
  }
 
  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_logVolumeList

Gaudi::Property<std::vector<std::string> > DetectorFieldManagerTool::m_logVolumeList {this, "LogicalVolumes", {}, "List of logical volumes to which the field will be applied"}

protected

List of volumes to assign this field configuration to.

Definition at line 36 of file DetectorFieldManagerTool.h.

{this, "LogicalVolumes", {}, "List of logical volumes to which the field will be applied"};

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_muonOnlyField

Gaudi::Property<bool> DetectorFieldManagerTool::m_muonOnlyField {this, "MuonOnlyField", false, "Only muons experience the magnetic field"}

protected

Option for muons feeling the B-field only.

Definition at line 40 of file DetectorFieldManagerTool.h.

{this, "MuonOnlyField", false, "Only muons experience the magnetic field"};

m_physVolumeList

Gaudi::Property<std::vector<std::string> > DetectorFieldManagerTool::m_physVolumeList {this, "PhysicalVolumes", {}, "List of physical volumes to which the field will be applied"}

protected

Definition at line 37 of file DetectorFieldManagerTool.h.

{this, "PhysicalVolumes", {}, "List of physical volumes to which the field will be applied"};

---

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

• DetectorFieldManagerTool.h
• DetectorFieldManagerTool.cxx