#include <CMSFieldManager.h>

Inheritance diagram for CMSFieldManager:

Public Member Functions
	CMSFieldManager ()

void	ConfigureForTrack (const G4Track *) override

void	InitialiseForVolume (const edm::ParameterSet &, sim::Field , G4ChordFinder cfDefault, G4ChordFinder cfMonopole, const std::string &vol, const std::string &fieldType, const std::string &stepperName, double delta, G4PropagatorInField )

void	SetMonopoleTracking (G4bool)

	~CMSFieldManager () override

Private Member Functions
	CMSFieldManager (const CMSFieldManager &)=delete

bool	isInsideVacuum (const G4Track *)

CMSFieldManager &	operator= (const CMSFieldManager &)=delete

void	setChordFinderForVacuum ()

void	setDefaultChordFinder ()

Private Attributes
bool	m_cfVacuum

G4ChordFinder *	m_chordFinder

G4ChordFinder *	m_chordFinderMonopole

G4ChordFinder *	m_currChordFinder

double	m_dChord

double	m_dChordSimple

double	m_dIntersection

double	m_dIntersectionSimple

double	m_dOneStep

double	m_dOneStepSimple

double	m_energyThreshold

G4PropagatorInField *	m_propagator

std::vector< const G4Region * >	m_regions

double	m_stepMax

double	m_stepMaxSimple

std::unique_ptr< sim::Field >	theField

Detailed Description

Definition at line 24 of file CMSFieldManager.h.

Constructor & Destructor Documentation

◆ CMSFieldManager() [1/2]

CMSFieldManager::CMSFieldManager ( )

explicit

Definition at line 13 of file CMSFieldManager.cc.

     : G4FieldManager(),
       m_currChordFinder(nullptr),
       m_chordFinder(nullptr),
       m_chordFinderMonopole(nullptr),
       m_propagator(nullptr),
       m_dChord(0.001),
       m_dOneStep(0.001),
       m_dIntersection(0.0001),
       m_stepMax(1000000.),
       m_energyThreshold(0.0),
       m_dChordSimple(0.1),
       m_dOneStepSimple(0.1),
       m_dIntersectionSimple(0.01),
       m_stepMaxSimple(1000.),
       m_cfVacuum(false) {}

◆ ~CMSFieldManager()

CMSFieldManager::~CMSFieldManager ( )

override

Definition at line 30 of file CMSFieldManager.cc.

                                   {
   if (m_chordFinder != m_currChordFinder) {
     delete m_chordFinder;
   }
   if (m_chordFinderMonopole != m_currChordFinder) {
     delete m_chordFinderMonopole;
   }
 }

References m_chordFinder, m_chordFinderMonopole, and m_currChordFinder.

◆ CMSFieldManager() [2/2]

CMSFieldManager::CMSFieldManager ( const CMSFieldManager & )

privatedelete

Member Function Documentation

◆ ConfigureForTrack()

void CMSFieldManager::ConfigureForTrack ( const G4Track * track )

override

Definition at line 125 of file CMSFieldManager.cc.

                                                             {
   // run time parameters per track
   if ((track->GetKineticEnergy() <= m_energyThreshold && track->GetParentID() > 0) || isInsideVacuum(track)) {
     if (!m_cfVacuum) {
       setChordFinderForVacuum();
     }
  
   } else if (m_cfVacuum) {
     // restore defaults
     setDefaultChordFinder();
   }
 }

References isInsideVacuum(), m_cfVacuum, m_energyThreshold, setChordFinderForVacuum(), setDefaultChordFinder(), and HLT_2018_cff::track.

Referenced by MonopoleTransportation::AlongStepGetPhysicalInteractionLength().

◆ InitialiseForVolume()

void CMSFieldManager::InitialiseForVolume	(	const edm::ParameterSet &	p,
		sim::Field *	field,
		G4ChordFinder *	cfDefault,
		G4ChordFinder *	cfMonopole,
		const std::string &	vol,
		const std::string &	fieldType,
		const std::string &	stepperName,
		double	delta,
		G4PropagatorInField *	pf
	)

Definition at line 39 of file CMSFieldManager.cc.

                                                                    {
   double minstep = p.getParameter<double>("MinStep") * CLHEP::mm;
   double minEpsStep = p.getUntrackedParameter<double>("MinimumEpsilonStep", 0.00001) * CLHEP::mm;
   double maxEpsStep = p.getUntrackedParameter<double>("MaximumEpsilonStep", 0.01) * CLHEP::mm;
   int maxLC = (int)p.getUntrackedParameter<double>("MaximumLoopCounts", 1000.);
  
   // double
   m_dChord = p.getParameter<double>("DeltaChord") * CLHEP::mm;
   m_dOneStep = p.getParameter<double>("DeltaOneStep") * CLHEP::mm;
   m_dIntersection = p.getParameter<double>("DeltaIntersection") * CLHEP::mm;
   m_stepMax = p.getParameter<double>("MaxStep") * CLHEP::cm;
  
   m_energyThreshold = p.getParameter<double>("EnergyThSimple") * CLHEP::GeV;
  
   // double
   m_dChordSimple = p.getParameter<double>("DeltaChordSimple") * CLHEP::mm;
   m_dOneStepSimple = p.getParameter<double>("DeltaOneStepSimple") * CLHEP::mm;
   m_dIntersectionSimple = p.getParameter<double>("DeltaIntersectionSimple") * CLHEP::mm;
   m_stepMaxSimple = p.getParameter<double>("MaxStepSimple") * CLHEP::cm;
  
   edm::LogVerbatim("SimG4CoreApplication")
       << " New CMSFieldManager: LogicalVolume:      <" << vol << ">\n"
       << "               Stepper:                   <" << stepper << ">\n"
       << "               Field type                 <" << type << ">\n"
       << "               Field const delta           " << delta << " mm\n"
       << "               MaximumLoopCounts           " << maxLC << "\n"
       << "               MinimumEpsilonStep          " << minEpsStep << "\n"
       << "               MaximumEpsilonStep          " << maxEpsStep << "\n"
       << "               MinStep                     " << minstep << " mm\n"
       << "               MaxStep                     " << m_stepMax / CLHEP::cm << " cm\n"
       << "               DeltaChord                  " << m_dChord << " mm\n"
       << "               DeltaOneStep                " << m_dOneStep << " mm\n"
       << "               DeltaIntersection           " << m_dIntersection << " mm\n"
       << "               EnergyThreshold             " << m_energyThreshold << " MeV\n"
       << "               DeltaChordSimple            " << m_dChordSimple << " mm\n"
       << "               DeltaOneStepSimple          " << m_dOneStepSimple << " mm\n"
       << "               DeltaIntersectionSimple     " << m_dIntersectionSimple << " mm\n"
       << "               MaxStepInVacuum             " << m_stepMaxSimple / CLHEP::cm << " cm";
  
   // initialisation of chord finders
   m_chordFinder = cf;
   m_chordFinderMonopole = cfmon;
  
   //  m_chordFinder->SetDeltaChord(dChord);
   m_chordFinderMonopole->SetDeltaChord(m_dChord);
  
   // initialisation of field manager
   theField.reset(field);
   SetDetectorField(field);
   SetMinimumEpsilonStep(minEpsStep);
   SetMaximumEpsilonStep(maxEpsStep);
  
   // propagater in field
   m_propagator = pf;
   pf->SetMaxLoopCount(maxLC);
   pf->SetMinimumEpsilonStep(minEpsStep);
   pf->SetMaximumEpsilonStep(maxEpsStep);
  
   // initial initialisation the default chord finder is defined
   SetMonopoleTracking(false);
  
   // define regions
   std::vector<std::string> rnames = p.getParameter<std::vector<std::string>>("VacRegions");
   if (!rnames.empty()) {
     std::stringstream ss;
     std::vector<G4Region *> *rs = G4RegionStore::GetInstance();
     for (auto &regnam : rnames) {
       for (auto &reg : *rs) {
         if (regnam == reg->GetName()) {
           m_regions.push_back(reg);
           ss << "  " << regnam;
         }
       }
     }
     edm::LogVerbatim("SimG4CoreApplication") << "Simple field integration in G4Regions:\n" << ss.str() << "\n";
   }
 }

References dumpMFGeometry_cfg::delta, GeV, createfilelist::int, m_chordFinder, m_chordFinderMonopole, m_dChord, m_dChordSimple, m_dIntersection, m_dIntersectionSimple, m_dOneStep, m_dOneStepSimple, m_energyThreshold, m_propagator, m_regions, m_stepMax, m_stepMaxSimple, AlCaHLTBitMon_ParallelJobs::p, packedPFCandidateRefMixer_cfi::pf, SetMonopoleTracking(), contentValuesCheck::ss, and theField.

Referenced by sim::FieldBuilder::configureForVolume().

◆ isInsideVacuum()

bool CMSFieldManager::isInsideVacuum ( const G4Track * track )

private

Definition at line 154 of file CMSFieldManager.cc.

                                                          {
   if (!m_regions.empty()) {
     const G4Region *reg = track->GetVolume()->GetLogicalVolume()->GetRegion();
     for (auto &areg : m_regions) {
       if (reg == areg) {
         return true;
       }
     }
   }
   return false;
 }

References m_regions, and HLT_2018_cff::track.

Referenced by ConfigureForTrack().

◆ operator=()

CMSFieldManager& CMSFieldManager::operator= ( const CMSFieldManager & )

privatedelete

◆ setChordFinderForVacuum()

void CMSFieldManager::setChordFinderForVacuum ( )

private

Definition at line 176 of file CMSFieldManager.cc.

                                               {
   m_currChordFinder->SetDeltaChord(m_dChordSimple);
   SetDeltaOneStep(m_dOneStepSimple);
   SetDeltaIntersection(m_dIntersectionSimple);
   m_propagator->SetLargestAcceptableStep(m_stepMaxSimple);
   m_cfVacuum = true;
 }

References m_cfVacuum, m_currChordFinder, m_dChordSimple, m_dIntersectionSimple, m_dOneStepSimple, m_propagator, and m_stepMaxSimple.

Referenced by ConfigureForTrack().

◆ setDefaultChordFinder()

void CMSFieldManager::setDefaultChordFinder ( )

private

Definition at line 166 of file CMSFieldManager.cc.

                                             {
   m_currChordFinder = m_chordFinder;
   m_currChordFinder->SetDeltaChord(m_dChord);
   SetChordFinder(m_currChordFinder);
   SetDeltaOneStep(m_dOneStep);
   SetDeltaIntersection(m_dIntersection);
   m_propagator->SetLargestAcceptableStep(m_stepMax);
   m_cfVacuum = false;
 }

References m_cfVacuum, m_chordFinder, m_currChordFinder, m_dChord, m_dIntersection, m_dOneStep, m_propagator, and m_stepMax.

Referenced by ConfigureForTrack(), and SetMonopoleTracking().

◆ SetMonopoleTracking()

void CMSFieldManager::SetMonopoleTracking ( G4bool flag )

Definition at line 138 of file CMSFieldManager.cc.

                                                      {
   if (flag) {
     if (m_currChordFinder != m_chordFinderMonopole) {
       if (m_cfVacuum) {
         setDefaultChordFinder();
       }
       m_currChordFinder = m_chordFinderMonopole;
       SetChordFinder(m_currChordFinder);
     }
   } else {
     setDefaultChordFinder();
   }
   SetFieldChangesEnergy(flag);
   m_currChordFinder->ResetStepEstimate();
 }