ATLAS Offline Software
Public Member Functions | Private Attributes | List of all members
FastCaloSim Class Reference

#include <FastCaloSim.h>

Inheritance diagram for FastCaloSim:
Collaboration diagram for FastCaloSim:

Public Member Functions

 FastCaloSim (const std::string &name, G4Region *region, const ServiceHandle< IAthRNGSvc > &rndmGenSvc, const std::string &randomEngineName, const PublicToolHandle< IFastCaloSimCaloTransportation > &FastCaloSimCaloTransportation, const PublicToolHandle< IFastCaloSimCaloExtrapolation > &FastCaloSimCaloExtrapolation, const PublicToolHandle< IG4CaloTransportTool > &G4CaloTransportTool, const PublicToolHandle< IPunchThroughSimWrapper > &PunchThroughSimWrapper, const ServiceHandle< ISF::IFastCaloSimParamSvc > &FastCaloSimSvc, const std::string &CaloCellContainerSDName, bool doG4Transport, bool doPunchThrough, FastCaloSimTool *FastCaloSimTool)
 
 ~FastCaloSim ()
 
G4bool IsApplicable (const G4ParticleDefinition &) override final
 
void DoIt (const G4FastTrack &, G4FastStep &) override final
 
void StartOfAthenaEvent (const EventContext &ctx)
 
void EndOfAthenaEvent (const EventContext &ctx)
 
G4bool ModelTrigger (const G4FastTrack &) override final
 Determines the applicability of the fast sim model to this particular track. More...
 
CaloCellContainerSDgetCaloCellContainerSD ()
 Retrieves the associated sensitive detector responsible for writing out the CaloCellContainer. More...
 
G4bool passedIDCaloBoundary (const G4FastTrack &fastTrack)
 Check if the particle is located at the proper ID-Calo parametrization boundary and is travelling outwards from the ID to the CALO. More...
 

Private Attributes

ServiceHandle< IAthRNGSvcm_rndmGenSvc
 
std::string m_randomEngineName
 
ATHRNG::RNGWrapperm_rngWrapper {}
 
PublicToolHandle< IFastCaloSimCaloTransportationm_FastCaloSimCaloTransportation
 
PublicToolHandle< IFastCaloSimCaloExtrapolationm_FastCaloSimCaloExtrapolation
 
PublicToolHandle< IG4CaloTransportToolm_G4CaloTransportTool
 
PublicToolHandle< IPunchThroughSimWrapperm_PunchThroughSimWrapper
 
ServiceHandle< ISF::IFastCaloSimParamSvcm_FastCaloSimSvc
 
std::string m_CaloCellContainerSDName
 
bool m_doG4Transport
 
bool m_doPunchThrough
 
FastCaloSimToolm_FastCaloSimTool
 

Detailed Description

Definition at line 33 of file FastCaloSim.h.

Constructor & Destructor Documentation

◆ FastCaloSim()

FastCaloSim::FastCaloSim ( const std::string &  name,
G4Region *  region,
const ServiceHandle< IAthRNGSvc > &  rndmGenSvc,
const std::string &  randomEngineName,
const PublicToolHandle< IFastCaloSimCaloTransportation > &  FastCaloSimCaloTransportation,
const PublicToolHandle< IFastCaloSimCaloExtrapolation > &  FastCaloSimCaloExtrapolation,
const PublicToolHandle< IG4CaloTransportTool > &  G4CaloTransportTool,
const PublicToolHandle< IPunchThroughSimWrapper > &  PunchThroughSimWrapper,
const ServiceHandle< ISF::IFastCaloSimParamSvc > &  FastCaloSimSvc,
const std::string &  CaloCellContainerSDName,
bool  doG4Transport,
bool  doPunchThrough,
FastCaloSimTool FastCaloSimTool 
)

Definition at line 35 of file FastCaloSim.cxx.

49 : G4VFastSimulationModel(name, region),
50  m_rndmGenSvc(rndmGenSvc), m_randomEngineName(randomEngineName),
55  m_FastCaloSimSvc(FastCaloSimSvc),
56  m_CaloCellContainerSDName(CaloCellContainerSDName),
57  m_doG4Transport(doG4Transport),
58  m_doPunchThrough(doPunchThrough),
60 {
61 }

◆ ~FastCaloSim()

FastCaloSim::~FastCaloSim ( )
inline

Definition at line 50 of file FastCaloSim.h.

50 {}

Member Function Documentation

◆ DoIt()

void FastCaloSim::DoIt ( const G4FastTrack &  fastTrack,
G4FastStep &  fastStep 
)
finaloverride

Definition at line 181 of file FastCaloSim.cxx.

182 {
183 
185  TFCSTruthState truthState;
186  TFCSExtrapolationState extrapolState;
187 
188  // Get Geant4 primary track
189  const G4Track * G4PrimaryTrack = fastTrack.GetPrimaryTrack();
190  // Get Geant4 particle definition
191  const G4ParticleDefinition * G4Particle = G4PrimaryTrack -> GetDefinition();
192  // Get Geant4 particle pdgID
193  signed int pdgID = G4Particle -> GetPDGEncoding();
194 
195  // Do not simulate particles below 10 MeV
196  if(G4PrimaryTrack -> GetKineticEnergy() < 10){
197  #ifdef FCS_DEBUG
198  G4cout<<"[FastCaloSim::DoIt] Skipping particle with Ekin: " << G4PrimaryTrack -> GetKineticEnergy() <<" MeV. Below the 10 MeV threshold"<<G4endl;
199  #endif
200  fastStep.KillPrimaryTrack();
201  return;
202  }
203  // Decide on which FastCaloSim parametrization to use (electron, photon or pion)
204  if(G4Particle == G4Electron::Definition() || G4Particle == G4Positron::Definition() || G4Particle == G4Gamma::Definition())
205  {
206  // Use egamma parametrization for simulation of electrons and photons
207  truthState.set_pdgid(pdgID);
208  }
209  else{
210  // Use pion parametrization for simulation of all hadrons
211  truthState.set_pdgid(G4PionPlus::Definition() -> GetPDGEncoding());
212  }
213 
214  // Set the kinematics of the FastCaloSim truth state
215  truthState.SetPtEtaPhiM(G4PrimaryTrack -> GetMomentum().perp(),
216  G4PrimaryTrack -> GetMomentum().eta(),
217  G4PrimaryTrack -> GetMomentum().phi(),
218  G4Particle -> GetPDGMass());
219 
220  // Set the vertex of the FastCaloSim truth state
221  truthState.set_vertex(G4PrimaryTrack -> GetPosition().x(),
222  G4PrimaryTrack -> GetPosition().y(),
223  G4PrimaryTrack -> GetPosition().z());
224 
225 
226  /* For anti protons and anti-neutrons the kinetic energy should be
227  calculated as Ekin = E() + M() instead of E() - M() this is
228  achieved by setting an Ekin offset of 2*M() to the truth state */
229  if(pdgID == -2212 || pdgID == -2112) truthState.set_Ekin_off(2 * G4Particle -> GetPDGMass());
230 
231 
232  // Perform particle transportation through calorimeter system eiher with ATLAS tracking tools or with Geant4
233  std::vector<G4FieldTrack> caloSteps = m_doG4Transport ? m_G4CaloTransportTool -> transport(*G4PrimaryTrack)
234  : m_FastCaloSimCaloTransportation -> transport(&truthState, false);
235 
236  // Extrapolate transported stepos to ID-Calo boundary and all layers of the calorimeter system
237  m_FastCaloSimCaloExtrapolation->extrapolate(extrapolState, &truthState, caloSteps);
238 
239  // Do not simulate further if extrapolation to ID - Calo boundary fails
240  if(extrapolState.IDCaloBoundary_eta() == -999){
241  #ifdef FCS_DEBUG
242  G4cout<<"[FastCaloSim::DoIt] Killing particle as extrapolation failed"<<G4endl;
243  #endif
244  fastStep.KillPrimaryTrack();
245  return;
246  }
247  // Perform the actual FastCaloSim simulation
248  if(m_FastCaloSimSvc->simulate(simState, &truthState, &extrapolState).isFailure()){
249  G4Exception("FastCaloSimSvc", "FailedSimulationCall", FatalException, "FastCaloSimSvc: Simulation call failed.");
250  abort();
251  }
252 
253  #ifdef FCS_DEBUG
254  G4cout<<"[FastCaloSim::DoIt] pdgID of G4PrimaryTrack: " << pdgID << G4endl;
255  G4cout<<"[FastCaloSim::DoIt] Energy returned: " << simState.E() << G4endl;
256  G4cout<<"[FastCaloSim::DoIt] Energy fraction for layer: " << G4endl;
257  for (int s = 0; s < 24; s++) G4cout<<"[FastCaloSim::DoIt] Sampling " << s << " energy " << simState.E(s) << G4endl;
258  #endif
259 
260  // Retrieve the associated CaloCellContainer sensitive detector
261  CaloCellContainerSD * caloCellContainerSD = getCaloCellContainerSD();
262  // Record the cells
263  caloCellContainerSD->recordCells(simState);
264 
265  // Do punchthrough here (secondaries), after the main simulation
266  if (m_doPunchThrough){
267  // necessary for determining particle type and properties (mass etc)
268  G4ParticleTable *ptable = G4ParticleTable::GetParticleTable();
269 
270  // Get simulated energy
271  const double simE = simState.E();
272 
273  // Get energy fraction in layers into vector
274  std::vector<double> simEfrac;
275  for (unsigned int i = 0; i < 24; i++){simEfrac.push_back(simState.Efrac(i));}
276 
277  // run actual method (no return, it will do fastStep.CreateSecondaryTrack(...) under the hood)
278  m_PunchThroughSimWrapper->DoPunchThroughSim(*ptable, m_rngWrapper, simE, simEfrac, fastTrack, fastStep);
279  }
280 
281  // Clean up the auxiliary info from the simulation state
282  simState.DoAuxInfoCleanup();
283 
284  // Finally kill the primary track after all simulation steps done
285  fastStep.KillPrimaryTrack();
286  fastStep.ProposePrimaryTrackPathLength(0.0);
287 }

◆ EndOfAthenaEvent()

void FastCaloSim::EndOfAthenaEvent ( const EventContext &  ctx)

Definition at line 71 of file FastCaloSim.cxx.

71  {
72 
73  return;
74 }

◆ getCaloCellContainerSD()

CaloCellContainerSD * FastCaloSim::getCaloCellContainerSD ( )

Retrieves the associated sensitive detector responsible for writing out the CaloCellContainer.

Definition at line 289 of file FastCaloSim.cxx.

289  {
290 
291  G4SDManager *sdm = G4SDManager::GetSDMpointer();
292  G4VSensitiveDetector * vsd = sdm->FindSensitiveDetector((G4String)m_CaloCellContainerSDName);
293 
294  if (!vsd){
295  G4Exception("FastCaloSimSvc", "FailedFindSensitiveDetector", FatalException, "FastCaloSimSvc: Failed getting CaloCellContainer SD.");
296  abort();
297  }
298  // Cast G4VSensitiveDetector to CaloCellContainerSD
299  CaloCellContainerSD * caloCellContainerSD = dynamic_cast<CaloCellContainerSD*>(vsd);
300 
301  if (!caloCellContainerSD){
302  G4Exception("FastCaloSimSvc", "FailedCastSensitiveDetector", FatalException, "FastCaloSimSvc: Failed casting G4VSensitiveDetector.");
303  abort();
304  }
305  return caloCellContainerSD;
306 }

◆ IsApplicable()

G4bool FastCaloSim::IsApplicable ( const G4ParticleDefinition &  particleType)
finaloverride

Definition at line 77 of file FastCaloSim.cxx.

78 {
79  // Check whether we can simulate the particle with FastCaloSim
80  bool isPhoton = &particleType == G4Gamma::GammaDefinition();
81  bool isElectron = &particleType == G4Electron::ElectronDefinition();
82  bool isPositron = &particleType == G4Positron::PositronDefinition();
83  bool isHadron = MC::isHadron(particleType.GetPDGEncoding());
84 
85  // FastCaloSim is applicable if it is photon, electron, positron or any hadron
86  bool isApplicable = isPhoton || isElectron || isPositron || isHadron;
87 
88  #ifdef FCS_DEBUG
89  const std::string pName = particleType.GetParticleName();
90  G4cout<< "[FastCaloSim::IsApplicable] Got " << pName <<G4endl;
91  if(isApplicable) G4cout<<"[FastCaloSim::IsApplicable] APPLICABLE"<<G4endl;
92  else G4cout<<"[FastCaloSim::IsApplicable] NOT APPLICABLE"<<G4endl;
93  #endif
94 
95 
96  return isApplicable;
97 }

◆ ModelTrigger()

G4bool FastCaloSim::ModelTrigger ( const G4FastTrack &  fastTrack)
finaloverride

Determines the applicability of the fast sim model to this particular track.

Checks that geometric location, energy, and particle type are within bounds. Also checks for containment of the particle's shower within a specific detector region.

Definition at line 99 of file FastCaloSim.cxx.

100 {
101 
102  #ifdef FCS_DEBUG
103  G4cout<<"[FastCaloSim::ModelTrigger] Got particle with " <<"\n"
104  <<" pdg=" <<fastTrack.GetPrimaryTrack() -> GetDefinition()->GetPDGEncoding() <<"\n"
105  <<" Ekin="<<fastTrack.GetPrimaryTrack() -> GetKineticEnergy() <<"\n"
106  <<" p=" <<fastTrack.GetPrimaryTrack() -> GetMomentum().mag() <<"\n"
107  <<" x=" <<fastTrack.GetPrimaryTrack() -> GetPosition().x() <<"\n"
108  <<" y=" <<fastTrack.GetPrimaryTrack() -> GetPosition().y() <<"\n"
109  <<" z=" <<fastTrack.GetPrimaryTrack() -> GetPosition().z() <<"\n"
110  <<" r=" <<fastTrack.GetPrimaryTrack() -> GetPosition().perp() <<"\n"
111  <<" eta=" <<fastTrack.GetPrimaryTrack() -> GetMomentum().eta() <<"\n"
112  <<" phi=" <<fastTrack.GetPrimaryTrack() -> GetMomentum().phi() <<"\n"
113  <<G4endl;
114  #endif
115 
116 
117  // Simulate particles below 50 keV with Geant4 to have same config as ISF implementation
118  if (fastTrack.GetPrimaryTrack() -> GetKineticEnergy() < 0.05) {
119  #ifdef FCS_DEBUG
120  G4cout<<"[FastCaloSim::ModelTrigger] Particle below 50 keV threshold. Passing to G4. "<<G4endl;
121  #endif
122  return false;
123  }
124 
125  // Check if triggered particle is really on the ID-Calo (parametrization) boundary
126  if (!passedIDCaloBoundary(fastTrack)) {
127  #ifdef FCS_DEBUG
128  G4cout<<"[FastCaloSim::ModelTrigger] Particle failed passedIDCaloBoundary z="<<fastTrack.GetPrimaryTrack() -> GetPosition().z()<<" r="<<fastTrack.GetPrimaryTrack() -> GetPosition().perp()<<G4endl;
129  #endif
130  return false;
131  }
132 
133  // Set minimum kinetic energy of pions and other hadrons required to be passed to FastCaloSim
134  float minEkinPions = 200;
135  float minEkinOtherHadrons = 400;
136 
137  // Get particle definition
138  const G4ParticleDefinition * G4Particle = fastTrack.GetPrimaryTrack() -> GetDefinition();
139  // Get particle kinetic energy
140  const float Ekin = fastTrack.GetPrimaryTrack() -> GetKineticEnergy();
141 
142  // Check particle type
143  bool isPhoton = G4Particle == G4Gamma::Definition();
144  bool isElectron = G4Particle == G4Electron::Definition();
145  bool isPositron = G4Particle == G4Positron::Definition();
146  bool isPionPlus = G4Particle == G4PionPlus::Definition();
147  bool isPionMinus = G4Particle == G4PionMinus::Definition();
148 
149  // Pass all photons, electrons and positrons to FastCaloSim
150  if (isPhoton || isElectron || isPositron){
151  #ifdef FCS_DEBUG
152  G4cout<<"[FastCaloSim::ModelTrigger] Model triggered"<<G4endl;
153  #endif
154  return true;
155  }
156 
157  // Require minimum kinetic energy of pions needed to be passed to FastCaloSim
158  if (isPionPlus || isPionMinus){
159  bool passMinEkinPions = Ekin > minEkinPions;
160 
161  #ifdef FCS_DEBUG
162  if(passMinEkinPions) G4cout<<"[FastCaloSim::ModelTrigger] Model triggered"<<G4endl;
163  else G4cout<<"[FastCaloSim::ModelTrigger] Pion with Ekin="<<Ekin<<" below the minimum "<<minEkinPions<<" MeV threshold. Model not triggered."<<G4endl;
164  #endif
165 
166  return passMinEkinPions;
167 
168  }
169 
170  // Require minimum kinetic energy of other hadrons needed to be passed to FastCaloSim
171  bool passMinEkinOtherHadrons = Ekin > minEkinOtherHadrons;
172 
173  #ifdef FCS_DEBUG
174  if(passMinEkinOtherHadrons) G4cout<<"[FastCaloSim::ModelTrigger] Model triggered"<<G4endl;
175  else G4cout<<"[FastCaloSim::ModelTrigger] Other hadron with Ekin="<<Ekin<<" below the minimum "<<minEkinOtherHadrons<<" MeV threshold. Model not triggered."<<G4endl;
176  #endif
177 
178  return passMinEkinOtherHadrons;
179 }

◆ passedIDCaloBoundary()

G4bool FastCaloSim::passedIDCaloBoundary ( const G4FastTrack &  fastTrack)

Check if the particle is located at the proper ID-Calo parametrization boundary and is travelling outwards from the ID to the CALO.

Definition at line 309 of file FastCaloSim.cxx.

309  {
310 
311 
312  /* Method checks if particle has crossed the ID-Calo boundary, defined using three cylinders with pairs of r/z values
313  We also perform a directional check to make sure that the particle does not originate from any backscatter from the MS or CALO */
314 
315  // NOTE:
316  // For the inner beam pipe section, innerBeamPipeZ = 4185 corresponds to original AFII boundary, while
317  // innerBeamPipeZ = 4587 corresponds to the CALO::CALO boundary which should be used instead as there
318  // is no triggering volume at this point and we will trigger slightly later than the AFII boundary, so
319  // passedIDCaloBoundary would fail and we would simulate this part with Geant4
320 
321  // Barrel
322  const float barrelR = 1148;
323  const float barrelZ = 3549.5;
324  // Inner beam pipe section
325  const float innerBeamPipeR = 120;
326  const float innerBeamPipeZ = 4587;
327  // Outer beam pipe section
328  const float outerBeamPipeR = 41;
329  const float outerBeamPipeZ = 6783;
330 
331  // Get particle position
332  const G4ThreeVector particlePosition = fastTrack.GetPrimaryTrack() -> GetPosition();
333  // Get r and z values of position
334  const float r = particlePosition.perp();
335  const float z = particlePosition.z();
336  // Get direction of particle
337  const G4ThreeVector particleDirection = fastTrack.GetPrimaryTrack() -> GetMomentum();
338  // Construct the helper line to decide if particle comes from ID or is backscatter from CALO
339  const G4ThreeVector helperLine = particlePosition + particleDirection;
340 
341  // Set 5cm trigger tolerance, i.e. the 'width' of the trigger boundary
342  // be careful not to set this too low, else Geant4 might overjump your trigger boundary and simulate everything with G4
343  const float triggerTolerance = 50;
344 
345  // Barrel boundary (horizontal surfaces)
346  if (std::abs(z) <= barrelZ + triggerTolerance) {
347  if (r >= barrelR && r < barrelR + triggerTolerance) return helperLine.perp() >= barrelR;
348  }
349  // Beam pipe boundary (horizontal surfaces)
350  if (std::abs(z) >= barrelZ && std::abs(z) <= innerBeamPipeZ + triggerTolerance){
351  if (r >= innerBeamPipeR && r < innerBeamPipeR + triggerTolerance) return helperLine.perp() >= innerBeamPipeR;
352  }
353  if (std::abs(z) >= innerBeamPipeZ && std::abs(z) <= outerBeamPipeZ){
354  if (r >= outerBeamPipeR && r < outerBeamPipeR + triggerTolerance) return helperLine.perp() >= outerBeamPipeR;
355  }
356  // Barrel boundary (vertical surfaces)
357  if (r >= outerBeamPipeR && r<= innerBeamPipeR){
358  if (std::abs(z) >= innerBeamPipeZ && std::abs(z) < innerBeamPipeZ + triggerTolerance) return std::abs(helperLine.z()) >= innerBeamPipeZ;
359  }
360  // Beam pipe boundary (vertical surfaces)
361  if (r >= innerBeamPipeR && r <= barrelR){
362  if (std::abs(z) >= barrelZ && std::abs(z) < barrelZ + triggerTolerance) return std::abs(helperLine.z()) >= barrelZ;
363  }
364 
365  return false;
366 
367 }

◆ StartOfAthenaEvent()

void FastCaloSim::StartOfAthenaEvent ( const EventContext &  ctx)

Definition at line 63 of file FastCaloSim.cxx.

63  {
64 
67 
68  return;
69 }

Member Data Documentation

◆ m_CaloCellContainerSDName

std::string FastCaloSim::m_CaloCellContainerSDName
private

Definition at line 87 of file FastCaloSim.h.

◆ m_doG4Transport

bool FastCaloSim::m_doG4Transport
private

Definition at line 89 of file FastCaloSim.h.

◆ m_doPunchThrough

bool FastCaloSim::m_doPunchThrough
private

Definition at line 92 of file FastCaloSim.h.

◆ m_FastCaloSimCaloExtrapolation

PublicToolHandle<IFastCaloSimCaloExtrapolation> FastCaloSim::m_FastCaloSimCaloExtrapolation
private

Definition at line 78 of file FastCaloSim.h.

◆ m_FastCaloSimCaloTransportation

PublicToolHandle<IFastCaloSimCaloTransportation> FastCaloSim::m_FastCaloSimCaloTransportation
private

Definition at line 76 of file FastCaloSim.h.

◆ m_FastCaloSimSvc

ServiceHandle<ISF::IFastCaloSimParamSvc> FastCaloSim::m_FastCaloSimSvc
private

Definition at line 85 of file FastCaloSim.h.

◆ m_FastCaloSimTool

FastCaloSimTool* FastCaloSim::m_FastCaloSimTool
private

Definition at line 95 of file FastCaloSim.h.

◆ m_G4CaloTransportTool

PublicToolHandle<IG4CaloTransportTool> FastCaloSim::m_G4CaloTransportTool
private

Definition at line 80 of file FastCaloSim.h.

◆ m_PunchThroughSimWrapper

PublicToolHandle<IPunchThroughSimWrapper> FastCaloSim::m_PunchThroughSimWrapper
private

Definition at line 82 of file FastCaloSim.h.

◆ m_randomEngineName

std::string FastCaloSim::m_randomEngineName
private

Definition at line 72 of file FastCaloSim.h.

◆ m_rndmGenSvc

ServiceHandle<IAthRNGSvc> FastCaloSim::m_rndmGenSvc
private

Definition at line 71 of file FastCaloSim.h.

◆ m_rngWrapper

ATHRNG::RNGWrapper* FastCaloSim::m_rngWrapper {}
private

Definition at line 73 of file FastCaloSim.h.


The documentation for this class was generated from the following files:
FastCaloSimCaloExtrapolation
Definition: FastCaloSimCaloExtrapolation.h:32
ATHRNG::RNGWrapper::setSeed
void setSeed(const std::string &algName, const EventContext &ctx)
Set the random seed using a string (e.g.
Definition: RNGWrapper.h:169
beamspotman.r
def r
Definition: beamspotman.py:672
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
perp
Scalar perp() const
perp method - perpenticular length
Definition: AmgMatrixBasePlugin.h:44
TFCSTruthState::set_Ekin_off
void set_Ekin_off(double val)
Definition: TFCSTruthState.h:23
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
CaloCellContainerSD::recordCells
void recordCells(TFCSSimulationState &)
Definition: CaloCellContainerSD.cxx:65
FastCaloSim::m_FastCaloSimTool
FastCaloSimTool * m_FastCaloSimTool
Definition: FastCaloSim.h:95
FastCaloSim::m_FastCaloSimSvc
ServiceHandle< ISF::IFastCaloSimParamSvc > m_FastCaloSimSvc
Definition: FastCaloSim.h:85
TFCSExtrapolationState
Definition: TFCSExtrapolationState.h:13
x
#define x
particleType
Definition: particleType.h:29
CaloCellContainerSD
Definition: CaloCellContainerSD.h:22
FastCaloSim::getCaloCellContainerSD
CaloCellContainerSD * getCaloCellContainerSD()
Retrieves the associated sensitive detector responsible for writing out the CaloCellContainer.
Definition: FastCaloSim.cxx:289
FastCaloSim::m_FastCaloSimCaloTransportation
PublicToolHandle< IFastCaloSimCaloTransportation > m_FastCaloSimCaloTransportation
Definition: FastCaloSim.h:76
FastCaloSim::m_doPunchThrough
bool m_doPunchThrough
Definition: FastCaloSim.h:92
FastCaloSim::m_randomEngineName
std::string m_randomEngineName
Definition: FastCaloSim.h:72
FastCaloSim::m_CaloCellContainerSDName
std::string m_CaloCellContainerSDName
Definition: FastCaloSim.h:87
lumiFormat.i
int i
Definition: lumiFormat.py:85
z
#define z
xAOD::EgammaHelpers::isElectron
bool isElectron(const xAOD::Egamma *eg)
is the object an electron (not Fwd)
Definition: EgammaxAODHelpers.cxx:12
TFCSExtrapolationState::IDCaloBoundary_eta
double IDCaloBoundary_eta() const
Definition: TFCSExtrapolationState.h:63
FastCaloSim::m_PunchThroughSimWrapper
PublicToolHandle< IPunchThroughSimWrapper > m_PunchThroughSimWrapper
Definition: FastCaloSim.h:82
FastCaloSim::m_FastCaloSimCaloExtrapolation
PublicToolHandle< IFastCaloSimCaloExtrapolation > m_FastCaloSimCaloExtrapolation
Definition: FastCaloSim.h:78
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
isHadron
bool isHadron(const T &p)
Definition: AtlasPID.h:348
PunchThroughSimWrapper
Class to wrap PunchThrough simulation inside FastCaloSim; Runs both PunchThroughG4Classifier and Punc...
Definition: PunchThroughSimWrapper.h:35
FastCaloSim::m_doG4Transport
bool m_doG4Transport
Definition: FastCaloSim.h:89
y
#define y
xAOD::EgammaHelpers::isPhoton
bool isPhoton(const xAOD::Egamma *eg)
is the object a photon
Definition: EgammaxAODHelpers.cxx:21
FastCaloSimCaloTransportation
Definition: FastCaloSimCaloTransportation.h:21
TFCSTruthState::set_vertex
void set_vertex(const TLorentzVector &val)
Definition: TFCSTruthState.h:19
FastCaloSim::m_rngWrapper
ATHRNG::RNGWrapper * m_rngWrapper
Definition: FastCaloSim.h:73
python.SystemOfUnits.s
float s
Definition: SystemOfUnits.py:147
FastCaloSim::m_G4CaloTransportTool
PublicToolHandle< IG4CaloTransportTool > m_G4CaloTransportTool
Definition: FastCaloSim.h:80
FastCaloSim::passedIDCaloBoundary
G4bool passedIDCaloBoundary(const G4FastTrack &fastTrack)
Check if the particle is located at the proper ID-Calo parametrization boundary and is travelling out...
Definition: FastCaloSim.cxx:309
G4CaloTransportTool
A tool which transports particles through the Geant4 geometry.
Definition: G4CaloTransportTool.h:25
TFCSTruthState
Definition: TFCSTruthState.h:13
TFCSSimulationState
Definition: TFCSSimulationState.h:32
FastCaloSimTool
Definition: FastCaloSimTool.h:27
FastCaloSim::m_rndmGenSvc
ServiceHandle< IAthRNGSvc > m_rndmGenSvc
Definition: FastCaloSim.h:71
TFCSTruthState::set_pdgid
void set_pdgid(int val)
Definition: TFCSTruthState.h:18