#include <CMSFieldManager.h>

Inheritance diagram for CMSFieldManager:

Public Member Functions
	CMSFieldManager ()

	CMSFieldManager (const CMSFieldManager &)=delete

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 )

CMSFieldManager &	operator= (const CMSFieldManager &)=delete

void	setMonopoleTracking (G4bool)

	~CMSFieldManager () override

Private Member Functions
bool	isInsideTracker (const G4Track *)

bool	isInsideVacuum (const G4Track *)

void	setChordFinderForTracker ()

void	setChordFinderForVacuum ()

void	setDefaultChordFinder ()

Private Attributes
bool	m_cfTracker

bool	m_cfVacuum

G4ChordFinder *	m_chordFinder

G4ChordFinder *	m_chordFinderMonopole

G4ChordFinder *	m_currChordFinder

double	m_dChord

double	m_dChordSimple

double	m_dChordTracker

double	m_dIntersection

double	m_dIntersectionSimple

double	m_dInterTracker

double	m_dOneStep

double	m_dOneStepSimple

double	m_dOneStepTracker

double	m_energyThreshold

double	m_energyThTracker

G4PropagatorInField *	m_propagator

std::vector< const G4Region * >	m_regions

double	m_Rmax2

double	m_stepMax

double	m_stepMaxSimple

double	m_Zmax

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_dChordTracker(0.001),
       m_dOneStep(0.001),
       m_dOneStepTracker(0.0001),
       m_dIntersection(0.0001),
       m_dInterTracker(1e-6),
       m_Rmax2(1.e+6),
       m_Zmax(3.e+3),
       m_stepMax(1000000.),
       m_energyThTracker(1.e+7),
       m_energyThreshold(0.0),
       m_dChordSimple(0.1),
       m_dOneStepSimple(0.1),
       m_dIntersectionSimple(0.01),
       m_stepMaxSimple(1000.),
       m_cfTracker(false),
       m_cfVacuum(false) {}

◆ ~CMSFieldManager()

CMSFieldManager::~CMSFieldManager ( )

override

Definition at line 37 of file CMSFieldManager.cc.

References m_chordFinder, m_chordFinderMonopole, and m_currChordFinder.

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

◆ CMSFieldManager() [2/2]

CMSFieldManager::CMSFieldManager ( const CMSFieldManager & )

delete

Member Function Documentation

◆ ConfigureForTrack()

void CMSFieldManager::ConfigureForTrack ( const G4Track * track )

override

Definition at line 140 of file CMSFieldManager.cc.

References isInsideTracker(), isInsideVacuum(), m_cfTracker, m_cfVacuum, m_energyThreshold, m_energyThTracker, setChordFinderForTracker(), setChordFinderForVacuum(), setDefaultChordFinder(), and HLT_2023v12_cff::track.

Referenced by MonopoleTransportation::AlongStepGetPhysicalInteractionLength().

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

◆ 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 46 of file CMSFieldManager.cc.

References dumpMFGeometry_cfg::delta, createfilelist::int, m_chordFinder, m_chordFinderMonopole, m_dChord, m_dChordSimple, m_dChordTracker, m_dIntersection, m_dIntersectionSimple, m_dInterTracker, m_dOneStep, m_dOneStepSimple, m_dOneStepTracker, m_energyThreshold, m_energyThTracker, m_propagator, m_regions, m_Rmax2, m_stepMax, m_stepMaxSimple, m_Zmax, AlCaHLTBitMon_ParallelJobs::p, packedPFCandidateRefMixer_cfi::pf, setMonopoleTracking(), contentValuesCheck::ss, and theField.

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

                                                                    {
   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_dChordTracker = p.getParameter<double>("DeltaChord") * CLHEP::mm;
   m_dOneStep = p.getParameter<double>("DeltaOneStep") * CLHEP::mm;
   m_dOneStepTracker = p.getParameter<double>("DeltaOneStepTracker") * CLHEP::mm;
   m_dIntersection = p.getParameter<double>("DeltaIntersection") * CLHEP::mm;
   m_dInterTracker = p.getParameter<double>("DeltaIntersectionTracker") * CLHEP::mm;
   m_stepMax = p.getParameter<double>("MaxStep") * CLHEP::cm;
 
   m_energyThreshold = p.getParameter<double>("EnergyThSimple") * CLHEP::GeV;
   m_energyThTracker = p.getParameter<double>("EnergyThTracker") * CLHEP::GeV;
 
   double rmax = p.getParameter<double>("RmaxTracker") * CLHEP::mm;
   m_Rmax2 = rmax * rmax;
   m_Zmax = p.getParameter<double>("ZmaxTracker") * CLHEP::mm;
 
   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"
       << "               DeltaInterTracker           " << m_dInterTracker << " mm\n"
       << "               EnergyThresholdSimple       " << m_energyThreshold / CLHEP::MeV << " MeV\n"
       << "               EnergyThresholdTracker      " << m_energyThTracker / CLHEP::MeV << " 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_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
   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";
   }
 }

◆ isInsideTracker()

bool CMSFieldManager::isInsideTracker ( const G4Track * track )

private

Definition at line 186 of file CMSFieldManager.cc.

References funct::abs(), m_Rmax2, m_Zmax, HLT_2023v12_cff::track, x, and y.

Referenced by ConfigureForTrack().

                                                           {
   const G4ThreeVector &pos = track->GetPosition();
   const double x = pos.x();
   const double y = pos.y();
   return (x * x + y * y < m_Rmax2 && std::abs(pos.z()) < m_Zmax);
 }

◆ isInsideVacuum()

bool CMSFieldManager::isInsideVacuum ( const G4Track * track )

private

Definition at line 174 of file CMSFieldManager.cc.

References m_regions, and HLT_2023v12_cff::track.

Referenced by ConfigureForTrack().

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

◆ operator=()

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

delete

◆ setChordFinderForTracker()

void CMSFieldManager::setChordFinderForTracker ( )

private

Definition at line 205 of file CMSFieldManager.cc.

References m_cfTracker, m_cfVacuum, m_chordFinder, m_currChordFinder, m_dChordTracker, m_dInterTracker, m_dOneStepTracker, m_propagator, and m_stepMax.

Referenced by ConfigureForTrack().

                                                {
   if (m_currChordFinder != m_chordFinder) {
     m_currChordFinder = m_chordFinder;
     SetChordFinder(m_currChordFinder);
   }
   m_currChordFinder->SetDeltaChord(m_dChordTracker);
   SetDeltaOneStep(m_dOneStepTracker);
   SetDeltaIntersection(m_dInterTracker);
   m_propagator->SetLargestAcceptableStep(m_stepMax);
   m_cfVacuum = false;
   m_cfTracker = true;
 }

◆ setChordFinderForVacuum()

void CMSFieldManager::setChordFinderForVacuum ( )

private

Definition at line 218 of file CMSFieldManager.cc.

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

Referenced by ConfigureForTrack().

                                               {
   if (m_currChordFinder != m_chordFinder) {
     m_currChordFinder = m_chordFinder;
     SetChordFinder(m_currChordFinder);
   }
   m_currChordFinder->SetDeltaChord(m_dChordSimple);
   SetDeltaOneStep(m_dOneStepSimple);
   SetDeltaIntersection(m_dIntersectionSimple);
   m_propagator->SetLargestAcceptableStep(m_stepMaxSimple);
   m_cfVacuum = true;
   m_cfTracker = false;
 }

◆ setDefaultChordFinder()

void CMSFieldManager::setDefaultChordFinder ( )

private

Definition at line 193 of file CMSFieldManager.cc.

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

Referenced by ConfigureForTrack(), and setMonopoleTracking().

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

◆ setMonopoleTracking()

void CMSFieldManager::setMonopoleTracking ( G4bool flag )

Definition at line 158 of file CMSFieldManager.cc.

References RemoveAddSevLevel::flag, m_cfTracker, m_cfVacuum, m_chordFinderMonopole, m_currChordFinder, and setDefaultChordFinder().

Referenced by MonopoleTransportation::AlongStepGetPhysicalInteractionLength(), InitialiseForVolume(), and MonopoleTransportation::PostStepDoIt().

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