SteppingAction Class Reference

#include <SteppingAction.h>

Inheritance diagram for SteppingAction:

Public Member Functions
	SteppingAction (EventAction *ea, const edm::ParameterSet &ps, const CMSSteppingVerbose *, bool hasW)
void	UserSteppingAction (const G4Step *aStep) final
	~SteppingAction () override

Public Attributes
SimActivityRegistry::G4StepSignal	m_g4StepSignal

Private Member Functions
bool	initPointer ()
bool	isInsideDeadRegion (const G4Region *reg) const
bool	isLowEnergy (const G4Step *aStep) const
bool	isOutOfTimeWindow (const G4Track *theTrack, const G4Region *reg) const
bool	isThisVolume (const G4VTouchable *touch, const G4VPhysicalVolume *pv) const
void	PrintKilledTrack (const G4Track *, const TrackStatus &) const

Private Attributes
const G4VPhysicalVolume *	calo
std::vector< std::string >	deadRegionNames
std::vector< const G4Region * >	deadRegions
std::vector< double >	ekinMins
std::vector< std::string >	ekinNames
std::vector< std::string >	ekinParticles
std::vector< int >	ekinPDG
std::vector< G4LogicalVolume * >	ekinVolumes
EventAction *	eventAction_
bool	hasWatcher
bool	initialized
bool	killBeamPipe
std::vector< std::string >	maxTimeNames
std::vector< const G4Region * >	maxTimeRegions
double	maxTrackTime
double	maxTrackTimeForward
std::vector< double >	maxTrackTimes
double	maxZCentralCMS
unsigned int	ndeadRegions
unsigned int	numberEkins
unsigned int	numberPart
unsigned int	numberTimes
unsigned int	nWarnings
const CMSSteppingVerbose *	steppingVerbose
double	theCriticalDensity
double	theCriticalEnergyForVacuum
const G4VPhysicalVolume *	tracker

Detailed Description

Definition at line 31 of file SteppingAction.h.

Constructor & Destructor Documentation

SteppingAction()

SteppingAction::SteppingAction ( EventAction *  ea, const edm::ParameterSet &  ps, const CMSSteppingVerbose *  sv, bool  hasW  )

explicit

Definition at line 18 of file SteppingAction.cc.

    : eventAction_(e),
      tracker(nullptr),
      calo(nullptr),
      steppingVerbose(sv),
      nWarnings(0),
      initialized(false),
      killBeamPipe(false),
      hasWatcher(hasW) {
  theCriticalEnergyForVacuum = (p.getParameter<double>("CriticalEnergyForVacuum") * CLHEP::MeV);
  if (0.0 < theCriticalEnergyForVacuum) {
    killBeamPipe = true;
  }
  theCriticalDensity = (p.getParameter<double>("CriticalDensity") * CLHEP::g / CLHEP::cm3);
  maxZCentralCMS = p.getParameter<double>("MaxZCentralCMS") * CLHEP::m;
  maxTrackTime = p.getParameter<double>("MaxTrackTime") * CLHEP::ns;
  maxTrackTimeForward = p.getParameter<double>("MaxTrackTimeForward") * CLHEP::ns;
  maxTrackTimes = p.getParameter<std::vector<double> >("MaxTrackTimes");
  maxTimeNames = p.getParameter<std::vector<std::string> >("MaxTimeNames");
  deadRegionNames = p.getParameter<std::vector<std::string> >("DeadRegions");
  ekinMins = p.getParameter<std::vector<double> >("EkinThresholds");
  ekinNames = p.getParameter<std::vector<std::string> >("EkinNames");
  ekinParticles = p.getParameter<std::vector<std::string> >("EkinParticles");
 
  edm::LogVerbatim("SimG4CoreApplication")
      << "SteppingAction:: KillBeamPipe = " << killBeamPipe
      << " CriticalDensity = " << theCriticalDensity * CLHEP::cm3 / CLHEP::g << " g/cm3\n"
      << "                 CriticalEnergyForVacuum = " << theCriticalEnergyForVacuum / CLHEP::MeV << " Mev;"
      << " MaxTrackTime = " << maxTrackTime / CLHEP::ns << " ns;"
      << " MaxZCentralCMS = " << maxZCentralCMS / CLHEP::m << " m"
      << " MaxTrackTimeForward = " << maxTrackTimeForward / CLHEP::ns << " ns";
 
  numberTimes = maxTrackTimes.size();
  if (numberTimes > 0) {
    for (unsigned int i = 0; i < numberTimes; i++) {
      edm::LogVerbatim("SimG4CoreApplication")
          << "SteppingAction::MaxTrackTime for " << maxTimeNames[i] << " is " << maxTrackTimes[i] << " ns ";
      maxTrackTimes[i] *= ns;
    }
  }
 
  ndeadRegions = deadRegionNames.size();
  if (ndeadRegions > 0) {
    edm::LogVerbatim("SimG4CoreApplication")
        << "SteppingAction: Number of DeadRegions where all trackes are killed " << ndeadRegions;
    for (unsigned int i = 0; i < ndeadRegions; ++i) {
      edm::LogVerbatim("SimG4CoreApplication") << "SteppingAction: DeadRegion " << i << ".  " << deadRegionNames[i];
    }
  }
  numberEkins = ekinNames.size();
  numberPart = ekinParticles.size();
  if (0 == numberPart) {
    numberEkins = 0;
  }
 
  if (numberEkins > 0) {
    edm::LogVerbatim("SimG4CoreApplication")
        << "SteppingAction::Kill following " << numberPart << " particles in " << numberEkins << " volumes";
    for (unsigned int i = 0; i < numberPart; ++i) {
      edm::LogVerbatim("SimG4CoreApplication")
          << "SteppingAction::Particle " << i << " " << ekinParticles[i] << "  Threshold = " << ekinMins[i] << " MeV";
      ekinMins[i] *= CLHEP::MeV;
    }
    for (unsigned int i = 0; i < numberEkins; ++i) {
      edm::LogVerbatim("SimG4CoreApplication") << "SteppingAction::LogVolume[" << i << "] = " << ekinNames[i];
    }
  }
}

References deadRegionNames, ekinMins, ekinNames, ekinParticles, g, mps_fire::i, killBeamPipe, visualization-live-secondInstance_cfg::m, maxTimeNames, maxTrackTime, maxTrackTimeForward, maxTrackTimes, maxZCentralCMS, MeV, ndeadRegions, numberEkins, numberPart, numberTimes, AlCaHLTBitMon_ParallelJobs::p, theCriticalDensity, and theCriticalEnergyForVacuum.

~SteppingAction()

SteppingAction::~SteppingAction ( )

override

Definition at line 87 of file SteppingAction.cc.

{}

Member Function Documentation

initPointer()

bool SteppingAction::initPointer ( )

private

Definition at line 194 of file SteppingAction.cc.

                                 {
  const G4PhysicalVolumeStore* pvs = G4PhysicalVolumeStore::GetInstance();
  if (pvs) {
    std::vector<G4VPhysicalVolume*>::const_iterator pvcite;
    for (pvcite = pvs->begin(); pvcite != pvs->end(); ++pvcite) {
      if ((*pvcite)->GetName() == "Tracker")
        tracker = (*pvcite);
      if ((*pvcite)->GetName() == "CALO")
        calo = (*pvcite);
      if (tracker && calo)
        break;
    }
    if (tracker || calo) {
      edm::LogVerbatim("SimG4CoreApplication") << "Pointer for Tracker " << tracker << " and for Calo " << calo;
      if (tracker)
        LogDebug("SimG4CoreApplication") << "Tracker vol name " << tracker->GetName();
      if (calo)
        LogDebug("SimG4CoreApplication") << "Calorimeter vol name " << calo->GetName();
    }
  }
 
  const G4LogicalVolumeStore* lvs = G4LogicalVolumeStore::GetInstance();
  if (numberEkins > 0) {
    if (lvs) {
      ekinVolumes.resize(numberEkins, nullptr);
      std::vector<G4LogicalVolume*>::const_iterator lvcite;
      for (lvcite = lvs->begin(); lvcite != lvs->end(); ++lvcite) {
        for (unsigned int i = 0; i < numberEkins; ++i) {
          if ((*lvcite)->GetName() == (G4String)(ekinNames[i])) {
            ekinVolumes[i] = (*lvcite);
            break;
          }
        }
      }
    }
    for (unsigned int i = 0; i < numberEkins; ++i) {
      edm::LogVerbatim("SimG4CoreApplication") << ekinVolumes[i]->GetName() << " with pointer " << ekinVolumes[i];
    }
  }
 
  if (numberPart > 0) {
    G4ParticleTable* theParticleTable = G4ParticleTable::GetParticleTable();
    G4String partName;
    ekinPDG.resize(numberPart, 0);
    for (unsigned int i = 0; i < numberPart; ++i) {
      ekinPDG[i] = theParticleTable->FindParticle(partName = ekinParticles[i])->GetPDGEncoding();
      edm::LogVerbatim("SimG4CoreApplication") << "Particle " << ekinParticles[i] << " with PDG code " << ekinPDG[i]
                                               << " and KE cut off " << ekinMins[i] / MeV << " MeV";
    }
  }
 
  const G4RegionStore* rs = G4RegionStore::GetInstance();
  if (numberTimes > 0) {
    maxTimeRegions.resize(numberTimes, nullptr);
    std::vector<G4Region*>::const_iterator rcite;
    for (rcite = rs->begin(); rcite != rs->end(); ++rcite) {
      for (unsigned int i = 0; i < numberTimes; ++i) {
        if ((*rcite)->GetName() == (G4String)(maxTimeNames[i])) {
          maxTimeRegions[i] = (*rcite);
          break;
        }
      }
    }
  }
  if (ndeadRegions > 0) {
    deadRegions.resize(ndeadRegions, nullptr);
    std::vector<G4Region*>::const_iterator rcite;
    for (rcite = rs->begin(); rcite != rs->end(); ++rcite) {
      for (unsigned int i = 0; i < ndeadRegions; ++i) {
        if ((*rcite)->GetName() == (G4String)(deadRegionNames[i])) {
          deadRegions[i] = (*rcite);
          break;
        }
      }
    }
  }
  return true;
}

References calo, deadRegionNames, deadRegions, ekinMins, ekinNames, ekinParticles, ekinPDG, ekinVolumes, mps_fire::i, LogDebug, maxTimeNames, maxTimeRegions, MeV, ndeadRegions, numberEkins, numberPart, numberTimes, FSQDQM_cfi::pvs, and tracker.

Referenced by UserSteppingAction().

isInsideDeadRegion()

bool SteppingAction::isInsideDeadRegion ( const G4Region *  reg ) const

inlineprivate

Definition at line 76 of file SteppingAction.h.

                                                                        {
  bool res = false;
  for (auto& region : deadRegions) {
    if (reg == region) {
      res = true;
      break;
    }
  }
  return res;
}

References deadRegions, and HLT_FULL_cff::region.

Referenced by UserSteppingAction().

isLowEnergy()

bool SteppingAction::isLowEnergy ( const G4Step *  aStep ) const

private

Definition at line 175 of file SteppingAction.cc.

                                                          {
  const G4StepPoint* sp = aStep->GetPostStepPoint();
  const G4LogicalVolume* lv = sp->GetPhysicalVolume()->GetLogicalVolume();
  double ekin = sp->GetKineticEnergy();
  int pCode = aStep->GetTrack()->GetDefinition()->GetPDGEncoding();
 
  for (auto& vol : ekinVolumes) {
    if (lv == vol) {
      for (unsigned int i = 0; i < numberPart; ++i) {
        if (pCode == ekinPDG[i]) {
          return (ekin <= ekinMins[i]);
        }
      }
      break;
    }
  }
  return false;
}

References ekinMins, ekinPDG, ekinVolumes, mps_fire::i, and numberPart.

Referenced by UserSteppingAction().

isOutOfTimeWindow()

bool SteppingAction::isOutOfTimeWindow ( const G4Track *  theTrack, const G4Region *  reg  ) const

inlineprivate

Definition at line 87 of file SteppingAction.h.

                                                                                                {
  double tofM = maxTrackTime;
  for (unsigned int i = 0; i < numberTimes; ++i) {
    if (reg == maxTimeRegions[i]) {
      tofM = maxTrackTimes[i];
      break;
    }
  }
  return (theTrack->GetGlobalTime() > tofM);
}

References mps_fire::i, maxTimeRegions, maxTrackTime, maxTrackTimes, and numberTimes.

Referenced by UserSteppingAction().

isThisVolume()

bool SteppingAction::isThisVolume ( const G4VTouchable *  touch, const G4VPhysicalVolume *  pv  ) const

inlineprivate

Definition at line 98 of file SteppingAction.h.

                                                                                                     {
  int level = (touch->GetHistoryDepth()) + 1;
  return (level >= 3) ? (touch->GetVolume(level - 3) == pv) : false;
}

References personalPlayback::level, and MetAnalyzer::pv().

Referenced by UserSteppingAction().

PrintKilledTrack()

void SteppingAction::PrintKilledTrack ( const G4Track *  aTrack, const TrackStatus &  tst  ) const

private

Definition at line 273 of file SteppingAction.cc.

                                                                                         {
  std::string vname = "";
  std::string rname = "";
  std::string typ = " ";
  switch (tst) {
    case sKilledByProcess:
      typ = " G4Process ";
      break;
    case sDeadRegion:
      typ = " in dead region ";
      break;
    case sOutOfTime:
      typ = " out of time window ";
      break;
    case sLowEnergy:
      typ = " low energy limit ";
      break;
    case sLowEnergyInVacuum:
      typ = " low energy limit in vacuum ";
      break;
    case sEnergyDepNaN:
      typ = " energy deposition is NaN ";
      break;
    case sVeryForward:
      typ = " very forward track ";
      break;
    default:
      break;
  }
  G4VPhysicalVolume* pv = aTrack->GetNextVolume();
  if (pv) {
    vname = pv->GetLogicalVolume()->GetName();
    rname = pv->GetLogicalVolume()->GetRegion()->GetName();
  }
 
  edm::LogVerbatim("SimG4CoreApplication")
      << "Track #" << aTrack->GetTrackID() << " " << aTrack->GetDefinition()->GetParticleName()
      << " E(MeV)= " << aTrack->GetKineticEnergy() / MeV << " T(ns)= " << aTrack->GetGlobalTime() / ns
      << " is killed due to " << typ << " inside LV: " << vname << " (" << rname << ") at " << aTrack->GetPosition();
}

References MeV, MetAnalyzer::pv(), rname, sDeadRegion, sEnergyDepNaN, sKilledByProcess, sLowEnergy, sLowEnergyInVacuum, sOutOfTime, AlCaHLTBitMon_QueryRunRegistry::string, and sVeryForward.

Referenced by UserSteppingAction().

UserSteppingAction()

void SteppingAction::UserSteppingAction ( const G4Step *  aStep )

final

Definition at line 89 of file SteppingAction.cc.

                                                           {
  if (!initialized) {
    initialized = initPointer();
  }
 
  //if(hasWatcher) { m_g4StepSignal(aStep); }
  m_g4StepSignal(aStep);
 
  G4Track* theTrack = aStep->GetTrack();
  TrackStatus tstat = (theTrack->GetTrackStatus() == fAlive) ? sAlive : sKilledByProcess;
 
  const G4StepPoint* preStep = aStep->GetPreStepPoint();
  const G4StepPoint* postStep = aStep->GetPostStepPoint();
 
  // NaN energy deposit
  if (sAlive == tstat && edm::isNotFinite(aStep->GetTotalEnergyDeposit())) {
    tstat = sEnergyDepNaN;
    if (nWarnings < 20) {
      ++nWarnings;
      edm::LogWarning("SimG4CoreApplication")
          << "Track #" << theTrack->GetTrackID() << " " << theTrack->GetDefinition()->GetParticleName()
          << " E(MeV)= " << preStep->GetKineticEnergy() / MeV
          << " is killed due to edep=NaN inside PV: " << preStep->GetPhysicalVolume()->GetName() << " at "
          << theTrack->GetPosition() << " StepLen(mm)= " << aStep->GetStepLength();
    }
  }
 
  // check Z-coordinate
  if (sAlive == tstat && std::abs(theTrack->GetPosition().z()) >= maxZCentralCMS) {
    tstat = (theTrack->GetGlobalTime() > maxTrackTimeForward) ? sOutOfTime : sVeryForward;
  }
 
  // check G4Region
  if (sAlive == tstat && postStep->GetPhysicalVolume() != nullptr) {
    const G4Region* theRegion = preStep->GetPhysicalVolume()->GetLogicalVolume()->GetRegion();
 
    // kill in dead regions
    if (isInsideDeadRegion(theRegion)) {
      tstat = sDeadRegion;
    }
 
    // kill out of time
    if (sAlive == tstat && isOutOfTimeWindow(theTrack, theRegion)) {
      tstat = sOutOfTime;
    }
 
    // kill low-energy in volumes on demand
    if (sAlive == tstat && numberEkins > 0 && isLowEnergy(aStep)) {
      tstat = sLowEnergy;
    }
 
    // kill low-energy in vacuum
    G4double kinEnergy = theTrack->GetKineticEnergy();
    if (sAlive == tstat && killBeamPipe && kinEnergy < theCriticalEnergyForVacuum &&
        theTrack->GetDefinition()->GetPDGCharge() != 0.0 && kinEnergy > 0.0 &&
        theTrack->GetNextVolume()->GetLogicalVolume()->GetMaterial()->GetDensity() <= theCriticalDensity) {
      tstat = sLowEnergyInVacuum;
    }
 
    // check transition tracker/calo
    if (sAlive == tstat || sVeryForward == tstat) {
      if (isThisVolume(preStep->GetTouchable(), tracker) && isThisVolume(postStep->GetTouchable(), calo)) {
        math::XYZVectorD pos((preStep->GetPosition()).x(), (preStep->GetPosition()).y(), (preStep->GetPosition()).z());
 
        math::XYZTLorentzVectorD mom((preStep->GetMomentum()).x(),
                                     (preStep->GetMomentum()).y(),
                                     (preStep->GetMomentum()).z(),
                                     preStep->GetTotalEnergy());
 
        uint32_t id = theTrack->GetTrackID();
 
        std::pair<math::XYZVectorD, math::XYZTLorentzVectorD> p(pos, mom);
        eventAction_->addTkCaloStateInfo(id, p);
      }
    } else {
      theTrack->SetTrackStatus(fStopAndKill);
#ifdef DebugLog
      PrintKilledTrack(theTrack, tstat);
#endif
    }
  }
  if (nullptr != steppingVerbose) {
    steppingVerbose->NextStep(aStep, fpSteppingManager, (1 < tstat));
  }
}

References funct::abs(), EventAction::addTkCaloStateInfo(), calo, eventAction_, initialized, initPointer(), isInsideDeadRegion(), isLowEnergy(), edm::isNotFinite(), isOutOfTimeWindow(), isThisVolume(), killBeamPipe, m_g4StepSignal, maxTrackTimeForward, maxZCentralCMS, MeV, CMSSteppingVerbose::NextStep(), numberEkins, nWarnings, AlCaHLTBitMon_ParallelJobs::p, PrintKilledTrack(), sAlive, sDeadRegion, sEnergyDepNaN, sKilledByProcess, sLowEnergy, sLowEnergyInVacuum, sOutOfTime, steppingVerbose, sVeryForward, theCriticalDensity, theCriticalEnergyForVacuum, tracker, x, y, and z.

Member Data Documentation

calo

const G4VPhysicalVolume * SteppingAction::calo

private

Definition at line 51 of file SteppingAction.h.

Referenced by initPointer(), and UserSteppingAction().

deadRegionNames

std::vector<std::string> SteppingAction::deadRegionNames

private

Definition at line 60 of file SteppingAction.h.

Referenced by initPointer(), and SteppingAction().

deadRegions

std::vector<const G4Region*> SteppingAction::deadRegions

private

Definition at line 62 of file SteppingAction.h.

Referenced by initPointer(), and isInsideDeadRegion().

ekinMins

std::vector<double> SteppingAction::ekinMins

private

Definition at line 58 of file SteppingAction.h.

Referenced by initPointer(), isLowEnergy(), and SteppingAction().

ekinNames

std::vector<std::string> SteppingAction::ekinNames

private

Definition at line 59 of file SteppingAction.h.

Referenced by initPointer(), and SteppingAction().

ekinParticles

std::vector<std::string> SteppingAction::ekinParticles

private

Definition at line 59 of file SteppingAction.h.

Referenced by initPointer(), and SteppingAction().

ekinPDG

std::vector<int> SteppingAction::ekinPDG

private

Definition at line 64 of file SteppingAction.h.

Referenced by initPointer(), and isLowEnergy().

ekinVolumes

std::vector<G4LogicalVolume*> SteppingAction::ekinVolumes

private

Definition at line 63 of file SteppingAction.h.

Referenced by initPointer(), and isLowEnergy().

eventAction_

EventAction* SteppingAction::eventAction_

private

Definition at line 50 of file SteppingAction.h.

Referenced by UserSteppingAction().

hasWatcher

bool SteppingAction::hasWatcher

private

Definition at line 73 of file SteppingAction.h.

initialized

bool SteppingAction::initialized

private

Definition at line 71 of file SteppingAction.h.

Referenced by UserSteppingAction().

killBeamPipe

bool SteppingAction::killBeamPipe

private

Definition at line 72 of file SteppingAction.h.

Referenced by SteppingAction(), and UserSteppingAction().

m_g4StepSignal

SimActivityRegistry::G4StepSignal SteppingAction::m_g4StepSignal

Definition at line 38 of file SteppingAction.h.

Referenced by RunManagerMTWorker::Connect(), RunManager::Connect(), GflashHadronShowerModel::makeHits(), GFlashHadronShowerModel::makeHits(), GFlashEMShowerModel::makeHits(), and UserSteppingAction().

maxTimeNames

std::vector<std::string> SteppingAction::maxTimeNames

private

Definition at line 59 of file SteppingAction.h.

Referenced by initPointer(), and SteppingAction().

maxTimeRegions

std::vector<const G4Region*> SteppingAction::maxTimeRegions

private

Definition at line 61 of file SteppingAction.h.

Referenced by initPointer(), and isOutOfTimeWindow().

maxTrackTime

double SteppingAction::maxTrackTime

private

Definition at line 55 of file SteppingAction.h.

Referenced by isOutOfTimeWindow(), and SteppingAction().

maxTrackTimeForward

double SteppingAction::maxTrackTimeForward

private

Definition at line 56 of file SteppingAction.h.

Referenced by SteppingAction(), and UserSteppingAction().

maxTrackTimes

std::vector<double> SteppingAction::maxTrackTimes

private

Definition at line 58 of file SteppingAction.h.

Referenced by isOutOfTimeWindow(), and SteppingAction().

maxZCentralCMS

double SteppingAction::maxZCentralCMS

private

Definition at line 57 of file SteppingAction.h.

Referenced by SteppingAction(), and UserSteppingAction().

ndeadRegions

unsigned int SteppingAction::ndeadRegions

private

Definition at line 68 of file SteppingAction.h.

Referenced by initPointer(), and SteppingAction().

numberEkins

unsigned int SteppingAction::numberEkins

private

Definition at line 66 of file SteppingAction.h.

Referenced by initPointer(), SteppingAction(), and UserSteppingAction().

numberPart

unsigned int SteppingAction::numberPart

private

Definition at line 67 of file SteppingAction.h.

Referenced by initPointer(), isLowEnergy(), and SteppingAction().

numberTimes

unsigned int SteppingAction::numberTimes

private

Definition at line 65 of file SteppingAction.h.

Referenced by initPointer(), isOutOfTimeWindow(), and SteppingAction().

nWarnings

unsigned int SteppingAction::nWarnings

private

Definition at line 69 of file SteppingAction.h.

Referenced by UserSteppingAction().

steppingVerbose

const CMSSteppingVerbose* SteppingAction::steppingVerbose

private

Definition at line 52 of file SteppingAction.h.

Referenced by UserSteppingAction().

theCriticalDensity

double SteppingAction::theCriticalDensity

private

Definition at line 54 of file SteppingAction.h.

Referenced by SteppingAction(), and UserSteppingAction().

theCriticalEnergyForVacuum

double SteppingAction::theCriticalEnergyForVacuum

private

Definition at line 53 of file SteppingAction.h.

Referenced by SteppingAction(), and UserSteppingAction().

tracker

const G4VPhysicalVolume* SteppingAction::tracker

private

Definition at line 51 of file SteppingAction.h.

Referenced by initPointer(), and UserSteppingAction().