#include <ElectronLimiter.h>

Inheritance diagram for ElectronLimiter:

Public Member Functions
	ElectronLimiter (const edm::ParameterSet &, const G4ParticleDefinition *)

void	InitialiseProcess (const G4ParticleDefinition *) override

G4bool	IsApplicable (const G4ParticleDefinition &) override

G4VParticleChange *	PostStepDoIt (const G4Track &, const G4Step &) override

G4double	PostStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition) override

void	SetFieldCheckFlag (G4bool)

void	SetRangeCheckFlag (G4bool)

void	SetTrackingCutPerRegion (std::vector< const G4Region * > &, std::vector< G4double > &, std::vector< G4double > &, std::vector< G4double > &)

void	StartTracking (G4Track *) override

	~ElectronLimiter () override

Private Attributes
std::vector< G4double >	energyLimits_

std::vector< G4double >	factors_

G4bool	fieldCheckFlag_

G4VEnergyLossProcess *	ionisation_

G4bool	killTrack_

G4double	minStepLimit_

G4int	nRegions_

const G4ParticleDefinition *	particle_

G4bool	rangeCheckFlag_

std::vector< const G4Region * >	regions_

std::vector< G4double >	rms_

CMSTrackingCutModel *	trcut_

Detailed Description

Definition at line 23 of file ElectronLimiter.h.

Constructor & Destructor Documentation

◆ ElectronLimiter()

ElectronLimiter::ElectronLimiter	(	const edm::ParameterSet &	p,
		const G4ParticleDefinition *	part
	)

explicit

Definition at line 19 of file ElectronLimiter.cc.

     : G4VEmProcess("eLimiter", fGeneral),
       ionisation_(nullptr),
       particle_(part),
       nRegions_(0),
       rangeCheckFlag_(false),
       fieldCheckFlag_(false),
       killTrack_(false) {
   // set Process Sub Type
   SetProcessSubType(static_cast<int>(STEP_LIMITER));
   minStepLimit_ = p.getParameter<double>("MinStepLimit") * CLHEP::mm;
   trcut_ = new CMSTrackingCutModel(part);
 }

References minStepLimit_, AlCaHLTBitMon_ParallelJobs::p, and trcut_.

◆ ~ElectronLimiter()

ElectronLimiter::~ElectronLimiter ( )

override

Definition at line 33 of file ElectronLimiter.cc.

33 { delete trcut_; }

References trcut_.

Member Function Documentation

◆ InitialiseProcess()

void ElectronLimiter::InitialiseProcess ( const G4ParticleDefinition * )

override

Definition at line 35 of file ElectronLimiter.cc.

                                                                     {
   G4LossTableManager *lManager = G4LossTableManager::Instance();
   if (rangeCheckFlag_) {
     ionisation_ = lManager->GetEnergyLossProcess(particle_);
     if (!ionisation_) {
       rangeCheckFlag_ = false;
     }
   }
   AddEmModel(0, new G4DummyModel());
  
   if (lManager->IsMaster()) {
     edm::LogVerbatim("SimG4CoreApplication")
         << "ElectronLimiter::BuildPhysicsTable for " << particle_->GetParticleName() << " ioni: " << ionisation_
         << " rangeCheckFlag: " << rangeCheckFlag_ << " fieldCheckFlag: " << fieldCheckFlag_ << " " << nRegions_
         << " regions for tracking cuts\n";
   }
 }

References fieldCheckFlag_, ionisation_, nRegions_, particle_, and rangeCheckFlag_.

◆ IsApplicable()

G4bool ElectronLimiter::IsApplicable ( const G4ParticleDefinition & )

override

Definition at line 107 of file ElectronLimiter.cc.

107 { return true; }

◆ PostStepDoIt()

G4VParticleChange * ElectronLimiter::PostStepDoIt	(	const G4Track &	aTrack,
		const G4Step &
	)

override

Definition at line 96 of file ElectronLimiter.cc.

                                                                                       {
   fParticleChange.Initialize(aTrack);
   if (killTrack_) {
     fParticleChange.ProposeTrackStatus(fStopAndKill);
     G4double edep = trcut_->SampleEnergyDepositEcal(aTrack.GetKineticEnergy());
     fParticleChange.ProposeLocalEnergyDeposit(edep);
     fParticleChange.SetProposedKineticEnergy(0.0);
   }
   return &fParticleChange;
 }

References killTrack_, CMSTrackingCutModel::SampleEnergyDepositEcal(), and trcut_.

◆ PostStepGetPhysicalInteractionLength()

G4double ElectronLimiter::PostStepGetPhysicalInteractionLength	(	const G4Track &	track,
		G4double	previousStepSize,
		G4ForceCondition *	condition
	)

override

Definition at line 53 of file ElectronLimiter.cc.

                                                                                             {
   *condition = NotForced;
   G4double limit = DBL_MAX;
   killTrack_ = false;
  
   G4double kinEnergy = aTrack.GetKineticEnergy();
   if (0 < nRegions_) {
     if (regions_[0] == nullptr) {
       if (kinEnergy < energyLimits_[0]) {
         killTrack_ = true;
         trcut_->InitialiseForStep(factors_[0], rms_[0]);
         limit = 0.0;
       }
     } else {
       const G4Region *reg = aTrack.GetVolume()->GetLogicalVolume()->GetRegion();
       for (G4int i = 0; i < nRegions_; ++i) {
         if (reg == regions_[i] && kinEnergy < energyLimits_[i]) {
           killTrack_ = true;
           trcut_->InitialiseForStep(factors_[i], rms_[i]);
           limit = 0.0;
           break;
         }
       }
     }
   }
   if (!killTrack_ && rangeCheckFlag_) {
     G4double safety = aTrack.GetStep()->GetPreStepPoint()->GetSafety();
     if (safety > std::min(minStepLimit_, previousLimit)) {
       G4double range = ionisation_->GetRange(kinEnergy, aTrack.GetMaterialCutsCouple());
       if (safety >= range) {
         killTrack_ = true;
         limit = 0.0;
       }
     }
   }
   if (!killTrack_ && fieldCheckFlag_) {
     limit = minStepLimit_;
   }
   return limit;
 }

References energyLimits_, factors_, fieldCheckFlag_, mps_fire::i, CMSTrackingCutModel::InitialiseForStep(), ionisation_, killTrack_, remoteMonitoring_LED_IterMethod_cfg::limit, min(), minStepLimit_, nRegions_, FastTimerService_cff::range, rangeCheckFlag_, regions_, rms_, and trcut_.

◆ SetFieldCheckFlag()

void ElectronLimiter::SetFieldCheckFlag ( G4bool val )

inline

Definition at line 70 of file ElectronLimiter.h.

70 { fieldCheckFlag_ = val; }

References fieldCheckFlag_, and heppy_batch::val.

Referenced by ParametrisedEMPhysics::ConstructProcess().

◆ SetRangeCheckFlag()

void ElectronLimiter::SetRangeCheckFlag ( G4bool val )

inline

Definition at line 68 of file ElectronLimiter.h.

68 { rangeCheckFlag_ = val; }

References rangeCheckFlag_, and heppy_batch::val.

Referenced by ParametrisedEMPhysics::ConstructProcess().

◆ SetTrackingCutPerRegion()

void ElectronLimiter::SetTrackingCutPerRegion	(	std::vector< const G4Region * > &	reg,
		std::vector< G4double > &	cut,
		std::vector< G4double > &	fac,
		std::vector< G4double > &	rms
	)

Definition at line 111 of file ElectronLimiter.cc.

                                                                         {
   nRegions_ = reg.size();
   if (nRegions_ > 0) {
     regions_ = reg;
     energyLimits_ = cut;
     factors_ = fac;
     rms_ = rms;
   }
 }