ElectronLimiter Class Reference

#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.

References minStepLimit_, AlCaHLTBitMon_ParallelJobs::p, and trcut_.

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

~ElectronLimiter()

ElectronLimiter::~ElectronLimiter ( )

override

Definition at line 33 of file ElectronLimiter.cc.

References trcut_.

{ delete trcut_; }

Member Function Documentation

InitialiseProcess()

void ElectronLimiter::InitialiseProcess ( const G4ParticleDefinition *  )

override

Definition at line 35 of file ElectronLimiter.cc.

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

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

IsApplicable()

G4bool ElectronLimiter::IsApplicable ( const G4ParticleDefinition &  )

override

Definition at line 107 of file ElectronLimiter.cc.

{ return true; }

PostStepDoIt()

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

override

Definition at line 96 of file ElectronLimiter.cc.

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

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

PostStepGetPhysicalInteractionLength()

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

override

Definition at line 53 of file ElectronLimiter.cc.

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

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

SetFieldCheckFlag()

void ElectronLimiter::SetFieldCheckFlag ( G4bool  val )

inline

Definition at line 70 of file ElectronLimiter.h.

References fieldCheckFlag_, and heppy_batch::val.

Referenced by ParametrisedEMPhysics::ConstructProcess().

{ fieldCheckFlag_ = val; }

SetRangeCheckFlag()

void ElectronLimiter::SetRangeCheckFlag ( G4bool  val )

inline

Definition at line 68 of file ElectronLimiter.h.

References rangeCheckFlag_, and heppy_batch::val.

Referenced by ParametrisedEMPhysics::ConstructProcess().

{ rangeCheckFlag_ = val; }

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.

References DMR_cfg::cut, energyLimits_, factors_, nRegions_, regions_, SiStripPI::rms, and rms_.

Referenced by ParametrisedEMPhysics::ConstructProcess().

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

StartTracking()

void ElectronLimiter::StartTracking ( G4Track *  )

override

Definition at line 109 of file ElectronLimiter.cc.

{}

Member Data Documentation

energyLimits_

std::vector<G4double> ElectronLimiter::energyLimits_

private

Definition at line 56 of file ElectronLimiter.h.

Referenced by PostStepGetPhysicalInteractionLength(), and SetTrackingCutPerRegion().

factors_

std::vector<G4double> ElectronLimiter::factors_

private

Definition at line 57 of file ElectronLimiter.h.

Referenced by PostStepGetPhysicalInteractionLength(), and SetTrackingCutPerRegion().

fieldCheckFlag_

G4bool ElectronLimiter::fieldCheckFlag_

private

Definition at line 64 of file ElectronLimiter.h.

Referenced by InitialiseProcess(), PostStepGetPhysicalInteractionLength(), and SetFieldCheckFlag().

ionisation_

G4VEnergyLossProcess* ElectronLimiter::ionisation_

private

Definition at line 51 of file ElectronLimiter.h.

Referenced by InitialiseProcess(), and PostStepGetPhysicalInteractionLength().

killTrack_

G4bool ElectronLimiter::killTrack_

private

Definition at line 65 of file ElectronLimiter.h.

Referenced by PostStepDoIt(), and PostStepGetPhysicalInteractionLength().

minStepLimit_

G4double ElectronLimiter::minStepLimit_

private

Definition at line 60 of file ElectronLimiter.h.

Referenced by ElectronLimiter(), and PostStepGetPhysicalInteractionLength().

nRegions_

G4int ElectronLimiter::nRegions_

private

Definition at line 62 of file ElectronLimiter.h.

Referenced by InitialiseProcess(), PostStepGetPhysicalInteractionLength(), and SetTrackingCutPerRegion().

particle_

const G4ParticleDefinition* ElectronLimiter::particle_

private

Definition at line 53 of file ElectronLimiter.h.

Referenced by InitialiseProcess().

rangeCheckFlag_

G4bool ElectronLimiter::rangeCheckFlag_

private

Definition at line 63 of file ElectronLimiter.h.

Referenced by InitialiseProcess(), PostStepGetPhysicalInteractionLength(), and SetRangeCheckFlag().

regions_

std::vector<const G4Region *> ElectronLimiter::regions_

private

Definition at line 55 of file ElectronLimiter.h.

Referenced by PostStepGetPhysicalInteractionLength(), and SetTrackingCutPerRegion().

rms_

std::vector<G4double> ElectronLimiter::rms_

private

Definition at line 58 of file ElectronLimiter.h.

Referenced by PostStepGetPhysicalInteractionLength(), and SetTrackingCutPerRegion().

trcut_

CMSTrackingCutModel* ElectronLimiter::trcut_

private

Definition at line 52 of file ElectronLimiter.h.

Referenced by ElectronLimiter(), PostStepDoIt(), PostStepGetPhysicalInteractionLength(), and ~ElectronLimiter().