#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 22 of file CMSFieldManager.h.

Constructor & Destructor Documentation

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 ( )

override

Definition at line 21 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::CMSFieldManager ( const CMSFieldManager & )

privatedelete

Member Function Documentation

void CMSFieldManager::ConfigureForTrack ( const G4Track * track )

override

Definition at line 114 of file CMSFieldManager.cc.

References isInsideVacuum(), m_cfVacuum, m_energyThreshold, setChordFinderForVacuum(), and setDefaultChordFinder().

Referenced by MonopoleTransportation::AlongStepGetPhysicalInteractionLength().

 {
   // 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(); 
   }
 } 

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

References edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), 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, packedPFCandidateRefMixer_cfi::pf, SetMonopoleTracking(), 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_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";
   }
 }

bool CMSFieldManager::isInsideVacuum ( const G4Track * track )

private

Definition at line 142 of file CMSFieldManager.cc.

References m_regions.

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;
 }

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

privatedelete

void CMSFieldManager::setChordFinderForVacuum ( )

private

Definition at line 164 of file CMSFieldManager.cc.

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

Referenced by ConfigureForTrack().

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

void CMSFieldManager::setDefaultChordFinder ( )

private

Definition at line 153 of file CMSFieldManager.cc.

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

Referenced by ConfigureForTrack(), and SetMonopoleTracking().

 {
   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;
 }

void CMSFieldManager::SetMonopoleTracking ( G4bool flag )

Definition at line 127 of file CMSFieldManager.cc.

References 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_cfVacuum) { setDefaultChordFinder(); }
       m_currChordFinder = m_chordFinderMonopole;
       SetChordFinder(m_currChordFinder);
     }
   } else { 
     setDefaultChordFinder();
   }
   SetFieldChangesEnergy(flag);
   m_currChordFinder->ResetStepEstimate();
 }