MergeG4Collections_module.cc
Go to the documentation of this file.
1 ///////////////////////////////////////////////////////////////////////////
2 // \file MergeG4Collections.cxx
3 // \brief
4 // \authors janow@fnal.gov jmusser@indiana.edu
5 ///////////////////////////////////////////////////////////////////////////
6 #include <math.h>
7 #include <string>
8 
16 #include "fhiclcpp/ParameterSet.h"
18 
19 #include "DAQChannelMap/DAQChannelMap.h"
23 
24 #include "Simulation/FLSHit.h"
25 #include "Simulation/FLSHitList.h"
26 #include "Simulation/Particle.h"
27 #include "Simulation/TrueEnergy.h"
28 #include "Utilities/AssociationUtil.h"
29 
30 
31 ///group hits according to time and space
33 {
35  public:
36 
37  explicit MergeG4Collections(fhicl::ParameterSet const &pset);
38  virtual ~MergeG4Collections();
39 
40  void produce(art::Event& evt);
41 
42  protected:
43 
44  // configuration settings
45  std::string fFirstGenCollection; /// MCTruth main collection label
46  std::string fFirstGenProcessLabel; /// MCTruth process main collection label
47  std::string fFirstG4Collection; /// Geant4 main collection label
49 
50  std::string fMixedGenCollection; /// MCTruth mixed collection label
52 
53  std::string fSecondCollection; /// Label for the mixing module
54 
55  bool ParticleIsInMCTruth(simb::MCParticle part, art::Ptr<simb::MCTruth> mct);
56  bool SameMCTruth(art::Ptr<simb::MCTruth> mct1, art::Ptr<simb::MCTruth> mct2);
57  };
58 
59 
60  //----------------------------------------------------------------------
62  EDProducer(pset),
63  fFirstGenCollection (pset.get< std::string >("FirstGenCollection")),
64  fFirstGenProcessLabel (pset.get< std::string >("FirstGenProcessLabel")),
65  fFirstG4Collection (pset.get< std::string >("FirstG4Collection")),
66  fIsFirstCollectionCosmic(pset.get< bool >("IsFirstCollectionCosmic")),
67  fMixedGenCollection (pset.get< std::string >("ThirdGenCollection")),
68  fMixerProcessLabel (pset.get< std::string >("ThirdCollection")),
69  fSecondCollection (pset.get< std::string >("SecondCollection"))
70  {
71  produces< std::vector<sim::FLSHitList > >();
72  produces< std::vector<sim::Particle> >();
73  produces< std::vector<sim::TrueEnergy> >();
74  produces< art::Assns <sim::Particle , simb::MCTruth> >();
75  produces< art::Assns <sim::TrueEnergy, sim::Particle> >();
76 
77  /*
78  if( fFirstGenCollection == "" ||
79  fFirstGenProcessLabel == "" ||
80  fFirstG4Collection == "" ){
81  std::cerr << "MergeG4Collections: "
82  << "First Collection labels not completely specified. Abort"
83  << std::endl;
84  std::abort();
85  }
86  */
87  if( fMixedGenCollection == "" ||
88  fMixerProcessLabel == "" ){
89  std::cerr << "MergeG4Collections: "
90  << "Mixed Gen Collection labels not completely specified. Abort"
91  << std::endl;
92  std::abort();
93  }
94  }
95 
96  //----------------------------------------------------------------------
97  MergeG4Collections::~MergeG4Collections()
98  {
99  }
100 
101  //----------------------------------------------------------------------
102  void MergeG4Collections::produce(art::Event& evt)
103  {
104 
105  std::unique_ptr< std::vector<sim::FLSHitList> > outFLSHitLists (new std::vector<sim::FLSHitList>);
106  std::unique_ptr< std::vector<sim::Particle > > tempParticles (new std::vector<sim::Particle >);
107  std::unique_ptr< std::vector<sim::Particle > > outParticles (new std::vector<sim::Particle >);
108  std::unique_ptr< std::vector<sim::TrueEnergy> > tempTrueEnergy (new std::vector<sim::TrueEnergy>);
109  std::unique_ptr< std::vector<sim::TrueEnergy> > outTrueEnergy (new std::vector<sim::TrueEnergy>);
110 
111  std::unique_ptr< art::Assns <sim::Particle , simb::MCTruth> > outMCTruthPartAssn(new art::Assns<sim::Particle , simb::MCTruth>);
112  std::unique_ptr< art::Assns <sim::TrueEnergy, sim::Particle> > outTrueEnPartAssn (new art::Assns<sim::TrueEnergy, sim::Particle>);
113 
114  // Push particles from primary collection onto merged collection.
115  // Find largest TrackId that will be used to seed trackID offsets in
116  // secondary file collections.
117  // Particles are pushed onto outParticles, which will hold
118  // combination of primary and secondary streams
119  int IdOffset = 0;
120  int MCListIndex = -1;
121 
122 
123  //// ***** Mixed Collection *****
124  //
125  art::InputTag mixedGenTag(fMixedGenCollection,"",fMixerProcessLabel);
127  evt.getByLabel(mixedGenTag, mixedMCTruths);
128 
129 
130  //// ***** First (primary) Collection *****
131  //
132  if( fFirstGenCollection != "" &&
133  fFirstGenProcessLabel != "" &&
134  fFirstG4Collection != "" ){
135 
136  art::InputTag firstGenTag(fFirstGenCollection,"",fFirstGenProcessLabel);
138  evt.getByLabel(firstGenTag, firstMCTruths);
140  evt.getByLabel(fFirstG4Collection, firstFLSHitLists);
142  evt.getByLabel(fFirstG4Collection, firstParticles);
143 
144  art::FindOneP<simb::MCTruth> MCTruthForParticle( firstParticles, evt,
145  fFirstG4Collection );
146 
147  // sim::TrueEnergy.
148  art::Handle< std::vector<sim::TrueEnergy> > firstTrueEnergies;
149  evt.getByLabel(fFirstG4Collection, firstTrueEnergies);
150  art::FindManyP<sim::TrueEnergy> TrueEnergyAssn(firstParticles, evt, fFirstG4Collection );
151 
152  // For each first-collection particle,
153  for(unsigned int i = 0; i < firstParticles->size(); ++i){
154  sim::Particle part ((*firstParticles)[i]);
155  outParticles->push_back(part);
156  int parTrId = part.TrackId();
157  bool match_truep = false;
158  for(size_t te = 0; te < TrueEnergyAssn.at(i).size(); ++te){
159  if (parTrId == TrueEnergyAssn.at(i)[te]->TrackId()) {
160  match_truep = true;
161  outTrueEnergy->push_back(*TrueEnergyAssn.at(i)[te]);
162  }
163  }
164  if (!match_truep) {
165  for(size_t par2 = 0; par2 < firstParticles->size(); ++par2){
166  for(size_t te = 0; te < TrueEnergyAssn.at(par2).size(); ++te){
167  if (parTrId == TrueEnergyAssn.at(par2)[te]->TrackId()) {
168  match_truep = true;
169  outTrueEnergy->push_back(*TrueEnergyAssn.at(par2)[te]);
170  }
171  if (match_truep) break;
172  }
173  if (match_truep) break;
174  }
175  //AS IN PREVIOUS VERSION, NEED AN ASSN SO STORE A JUNK VALUE FOR THAT PARTICLE.
176  if(!match_truep){
177  outTrueEnergy->push_back( sim::TrueEnergy(parTrId, -5, -5, -5, -5) );
178  }
179  }
180 
181  util::CreateAssn(evt, *outTrueEnPartAssn, *outTrueEnergy, *outParticles, i, (outParticles->size()-1) );
182 
183  // motherID==0 means new MCTruth
184  if(part.Mother() == 0)
185  MCListIndex++;
186 
187  // incriment TrackId offset
188  if(part.TrackId() > IdOffset) IdOffset = part.TrackId();
189  for(int d = 0; d < part.NumberDaughters(); d++)
190  if(part.Daughter(d) > IdOffset)
191  IdOffset = part.Daughter(d);
192 
193  // Find the MCTruth to associate with this particle.
194  // Since the primary file particle list still has an intact MCTruth
195  // association, we can use a simple check on equality of
196  // a set of member variables to find this same MCTruth on the merged
197  // collection (mixedMCTruths)
198 
199  art::Ptr<simb::MCTruth> mct = MCTruthForParticle.at(i);
200 
201 
202  if(fIsFirstCollectionCosmic){
203  // Assume 1 MCTruth per Particle
204  art::Ptr<simb::MCTruth> mcptr(mixedMCTruths,MCListIndex);
205  util::CreateAssn(evt, *outParticles, mcptr ,
206  *outMCTruthPartAssn, outParticles->size() - 1);
207  } else {
208  // Otherwise assume a neutrino
209 
210  bool foundMCT = false;
211  for(unsigned int imc = 0; imc < mixedMCTruths->size(); imc++){
212  art::Ptr<simb::MCTruth> mixed_mct(mixedMCTruths, imc);
213 
214  if( SameMCTruth(mct,mixed_mct) ){
215  // Check that original particle is in this equivalent MCTruth
216  if(part.Mother() == 0 && !ParticleIsInMCTruth(part,mixed_mct))
217  mf::LogWarning("MergeG4Collection")
218  << " !!! possible primary list particle and MCTruth position mismatch !!!";
219 
220  util::CreateAssn(evt, *outParticles, mixed_mct, *outMCTruthPartAssn, outParticles->size() - 1);
221  foundMCT = true;
222  break;
223  }
224  }
225  if(!foundMCT)
226  mf::LogWarning("MergeG4Collection")
227  << "MCTruth to primary collection particle not found";
228  }
229  } // firstParticles loop
230 
231  //Set initial MCListIndex for secondary files
232  if(firstMCTruths->size() > 0) MCListIndex = firstMCTruths->size() - 1;
233 
234 
235  // Save FLSHit list for each MCTruth
236  if(firstMCTruths->size() != firstFLSHitLists->size())
237  mf::LogWarning("MergeG4Collections")
238  << " MC/FLSHitList size mismatch in first collection";
239  for(unsigned int i = 0; i < firstMCTruths->size(); ++i)
240  if(i < firstFLSHitLists->size())
241  outFLSHitLists->push_back((*firstFLSHitLists)[i]);
242 
243  }
244  //
245  //// *** If first collection specified ***
246 
247 
248 
249  //// ***** Secondary Collections *****
250  //
251  if( fSecondCollection!="" ){ // Optionally ignore second collection
252  // (for Data in a Data-MC merge)
253 
254  art::Handle< std::vector<simb::MCTruth> > SecFileMCTruthlistCol;
255  evt.getByLabel(fSecondCollection, SecFileMCTruthlistCol);
256 
257  art::Handle< std::vector<sim::FLSHitList> > SecFileFLSHitlistCol;
258  evt.getByLabel(fSecondCollection, SecFileFLSHitlistCol);
259 
260  if(SecFileMCTruthlistCol->size() != SecFileFLSHitlistCol->size())
261  mf::LogWarning("MergeG4Collections")
262  << " MC/FLSHitList size mismatch in second collection";
263 
264  art::Handle< std::vector<sim::Particle> > SecFileParticlelistCol;
265  evt.getByLabel(fSecondCollection, SecFileParticlelistCol);
266 
267  // sim::TrueEnergy.
268  art::Handle< std::vector<sim::TrueEnergy> > SecFileTrueEnergies;
269  evt.getByLabel(fSecondCollection, SecFileTrueEnergies);
270 
271  int nParticle = 0;
272  int trackIDList[100000]; // used as check of FLSHitList TrackID consistency
273  int LastPartId = 0;
274  int *Offset = new int[1000]; // holds trackID offsets, one/MCTruth
275  int OffsetIndex = 1;
276 
277  for(int i = 0; i < 1000; i++){
278  Offset[i] = 0;
279  }
280  Offset[0] = IdOffset; // TrackID offset for first secondary MCTruth is the largest trackID from primary
281 
282  int MCindex = MCListIndex;
283  if(MCindex < 0) MCindex = 0;
284  bool first = true;
285 
286  // Loop over all secondary file particles, finding the event boundaries.
287  // The MCTruth/Particle matching algorithm is based on looking for a
288  // particle in the MCTruth particle list at the same vertex location
289  // as the particle from SecFileParticlelistCol. If we don't find one,
290  // and the particle's motherID==0 we move to the next MCTruth entry.
291  for(unsigned int i = 0; i < SecFileParticlelistCol->size(); ++i){
292  sim::Particle part ((*SecFileParticlelistCol)[i]); // local copy of this particle
293  art::Ptr<simb::MCTruth> mcptr(mixedMCTruths, MCindex); // grab MCTruth at current index
294  bool partInMCT = ParticleIsInMCTruth(part,mcptr);
295 
296  if((LastPartId >= part.TrackId()) || (part.Mother()==0 && !partInMCT ) ){ // make check on MCTruth/Particle consistency
297  if(!first){
298  Offset[OffsetIndex] = Offset[OffsetIndex-1] + LastPartId; //if here, new particle must be start of next event
299  OffsetIndex++;
300  }
301  if(MCindex+1 < (int)mixedMCTruths->size()) MCindex++;
302  }
303  first = false;
304  LastPartId = part.TrackId();
305 
306  // Construct new particle with offset trackID and add to particle
307  // collection. We must also offset daughters, and motherID
308  // (if motherID is not zero)
309 
310  int partmother = 0;
311  if(part.Mother() != 0)partmother = part.Mother() + Offset[OffsetIndex-1];
312 
313  sim::Particle gpart(part.TrackId() + Offset[OffsetIndex-1],
314  part.PdgCode(),
315  part.Process(),
316  partmother,
317  part.Mass(),
318  part.StatusCode());
319 
320  gpart.SetGvtx(part.Gvx(), part.Gvy(),part.Gvz(),part.Gvt());
321  gpart.SetPolarization(part.Polarization());
322  gpart.SetWeight(part.Weight());
323  gpart.SetRescatter(part.Rescatter());
324  for(int d = 0; d < part.NumberDaughters(); d++){
325  gpart.AddDaughter(part.Daughter(d) + Offset[OffsetIndex-1]);
326  }
327  for(unsigned int t = 0; t < part.NumberTrajectoryPoints(); t++){
328  gpart.AddTrajectoryPoint(part.Position(t), part.Momentum(t));
329  }
330  tempParticles->push_back(gpart);
331 
332  // sim::TrueEnergy
333  sim::TrueEnergy TrueEn = ((*SecFileTrueEnergies)[i]);
334 
335  if (part.TrackId() != TrueEn.TrackId()) {
336  std::cout << "sim::TrueEnergy TrackId doesn't match... Part TrackId" << part.TrackId() << ", TrueEn TrackId " << TrueEn.TrackId()
337  << ". Need an assn, so going to store a junk TrueEn for this particle." << std::endl;
338  tempTrueEnergy->push_back( sim::TrueEnergy(TrueEn.TrackId() + Offset[OffsetIndex-1], -5, -5, -5, -5) );
339  } else {
340  sim::TrueEnergy gTrueEn( TrueEn.TrackId() + Offset[OffsetIndex-1],
341  TrueEn.EnteringEnergy(),
342  TrueEn.EscapingEnergy(),
343  TrueEn.TotalDepEnergy(),
344  TrueEn.TotalEscEnergy() );
345  tempTrueEnergy->push_back(gTrueEn);
346  }
347 
348  // this array is used just to check consistency of results for FLSHit matching later
349  trackIDList[nParticle] = part.TrackId() + Offset[OffsetIndex-1];
350 
351  nParticle++;
352  } // secondary Particles loop
353 
354  // Loop over secondary MCTruth list; has same size as FLSHitList
355  for(unsigned int i = 0; i < SecFileMCTruthlistCol->size(); ++i){
356  if(i < SecFileFLSHitlistCol->size()){
357 
358  sim::FLSHitList mcfls ((*SecFileFLSHitlistCol)[i]);
359  sim::FLSHitList tmcfls;
360  sim::FLSHit fHit;
361 
362  // add flshits to final list offsetting trackIDs
363  const std::vector<sim::FLSHit>& hits = mcfls.fHits;
364  for (unsigned int j = 0; j < hits.size(); ++j){
365  fHit.Clear();
366  fHit = hits[j];
367  fHit.SetTrackId(hits[j].GetTrackID() + Offset[i]);
368  tmcfls.fHits.push_back(fHit);
369 
370  // Ccheck that this FLSHit trackID is on the particle trackID list
371  // failure just results in warning message being printed
372  bool foundpart=false;
373  for(int ip = 0; ip < nParticle; ip++){
374  if(hits[j].GetTrackID() + Offset[i] == trackIDList[ip]){
375  foundpart = true;
376  break;
377  }
378  }
379  if(!foundpart){
380  mf::LogWarning("MergeG4Collections") << " !!!FLSHit problem "
381  << i << " "
382  << j << " "
383  << hits[j].GetTrackID() << " "
384  << Offset[i];
385  }
386  }
387  outFLSHitLists->push_back(tmcfls);
388  }
389  else mf::LogWarning("MergeG4Collections") << "FLSHitList length - MCList length mismatch!" << std::endl;
390  } // secondary MCTruths
391 
392  // Create Particlelist:MCTruth association
393 
394  LastPartId = 0;
395  int partcount = 0;
396  first = true;
397  // set MCList index to first secondary event location
398  if(MCListIndex + 1 < (int)mixedMCTruths->size())
399  MCListIndex++;
400  else
401  mf::LogWarning("MergeG4Collections")
402  << "!!! Caught MCListIndex MCTruth size mismatch !!! ";
403 
404 
405  //repeat loop over particle list
406  for(unsigned int j = 0; j < tempParticles->size(); ++j){
407  sim::Particle part ((*tempParticles)[j]);
408  sim::Particle oldpart ((*SecFileParticlelistCol)[j]);
409 
410  art::Ptr<simb::MCTruth> mcptr(mixedMCTruths, MCListIndex); //grab MCTruth at index location
411 
412  // Check that the particle can be found on this MCTruth particle list.
413  // If not increment MCTruth index
414  bool partInMCT = ParticleIsInMCTruth(part,mcptr);
415 
416  //check whether to increment MCTruth
417  if((LastPartId >= oldpart.TrackId()) || (part.Mother() == 0 && !partInMCT && !first )){
418 
419  if(MCListIndex +1 < (int)mixedMCTruths->size())
420  MCListIndex++;
421  else
422  mf::LogWarning("MergeG4Collections")
423  << "!!! caught MCListIndex MCTruth size mismatch !!!";
424 
425  partcount = 0;
426  }
427 
428  // Check position of mother=0 with updated list index.
429  // Should always find a match - this is just a check
430  art::Ptr<simb::MCTruth> mcptr2(mixedMCTruths, MCListIndex);
431  bool partInMCT2 = ParticleIsInMCTruth(part,mcptr2);
432 
433  if(part.Mother() == 0 && !partInMCT2 )
434  mf::LogWarning("MergeG4Collections")
435  << "!!! Secondary particle and MCTruth particle list mismatch !!!";
436  first = false;
437  LastPartId = oldpart.TrackId();
438 
439  outParticles->push_back(part); //push this particle onto final particle list and make association
440  util::CreateAssn(evt, *outParticles, mcptr2 , *outMCTruthPartAssn, outParticles->size()-1);
441 
442  // sim::TrueEnergy
443  sim::TrueEnergy TrueEn = ((*tempTrueEnergy)[j]);
444  outTrueEnergy->push_back( TrueEn );
445  util::CreateAssn(evt, *outTrueEnPartAssn, *outTrueEnergy, *outParticles, j, (outParticles->size()-1) );
446 
447  partcount ++;
448  } // tempParticles loop
449 
450  delete [] Offset ;
451 
452  } // If secondary labels are specified
453 
454 
455  // put the collections in the event
456  evt.put(std::move(outFLSHitLists));
457  evt.put(std::move(outParticles ));
458  evt.put(std::move(outTrueEnergy ));
459  evt.put(std::move(outMCTruthPartAssn));
460  evt.put(std::move(outTrueEnPartAssn ));
461  }
462 
463 
464  //----------------------------------------------------------------------
465  bool MergeG4Collections::ParticleIsInMCTruth( simb::MCParticle part,
467  {
468  // check for particle in mct with same start position as part
469  for(int i = 0; i < mct->NParticles(); i++){
470  simb::MCParticle mct_part = mct->GetParticle(i);
471  float vpartsep = sqrt((part.Vx()-mct_part.Vx())*(part.Vx()-mct_part.Vx())+
472  (part.Vy()-mct_part.Vy())*(part.Vy()-mct_part.Vy())+
473  (part.Vz()-mct_part.Vz())*(part.Vz()-mct_part.Vz()));
474  if(vpartsep < 0.01) return true;
475  }
476  return false;
477  }
478 
479 
480  //----------------------------------------------------------------------
481  bool MergeG4Collections::SameMCTruth( art::Ptr<simb::MCTruth> mct1,
483  {
484  // neutrino vertex and bjorken x & y are enough to constitute equality
485  return ( (mct1->GetNeutrino().X() == mct2->GetNeutrino().X()) &&
486  (mct1->GetNeutrino().Y() == mct2->GetNeutrino().Y()) &&
487  (mct1->GetNeutrino().Nu().Vx() == mct2->GetNeutrino().Nu().Vx()) &&
488  (mct1->GetNeutrino().Nu().Vy() == mct2->GetNeutrino().Nu().Vy()) &&
489  (mct1->GetNeutrino().Nu().Vz() == mct2->GetNeutrino().Nu().Vz()) );
490  }
491 
493 
494 } //end namespace merge
495 ////////////////////////////////////////////////////////////////////////////
unsigned int NumberTrajectoryPoints() const
Definition: MCParticle.h:217
const TVector3 & Polarization() const
Definition: MCParticle.h:213
void SetTrackId(const int trackid)
Definition: FLSHit.h:101
const TLorentzVector & Position(const int i=0) const
Definition: MCParticle.h:218
static bool CreateAssn(art::EDProducer const &prod, art::Event &evt, std::vector< T > &a, art::Ptr< U > b, art::Assns< T, U > &assn, size_t indx=UINT_MAX, std::string const &instance=std::string())
Create a 1 to 1 association between a new product and one already in the event.
int PdgCode() const
Definition: MCParticle.h:211
int TrackId() const
Definition: TrueEnergy.h:36
std::vector< sim::FLSHit > fHits
Definition: FLSHitList.h:21
const simb::MCNeutrino & GetNeutrino() const
Definition: MCTruth.h:77
double Gvz() const
Definition: MCParticle.h:247
double Weight() const
Definition: MCParticle.h:253
int Mother() const
Definition: MCParticle.h:212
const simb::MCParticle & Nu() const
Definition: MCNeutrino.h:146
T sqrt(T number)
Definition: d0nt_math.hpp:156
double Mass() const
Definition: MCParticle.h:238
std::string fMixerProcessLabel
MCTruth mixed collection label.
std::string fFirstG4Collection
MCTruth process main collection label.
OStream cerr
Definition: OStream.cxx:7
int StatusCode() const
Definition: MCParticle.h:210
TString ip
Definition: loadincs.C:5
double Gvx() const
Definition: MCParticle.h:245
A single unit of energy deposition in the liquid scintillator.
Definition: FLSHit.h:19
int NParticles() const
Definition: MCTruth.h:75
DEFINE_ART_MODULE(TestTMapFile)
double Gvy() const
Definition: MCParticle.h:246
std::string Process() const
Definition: MCParticle.h:214
float EscapingEnergy() const
Definition: TrueEnergy.h:38
int NumberDaughters() const
Definition: MCParticle.h:216
float TotalEscEnergy() const
Definition: TrueEnergy.h:40
object containing MC flux information
float EnteringEnergy() const
Definition: TrueEnergy.h:37
int TrackId() const
Definition: MCParticle.h:209
int Daughter(const int i) const
Definition: MCParticle.cxx:112
TString part[npart]
Definition: Style.C:32
bool getByLabel(std::string const &label, std::string const &instance, Handle< PROD > &result) const
Definition: DataViewImpl.h:446
void hits()
Definition: readHits.C:15
double Y() const
Definition: MCNeutrino.h:156
int evt
Float_t d
Definition: plot.C:236
double X() const
Definition: MCNeutrino.h:155
const double j
Definition: BetheBloch.cxx:29
std::string fFirstGenProcessLabel
MCTruth main collection label.
OStream cout
Definition: OStream.cxx:6
const simb::MCParticle & GetParticle(int i) const
Definition: MCTruth.h:76
double Vx(const int i=0) const
Definition: MCParticle.h:220
size_t Offset(bool allow_default)
Value passed to –offset, or 0 if not specified.
Definition: Utilities.cxx:395
void SetGvtx(double *v)
Definition: MCParticle.cxx:120
group hits according to time and space
A vector of FLSHit from single neutrino interaction.
Definition: FLSHitList.h:13
double Gvt() const
Definition: MCParticle.h:248
const TLorentzVector & Momentum(const int i=0) const
Definition: MCParticle.h:219
MaybeLogger_< ELseverityLevel::ELsev_warning, false > LogWarning
void Clear()
Clear the FLS hit.
Definition: FLSHit.cxx:39
int Rescatter() const
Definition: MCParticle.h:251
double Vz(const int i=0) const
Definition: MCParticle.h:222
ProductID put(std::unique_ptr< PROD > &&edp, FullSemantic< Level::Run > const semantic)
Definition: DataViewImpl.h:730
float TotalDepEnergy() const
Definition: TrueEnergy.h:39
bool fIsFirstCollectionCosmic
Geant4 main collection label.
double Vy(const int i=0) const
Definition: MCParticle.h:221
enum BeamMode string