DD4hep  1.32.1
Detector Description Toolkit for High Energy Physics
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
EDM4hepFileReader.cpp
Go to the documentation of this file.
1 //==========================================================================
2 // AIDA Detector description implementation
3 //--------------------------------------------------------------------------
4 // Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
5 // All rights reserved.
6 //
7 // For the licensing terms see $DD4hepINSTALL/LICENSE.
8 // For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
9 //
10 // Author : A.Sailer
11 //
12 //==========================================================================
13 
24 #include <CLHEP/Units/SystemOfUnits.h>
25 
26 #include <DDG4/EventParameters.h>
27 #include <DDG4/Factories.h>
28 #include <DDG4/FileParameters.h>
29 #include <DDG4/Geant4InputAction.h>
30 #include <DDG4/RunParameters.h>
31 
32 #include <edm4hep/EventHeaderCollection.h>
33 #include <edm4hep/MCParticleCollection.h>
34 
35 #include <podio/Frame.h>
36 #include <podio/Reader.h>
37 
38 typedef dd4hep::detail::ReferenceBitMask<int> PropertyMask;
39 
40 
41 namespace dd4hep::sim {
42 
43  // we use the index of the objectID to identify particles
44  // we will not support MCParticles from different collections
45  using MCPARTICLE_MAP=std::map<int, int>;
46 
49  template <class T=podio::GenericParameters> void EventParameters::ingestParameters(T const& source) {
50  for(auto const& key: source.template getKeys<int>()) {
51  m_intValues[key] = source.template get<std::vector<int>>(key).value();
52  }
53  for(auto const& key: source.template getKeys<float>()) {
54  m_fltValues[key] = source.template get<std::vector<float>>(key).value();
55  }
56  for(auto const& key: source.template getKeys<double>()) {
57  m_dblValues[key] = source.template get<std::vector<double>>(key).value();
58  }
59  for(auto const& key: source.template getKeys<std::string>()) {
60  m_strValues[key] = source.template get<std::vector<std::string>>(key).value();
61  }
62  }
63 
66  template <class T=podio::GenericParameters> void RunParameters::ingestParameters(T const& source) {
67  for(auto const& key: source.template getKeys<int>()) {
68  m_intValues[key] = source.template get<std::vector<int>>(key).value();
69  }
70  for(auto const& key: source.template getKeys<float>()) {
71  m_fltValues[key] = source.template get<std::vector<float>>(key).value();
72  }
73  for(auto const& key: source.template getKeys<double>()) {
74  m_dblValues[key] = source.template get<std::vector<double>>(key).value();
75  }
76  for(auto const& key: source.template getKeys<std::string>()) {
77  m_strValues[key] = source.template get<std::vector<std::string>>(key).value();
78  }
79  }
80 
81  template <class T=podio::GenericParameters> void FileParameters::ingestParameters(T const& source) {
82  for(auto const& key: source.template getKeys<int>()) {
83  m_intValues[key] = source.template get<std::vector<int>>(key).value();
84  }
85  for(auto const& key: source.template getKeys<float>()) {
86  m_fltValues[key] = source.template get<std::vector<float>>(key).value();
87  }
88  for(auto const& key: source.template getKeys<double>()) {
89  m_dblValues[key] = source.template get<std::vector<double>>(key).value();
90  }
91  for(auto const& key: source.template getKeys<std::string>()) {
92  m_strValues[key] = source.template get<std::vector<std::string>>(key).value();
93  }
94  }
95 
97 
102  protected:
104  podio::Reader m_reader;
106  std::string m_collectionName;
109 
110  public:
112  EDM4hepFileReader(const std::string& nam);
113 
115  virtual EventReaderStatus setParameters(std::map< std::string, std::string >& parameters);
116 
118  virtual EventReaderStatus readParticles(int event_number, Vertices& vertices, std::vector<Particle*>& particles);
120  void registerRunParameters();
121 
122  };
123 
126  : Geant4EventReader(nam)
127  , m_reader(podio::makeReader(nam))
128  , m_collectionName("MCParticles")
129  , m_eventHeaderCollectionName("EventHeader")
130  {
131  printout(INFO,"EDM4hepFileReader","Created file reader. Try to open input %s",nam.c_str());
132  m_directAccess = true;
133  }
134 
136  try {
137  // get RunParameters or create new if not existent yet
138  auto* parameters = context()->run().extension<RunParameters>(false);
139  if (!parameters) {
140  parameters = new RunParameters();
141  context()->run().addExtension<RunParameters>(parameters);
142  }
143  try {
144  podio::Frame runFrame = m_reader.readFrame("runs", 0);
145  parameters->ingestParameters(runFrame.getParameters());
146  } catch (std::runtime_error& e) {
147  // we ignore if we do not have runs information
148  } catch(std::invalid_argument&) {
149  // we ignore if we do not have runs information
150  }
151  } catch(std::exception &e) {
152  printout(ERROR,"EDM4hepFileReader::registerRunParameters","Failed to register run parameters: %s", e.what());
153  }
154 
155  try {
156  auto *fileParameters = new FileParameters();
157  try {
158  podio::Frame metaFrame = m_reader.readFrame("metadata", 0);
159  fileParameters->ingestParameters(metaFrame.getParameters());
160  } catch (std::runtime_error& e) {
161  // we ignore if we do not have metadata information
162  } catch(std::invalid_argument&) {
163  // we ignore if we do not have metadata information
164  }
165  context()->run().addExtension<FileParameters>(fileParameters);
166  } catch(std::exception &e) {
167  printout(ERROR,"EDM4hepFileReader::registerRunParameters","Failed to register file parameters: %s", e.what());
168  }
169  }
170 
171  namespace {
173  inline int GET_ENTRY(MCPARTICLE_MAP const& mcparts, int partID) {
174  MCPARTICLE_MAP::const_iterator ip = mcparts.find(partID);
175  if ( ip == mcparts.end() ) {
176  throw std::runtime_error("Unknown particle identifier look-up!");
177  }
178  return (*ip).second;
179  }
180  }
181 
184  EDM4hepFileReader::readParticles(int event_number, Vertices& vertices, std::vector<Particle*>& particles) {
185  m_currEvent = event_number;
186  podio::Frame frame = m_reader.readFrame("events", event_number);
187  const auto& primaries = frame.get<edm4hep::MCParticleCollection>(m_collectionName);
188  int eventNumber = event_number, runNumber = 0;
189  if (primaries.isValid()) {
190  //Read the event header collection and add it to the context as an extension
191  const auto& eventHeaderCollection = frame.get<edm4hep::EventHeaderCollection>(m_eventHeaderCollectionName);
192  if(eventHeaderCollection.isValid() && eventHeaderCollection.size() == 1){
193  const auto& eh = eventHeaderCollection.at(0);
194  eventNumber = eh.getEventNumber();
195  runNumber = eh.getRunNumber();
196  try {
197  Geant4Context* ctx = context();
198  ctx->event().addExtension<edm4hep::MutableEventHeader>(new edm4hep::MutableEventHeader(eh.clone()));
199  } catch(std::exception& ) {}
200  // Create input event parameters context
201  try {
202  Geant4Context* ctx = context();
203  EventParameters *parameters = new EventParameters();
204  parameters->setRunNumber(runNumber);
205  parameters->setEventNumber(eventNumber);
206  parameters->ingestParameters(frame.getParameters());
207  ctx->event().addExtension<EventParameters>(parameters);
208  } catch(std::exception &) {}
209  } else {
210  printout(WARNING,"EDM4hepFileReader","No EventHeader collection found or too many event headers!");
211  try {
212  Geant4Context* ctx = context();
213  EventParameters *parameters = new EventParameters();
214  parameters->setRunNumber(0);
215  parameters->setEventNumber(event_number);
216  parameters->ingestParameters(frame.getParameters());
217  ctx->event().addExtension<EventParameters>(parameters);
218  } catch(std::exception &) {}
219  }
220  printout(INFO,"EDM4hepFileReader","read collection %s from event %d in run %d ",
221  m_collectionName.c_str(), eventNumber, runNumber);
222 
223  } else {
224  return EVENT_READER_EOF;
225  }
226 
227  printout(INFO,"EDM4hepFileReader", "We read the particle collection");
228  int NHEP = primaries.size();
229  // check if there is at least one particle
230  if ( NHEP == 0 ) {
231  printout(WARNING,"EDM4hepFileReader", "We have no particles");
233  }
234 
235  MCPARTICLE_MAP mcparts;
236  std::vector<int> mcpcoll;
237  mcpcoll.resize(NHEP);
238  for(int i=0; i<NHEP; ++i ) {
239  edm4hep::MCParticle p = primaries.at(i);
240  mcparts[p.getObjectID().index] = i;
241  mcpcoll[i] = p.getObjectID().index;
242  }
243 
244  // build collection of MCParticles
245  for(int i=0; i<NHEP; ++i ) {
246  const auto& mcp = primaries.at(i);
247  Geant4ParticleHandle p(new Particle(i));
248  const auto mom = mcp.getMomentum();
249  const auto vsx = mcp.getVertex();
250  const auto vex = mcp.getEndpoint();
251  const auto spin = mcp.getSpin();
252  const int pdg = mcp.getPDG();
253  p->pdgID = pdg;
254  p->charge = int(mcp.getCharge()*3.0);
255  p->psx = mom[0]*CLHEP::GeV;
256  p->psy = mom[1]*CLHEP::GeV;
257  p->psz = mom[2]*CLHEP::GeV;
258  p->time = mcp.getTime()*CLHEP::ns;
259  p->properTime = mcp.getTime()*CLHEP::ns;
260  p->vsx = vsx[0]*CLHEP::mm;
261  p->vsy = vsx[1]*CLHEP::mm;
262  p->vsz = vsx[2]*CLHEP::mm;
263  p->vex = vex[0]*CLHEP::mm;
264  p->vey = vex[1]*CLHEP::mm;
265  p->vez = vex[2]*CLHEP::mm;
266  p->process = 0;
267  p->spin[0] = spin[0];
268  p->spin[1] = spin[1];
269  p->spin[2] = spin[2];
270  p->colorFlow[0] = 0;
271  p->colorFlow[1] = 0;
272  p->mass = mcp.getMass()*CLHEP::GeV;
273  const auto par = mcp.getParents(), &dau=mcp.getDaughters();
274  for(int num=dau.size(),k=0; k<num; ++k) {
275  edm4hep::MCParticle dau_k = dau[k];
276  p->daughters.insert(GET_ENTRY(mcparts,dau_k.getObjectID().index));
277  }
278  for(int num=par.size(),k=0; k<num; ++k) {
279  auto par_k = par[k];
280  p->parents.insert(GET_ENTRY(mcparts, par_k.getObjectID().index));
281  }
282 
283  PropertyMask status(p->status);
284  int genStatus = mcp.getGeneratorStatus();
285  // Copy raw generator status
286  p->genStatus = genStatus&G4PARTICLE_GEN_STATUS_MASK;
287  if(m_inputAction) {
288  // in some tests we do not set up the inputAction
289  m_inputAction->setGeneratorStatus(genStatus, status);
290  }
291 
292  //fg: we simply add all particles without parents as with their own vertex.
293  // This might include the incoming beam particles, e.g. in
294  // the case of lcio files written with Whizard2, which is slightly odd,
295  // however should be treated correctly in Geant4InputHandling.cpp.
296  // We no longer make an attempt to identify the incoming particles
297  // based on the generator status, as this varies widely with different
298  // generators.
299 
300  if ( p->parents.size() == 0 ) {
301 
302  Geant4Vertex* vtx = new Geant4Vertex ;
303  vertices.emplace_back( vtx );
304  vtx->x = p->vsx;
305  vtx->y = p->vsy;
306  vtx->z = p->vsz;
307  vtx->time = p->time;
308 
309  vtx->out.insert(p->id) ;
310  }
311 
312  if ( mcp.isCreatedInSimulation() ) status.set(G4PARTICLE_SIM_CREATED);
313  if ( mcp.isBackscatter() ) status.set(G4PARTICLE_SIM_BACKSCATTER);
314  if ( mcp.vertexIsNotEndpointOfParent() ) status.set(G4PARTICLE_SIM_PARENT_RADIATED);
315  if ( mcp.isDecayedInTracker() ) status.set(G4PARTICLE_SIM_DECAY_TRACKER);
316  if ( mcp.isDecayedInCalorimeter() ) status.set(G4PARTICLE_SIM_DECAY_CALO);
317  if ( mcp.hasLeftDetector() ) status.set(G4PARTICLE_SIM_LEFT_DETECTOR);
318  if ( mcp.isStopped() ) status.set(G4PARTICLE_SIM_STOPPED);
319  if ( mcp.isOverlay() ) status.set(G4PARTICLE_SIM_OVERLAY);
320  particles.emplace_back(p);
321  }
322  return EVENT_READER_OK;
323  }
324 
328  dd4hep::sim::EDM4hepFileReader::setParameters( std::map< std::string, std::string > & parameters ) {
329  _getParameterValue(parameters, "MCParticleCollectionName", m_collectionName, m_collectionName);
330  _getParameterValue(parameters, "EventHeaderCollectionName", m_eventHeaderCollectionName, m_eventHeaderCollectionName);
331  return EVENT_READER_OK;
332  }
333 
334 } //end dd4hep::sim
335 
dd4hep::sim::G4PARTICLE_SIM_CREATED
@ G4PARTICLE_SIM_CREATED
Definition: Geant4Particle.h:85
dd4hep::sim::EDM4hepFileReader::setParameters
virtual EventReaderStatus setParameters(std::map< std::string, std::string > &parameters)
Read parameters set for this action.
Definition: EDM4hepFileReader.cpp:328
dd4hep::sim::Geant4EventReader::EVENT_READER_EOF
@ EVENT_READER_EOF
Definition: Geant4InputAction.h:75
dd4hep::sim::Geant4Particle::vsz
double vsz
Definition: Geant4Particle.h:124
dd4hep::sim::Geant4EventReader::context
Geant4Context * context() const
Get the context (from the input action)
Definition: Geant4InputAction.cpp:41
dd4hep::sim::EDM4hepFileReader::EDM4hepFileReader
EDM4hepFileReader(const std::string &nam)
Initializing constructor.
Definition: EDM4hepFileReader.cpp:125
dd4hep::sim::G4PARTICLE_SIM_PARENT_RADIATED
@ G4PARTICLE_SIM_PARENT_RADIATED
Definition: Geant4Particle.h:91
dd4hep::sim::Geant4Vertex::y
double y
Definition: Geant4Vertex.h:53
dd4hep::sim::Geant4Particle::mass
double mass
Particle mass.
Definition: Geant4Particle.h:132
dd4hep::sim::Geant4Particle::vey
double vey
Definition: Geant4Particle.h:126
dd4hep::sim::Geant4EventReader::EventReaderStatus
EventReaderStatus
Status codes of the event reader object. Anything with NOT low-bit set is an error.
Definition: Geant4InputAction.h:68
dd4hep::exception
void exception(const std::string &src, const std::string &msg)
Definition: RootDictionary.h:69
dd4hep::sim::ExtensionParameters::m_strValues
std::map< std::string, std::vector< std::string > > m_strValues
Definition: ExtensionParameters.h:35
dd4hep::sim::Geant4Context::run
Geant4Run & run() const
Access the geant4 run – valid only between BeginRun() and EndRun()!
Definition: Geant4Context.cpp:72
dd4hep::sim::Geant4Particle::id
int id
not persistent
Definition: Geant4Particle.h:108
dd4hep::sim::EventParameters::setRunNumber
void setRunNumber(int runNumber)
Set the event parameters.
Definition: EventParameters.cpp:20
dd4hep::sim::EDM4hepFileReader::m_collectionName
std::string m_collectionName
Name of the MCParticle collection to read.
Definition: EDM4hepFileReader.cpp:106
dd4hep::sim::EDM4hepFileReader::readParticles
virtual EventReaderStatus readParticles(int event_number, Vertices &vertices, std::vector< Particle * > &particles)
Read an event and fill a vector of MCParticles.
Definition: EDM4hepFileReader.cpp:184
dd4hep::sim::Geant4Particle::pdgID
int pdgID
Definition: Geant4Particle.h:115
dd4hep::sim::EventParameters::setEventNumber
void setEventNumber(int eventNumber)
Definition: EventParameters.cpp:23
dd4hep::sim::Geant4Particle::psz
double psz
Definition: Geant4Particle.h:128
DECLARE_GEANT4_EVENT_READER_NS
#define DECLARE_GEANT4_EVENT_READER_NS(name_space, name)
Plugin defintion to create event reader objects.
Definition: Factories.h:240
dd4hep::sim::Geant4Context::event
Geant4Event & event() const
Access the geant4 event – valid only between BeginEvent() and EndEvent()!
Definition: Geant4Context.cpp:84
dd4hep::sim::G4PARTICLE_GEN_STATUS_MASK
@ G4PARTICLE_GEN_STATUS_MASK
Definition: Geant4Particle.h:83
m_reader
UriReader * m_reader
Pointer to URI reader.
Definition: DocumentHandler.cpp:154
dd4hep::sim::G4PARTICLE_SIM_BACKSCATTER
@ G4PARTICLE_SIM_BACKSCATTER
Definition: Geant4Particle.h:86
RunParameters.h
dd4hep::sim::Geant4EventReader::m_currEvent
int m_currEvent
Current event number.
Definition: Geant4InputAction.h:83
dd4hep::sim::RunParameters
Extension to pass input run data to output run data.
Definition: RunParameters.h:28
FileParameters.h
dd4hep::sim::Geant4EventReader::Particle
Geant4Particle Particle
Definition: Geant4InputAction.h:64
dd4hep::sim::G4PARTICLE_SIM_STOPPED
@ G4PARTICLE_SIM_STOPPED
Definition: Geant4Particle.h:89
EDM4hepFileReader
Plugin to read EDM4hep files.
EventParameters.h
dd4hep::sim::EDM4hepFileReader::m_reader
podio::Reader m_reader
Reference to reader object.
Definition: EDM4hepFileReader.cpp:104
dd4hep::sim::Geant4Run::addExtension
void * addExtension(unsigned long long int k, ExtensionEntry *e)
Add an extension object to the detector element.
Definition: Geant4Context.h:84
dd4hep::sim::EventParameters::ingestParameters
void ingestParameters(T const &source)
Copy the parameters from source.
Definition: EDM4hepFileReader.cpp:49
dd4hep::sim::Geant4Particle::vez
double vez
Definition: Geant4Particle.h:126
dd4hep::sim::G4PARTICLE_SIM_DECAY_CALO
@ G4PARTICLE_SIM_DECAY_CALO
Definition: Geant4Particle.h:87
dd4hep::sim::EDM4hepFileReader::registerRunParameters
void registerRunParameters()
Call to register the run parameters.
Definition: EDM4hepFileReader.cpp:135
dd4hep::sim::Geant4Vertex::x
double x
Vertex data.
Definition: Geant4Vertex.h:53
dd4hep::sim::Geant4Particle::colorFlow
int colorFlow[2]
Definition: Geant4Particle.h:117
dd4hep::sim::Geant4Particle::spin
float spin[3]
Definition: Geant4Particle.h:121
dd4hep::sim::Geant4Particle::genStatus
unsigned short genStatus
Definition: Geant4Particle.h:118
dd4hep::sim::ExtensionParameters::m_intValues
std::map< std::string, std::vector< int > > m_intValues
Definition: ExtensionParameters.h:33
dd4hep::sim::Geant4Particle::status
int status
Definition: Geant4Particle.h:116
dd4hep::sim::Geant4EventReader::m_directAccess
bool m_directAccess
Flag if direct event access is supported. To be explicitly set by subclass constructors.
Definition: Geant4InputAction.h:81
dd4hep::sim::G4PARTICLE_SIM_OVERLAY
@ G4PARTICLE_SIM_OVERLAY
Definition: Geant4Particle.h:92
dd4hep::sim::Geant4Particle::daughters
Particles daughters
The list of daughters of this MC particle.
Definition: Geant4Particle.h:140
dd4hep::sim::G4PARTICLE_SIM_DECAY_TRACKER
@ G4PARTICLE_SIM_DECAY_TRACKER
Definition: Geant4Particle.h:88
dd4hep::sim::FileParameters
Extension to pass input run data to output run data.
Definition: FileParameters.h:28
dd4hep::sim::ExtensionParameters::m_dblValues
std::map< std::string, std::vector< double > > m_dblValues
Definition: ExtensionParameters.h:36
dd4hep::sim::Geant4InputAction::setGeneratorStatus
void setGeneratorStatus(int generatorStatus, PropertyMask &status)
Convert the generator status into a common set of generator status bits.
dd4hep::sim::Geant4Particle::time
double time
Particle creation time.
Definition: Geant4Particle.h:134
dd4hep::sim::Geant4Particle::process
const G4VProcess * process
Reference to the G4VProcess, which created this track.
Definition: Geant4Particle.h:145
dd4hep::sim::Geant4EventReader::m_inputAction
Geant4InputAction * m_inputAction
The input action context.
Definition: Geant4InputAction.h:85
dd4hep::sim::Geant4EventReader
Basic geant4 event reader class. This interface/base-class must be implemented by concrete readers.
Definition: Geant4InputAction.h:60
dd4hep::sim::MCPARTICLE_MAP
std::map< int, int > MCPARTICLE_MAP
Definition: EDM4hepFileReader.cpp:45
dd4hep::sim::Geant4Vertex::out
Particles out
The list of outgoing particles.
Definition: Geant4Vertex.h:55
dd4hep::sim::Geant4Particle::vex
double vex
The end vertex.
Definition: Geant4Particle.h:126
dd4hep::sim::ExtensionParameters::m_fltValues
std::map< std::string, std::vector< float > > m_fltValues
Definition: ExtensionParameters.h:34
dd4hep::sim::Geant4Run::extension
T * extension(bool alert=true)
Access to type safe extension object. Exception is thrown if the object is invalid.
Definition: Geant4Context.h:95
dd4hep::sim::Geant4Particle::vsx
double vsx
The starting vertex.
Definition: Geant4Particle.h:124
dd4hep::sim::Geant4Particle::psx
double psx
The track momentum at the start vertex.
Definition: Geant4Particle.h:128
dd4hep::sim::Geant4Event::addExtension
void * addExtension(unsigned long long int k, ExtensionEntry *e)
Add an extension object to the detector element.
Definition: Geant4Context.h:140
Factories.h
dd4hep::sim::G4PARTICLE_SIM_LEFT_DETECTOR
@ G4PARTICLE_SIM_LEFT_DETECTOR
Definition: Geant4Particle.h:90
key
unsigned char key
Definition: AlignmentsCalculator.cpp:69
dd4hep::sim
Namespace for the Geant4 based simulation part of the AIDA detector description toolkit.
Definition: EDM4hepFileReader.cpp:41
Geant4InputAction.h
dd4hep::sim::EventParameters
Event extension to pass input event data to output event.
Definition: EventParameters.h:28
dd4hep::sim::Geant4EventReader::EVENT_READER_OK
@ EVENT_READER_OK
Definition: Geant4InputAction.h:70
dd4hep::sim::Geant4ParticleHandle
Data structure to access derived MC particle information.
Definition: Geant4Particle.h:181
dd4hep::sim::Geant4Vertex::time
double time
Definition: Geant4Vertex.h:53
dd4hep::sim::Geant4Particle::parents
Particles parents
The list of parents of this MC particle.
Definition: Geant4Particle.h:138
dd4hep::sim::Geant4Particle::vsy
double vsy
Definition: Geant4Particle.h:124
dd4hep::sim::Geant4Vertex::z
double z
Definition: Geant4Vertex.h:53
dd4hep::sim::Geant4EventReader::EVENT_READER_NO_PRIMARIES
@ EVENT_READER_NO_PRIMARIES
Definition: Geant4InputAction.h:72
dd4hep::sim::Geant4Vertex
Data structure to store the MC vertex information.
Definition: Geant4Vertex.h:45
dd4hep::sim::Geant4Particle::charge
char charge
Definition: Geant4Particle.h:119
PropertyMask
dd4hep::detail::ReferenceBitMask< int > PropertyMask
Definition: EDM4hepFileReader.cpp:38
dd4hep::sim::FileParameters::ingestParameters
void ingestParameters(T const &source)
Copy the parameters from source.
Definition: EDM4hepFileReader.cpp:81
dd4hep::sim::Geant4EventReader::Vertices
std::vector< Vertex * > Vertices
Definition: Geant4InputAction.h:66
dd4hep::sim::Geant4Particle::psy
double psy
Definition: Geant4Particle.h:128
dd4hep::sim::RunParameters::ingestParameters
void ingestParameters(T const &source)
Copy the parameters from source.
Definition: EDM4hepFileReader.cpp:66
dd4hep::sim::EDM4hepFileReader::m_eventHeaderCollectionName
std::string m_eventHeaderCollectionName
Name of the EventHeader collection to read.
Definition: EDM4hepFileReader.cpp:108
dd4hep::sim::Geant4Particle::properTime
double properTime
Proper time.
Definition: Geant4Particle.h:136
dd4hep::sim::Geant4Context
Generic context to extend user, run and event information.
Definition: Geant4Context.h:201