LArSoft  v06_85_00
Liquid Argon Software toolkit - http://larsoft.org/
SimPhotonCounter_module.cc
Go to the documentation of this file.
1 // \file SimPhotonCounter.h
2 // \author Ben Jones, MIT 2010
3 //
4 // Module to determine how many phots have been detected at each OpDet
5 //
6 // This analyzer takes the SimPhotonsCollection generated by LArG4's sensitive detectors
7 // and fills up to four trees in the histograms file. The four trees are:
8 //
9 // OpDetEvents - count how many phots hit the OpDet face / were detected across all OpDet's per event
10 // OpDets - count how many phots hit the OpDet face / were detected in each OpDet individually for each event
11 // AllPhotons - wavelength information for each phot hitting the OpDet face
12 // DetectedPhotons - wavelength information for each phot detected
13 //
14 // The user may supply a quantum efficiency and sensitive wavelength range for the OpDet's.
15 // with a QE < 1 and a finite wavelength range, a "detected" phot is one which is
16 // in the relevant wavelength range and passes the random sampling condition imposed by
17 // the quantum efficiency of the OpDet
18 //
19 // PARAMETERS REQUIRED:
20 // int32 Verbosity - whether to write to screen a well as to file. levels 0 to 3 specify different levels of detail to display
21 // string InputModule - the module which produced the SimPhotonsCollection
22 // bool MakeAllPhotonsTree - whether to build and store each tree (performance can be enhanced by switching off those not required)
23 // bool MakeDetectedPhotonsTree
24 // bool MakeOpDetsTree
25 // bool MakeOpDetEventsTree
26 // double QantumEfficiency - Quantum efficiency of OpDet
27 // double WavelengthCutLow - Sensitive wavelength range of OpDet
28 // double WavelengthCutHigh
29 #ifndef SimPhotonCounterModule_h
30 #define SimPhotonCounterModule_h 1
31 
32 // ROOT includes.
33 #include "TTree.h"
34 #include "TFile.h"
35 #include <Rtypes.h>
36 
37 // FMWK includes
41 #include "fhiclcpp/ParameterSet.h"
49 
50 // LArSoft includes
59 
60 // ROOT includes
61 #include <TH1D.h>
62 #include <TF1.h>
63 #include <TTree.h>
64 
65 // C++ language includes
66 #include <iostream>
67 #include <sstream>
68 #include <cstring>
69 #include <vector>
70 
71 #include "CLHEP/Random/RandFlat.h"
72 #include "CLHEP/Random/RandGaussQ.h"
73 
74 namespace opdet {
75 
76  class SimPhotonCounter : public art::EDAnalyzer{
77  public:
78 
80  virtual ~SimPhotonCounter();
81 
82  void analyze(art::Event const&);
83 
84  void beginJob();
85  void endJob();
86 
87  private:
88 
89  // Trees to output
90 
93  TTree * fTheOpDetTree;
94  TTree * fTheEventTree;
95 
96 
97  // Parameters to read in
98 
99  std::vector<std::string> fInputModule; // Input tag for OpDet collection
100 
101  int fVerbosity; // Level of output to write to std::out
102 
105  bool fMakeOpDetsTree; // Switches to turn on or off each output
107 
108  // float fQE; // Quantum efficiency of tube
109 
110  // float fWavelengthCutLow; // Sensitive wavelength range
111  // float fWavelengthCutHigh; //
112 
115 
116 
117  // Data to store in trees
118 
119  Float_t fWavelength;
120  Float_t fTime;
121  // Int_t fCount;
125  Float_t fT0_vis;
126 
129  // Int_t fCountEventDetectedwithRefl;
130 
131  Int_t fEventID;
132  Int_t fOpChannel;
133 
134  //for the analysis tree of the light (gamez)
136  std::vector<std::vector<std::vector<double> > > fSignals_vuv;
137  std::vector<std::vector<std::vector<double> > > fSignals_vis;
138 
141  double fEnergy, fdEdx;
142  std::vector<double> fPosition0;
143  std::vector<std::vector<double> > fstepPrePositions;
144  std::vector<std::vector<double> > fstepPostPositions;
145  std::vector<double> fstepPreTimes;
146  std::vector<double> fstepPostTimes;
147  std::vector<std::vector<double> > fSignalsvuv;
148  std::vector<std::vector<double> > fSignalsvis;
149  std::string fProcess;
150 
152  };
153 }
154 
155 #endif
156 
157 
158 namespace opdet {
159 
160 
162  : EDAnalyzer(pset)
163  {
164  fVerbosity= pset.get<int>("Verbosity");
165  try
166  {
167  fInputModule = pset.get<std::vector<std::string>>("InputModule",{"largeant"});
168  }
169  catch(...)
170  {
171  fInputModule.push_back(pset.get<std::string>("InputModule","largeant"));
172  }
173  fMakeAllPhotonsTree= pset.get<bool>("MakeAllPhotonsTree");
174  fMakeDetectedPhotonsTree= pset.get<bool>("MakeDetectedPhotonsTree");
175  fMakeOpDetsTree= pset.get<bool>("MakeOpDetsTree");
176  fMakeOpDetEventsTree= pset.get<bool>("MakeOpDetEventsTree");
177  fMakeLightAnalysisTree= pset.get<bool>("MakeLightAnalysisTree", false);
178  //fQE= pset.get<double>("QuantumEfficiency");
179  //fWavelengthCutLow= pset.get<double>("WavelengthCutLow");
180  //fWavelengthCutHigh= pset.get<double>("WavelengthCutHigh");
181  }
182 
183 
185  {
186  // Get file service to store trees
190 
191  try {
193  }
194  catch (art::Exception const& e) {
195  if (e.categoryCode() != art::errors::ServiceNotFound) throw;
196  mf::LogError("SimPhotonCounter")
197  << "ParticleInventoryService service is not configured!"
198  " Please add it in the job configuration."
199  " In the meanwhile, some checks to particles will be skipped."
200  ;
201  }
202 
203  // Create and assign branch addresses to required tree
205  {
206  fThePhotonTreeAll = tfs->make<TTree>("AllPhotons","AllPhotons");
207  fThePhotonTreeAll->Branch("EventID", &fEventID, "EventID/I");
208  fThePhotonTreeAll->Branch("Wavelength", &fWavelength, "Wavelength/F");
209  fThePhotonTreeAll->Branch("OpChannel", &fOpChannel, "OpChannel/I");
210  fThePhotonTreeAll->Branch("Time", &fTime, "Time/F");
211  }
212 
214  {
215  fThePhotonTreeDetected = tfs->make<TTree>("DetectedPhotons","DetectedPhotons");
216  fThePhotonTreeDetected->Branch("EventID", &fEventID, "EventID/I");
217  fThePhotonTreeDetected->Branch("Wavelength", &fWavelength, "Wavelength/F");
218  fThePhotonTreeDetected->Branch("OpChannel", &fOpChannel, "OpChannel/I");
219  fThePhotonTreeDetected->Branch("Time", &fTime, "Time/F");
220  }
221 
222  if(fMakeOpDetsTree)
223  {
224  fTheOpDetTree = tfs->make<TTree>("OpDets","OpDets");
225  fTheOpDetTree->Branch("EventID", &fEventID, "EventID/I");
226  fTheOpDetTree->Branch("OpChannel", &fOpChannel, "OpChannel/I");
227  fTheOpDetTree->Branch("CountAll", &fCountOpDetAll, "CountAll/I");
228  fTheOpDetTree->Branch("CountDetected", &fCountOpDetDetected, "CountDetected/I");
229  if(pvs->StoreReflected())
230  fTheOpDetTree->Branch("CountReflDetected", &fCountOpDetReflDetected, "CountReflDetected/I");
231  fTheOpDetTree->Branch("Time", &fTime, "Time/F");
232  }
233 
235  {
236  fTheEventTree = tfs->make<TTree>("OpDetEvents","OpDetEvents");
237  fTheEventTree->Branch("EventID", &fEventID, "EventID/I");
238  fTheEventTree->Branch("CountAll", &fCountEventAll, "CountAll/I");
239  fTheEventTree->Branch("CountDetected",&fCountEventDetected,"CountDetected/I");
240  if(pvs->StoreReflected())
241  fTheOpDetTree->Branch("CountReflDetected", &fCountOpDetReflDetected, "CountReflDetected/I");
242 
243  }
244 
245  //generating the tree for the light analysis:
247  {
248  fLightAnalysisTree = tfs->make<TTree>("LightAnalysis","LightAnalysis");
249  fLightAnalysisTree->Branch("RunNumber",&fRun);
250  fLightAnalysisTree->Branch("EventID",&fEventID);
251  fLightAnalysisTree->Branch("TrackID",&fTrackID);
252  fLightAnalysisTree->Branch("PdgCode",&fpdg);
253  fLightAnalysisTree->Branch("MotherTrackID",&fmotherTrackID);
254  fLightAnalysisTree->Branch("Energy",&fEnergy);
255  fLightAnalysisTree->Branch("dEdx",&fdEdx);
256  fLightAnalysisTree->Branch("StepPrePositions",&fstepPrePositions);
257  fLightAnalysisTree->Branch("StepPostPositions",&fstepPostPositions);
258  fLightAnalysisTree->Branch("StepPreTimes",&fstepPreTimes);
259  fLightAnalysisTree->Branch("StepPostTimes",&fstepPostTimes);
260  fLightAnalysisTree->Branch("SignalsVUV",&fSignalsvuv);
261  fLightAnalysisTree->Branch("SignalsVisible",&fSignalsvis);
262  fLightAnalysisTree->Branch("Process",&fProcess);
263 
264  const int maxNtracks = 1000;
265  fSignals_vuv.clear();
266  fSignals_vuv.resize(maxNtracks);
267  fSignals_vis.clear();
268  fSignals_vis.resize(maxNtracks);
269  for(size_t itrack=0; itrack!=maxNtracks; itrack++) {
270  fSignals_vuv[itrack].resize(geo->NOpChannels());
271  fSignals_vis[itrack].resize(geo->NOpChannels());
272  }
273 
274  fstepPrePositions.clear();
275  fstepPostPositions.clear();
276  fstepPreTimes.clear();
277  fstepPostTimes.clear();
278 
279  }
280 
281  }
282 
283 
285  {
286  }
287 
289  {
291 
292  if(vis->IsBuildJob())
293  {
294  vis->StoreLibrary();
295  }
296  }
297 
299  {
300 
301  // Lookup event ID from event
302  art::EventNumber_t event = evt.id().event();
303  fEventID=Int_t(event);
304 
306 
308  bool fUseLitePhotons = lgp->UseLitePhotons();
309 
310  // Service for determining opdet responses
312 
313  // get the geometry to be able to figure out signal types and chan -> plane mappings
315 
316  //-------------------------stimation of dedx per trackID------------------------
317 
318  //get the list of particles from this event
319  double totalEnergy_track[1000] = {0.};
321  const sim::ParticleList* plist = pi_serv? &(pi_serv->ParticleList()): nullptr;
322 
323  // loop over all sim::SimChannels in the event and make sure there are no
324  // sim::IDEs with trackID values that are not in the sim::ParticleList
325  std::vector<const sim::SimChannel*> sccol;
326  //evt.getView(fG4ModuleLabel, sccol);
327  for(auto mod : fInputModule){
328  evt.getView(mod, sccol);
329  double totalCharge=0.0;
330  double totalEnergy=0.0;
331  //loop over the sim channels collection
332  for(size_t sc = 0; sc < sccol.size(); ++sc){
333  double numIDEs=0.0;
334  double scCharge=0.0;
335  double scEnergy=0.0;
336  const auto & tdcidemap = sccol[sc]->TDCIDEMap();
337  //loop over all of the tdc IDE map objects
338  for(auto mapitr = tdcidemap.begin(); mapitr != tdcidemap.end(); mapitr++){
339  const std::vector<sim::IDE> idevec = (*mapitr).second;
340  numIDEs += idevec.size();
341  //go over all of the IDEs in a given simchannel
342  for(size_t iv = 0; iv < idevec.size(); ++iv){
343  if (plist) {
344  if(plist->find( idevec[iv].trackID ) == plist->end()
345  && idevec[iv].trackID != sim::NoParticleId)
346  {
347  mf::LogWarning("LArG4Ana") << idevec[iv].trackID << " is not in particle list";
348  }
349  }
350  if(idevec[iv].trackID < 0) continue;
351  totalCharge +=idevec[iv].numElectrons;
352  scCharge += idevec[iv].numElectrons;
353  totalEnergy +=idevec[iv].energy;
354  scEnergy += idevec[iv].energy;
355 
356  totalEnergy_track[idevec[iv].trackID] += idevec[iv].energy/3.;
357  }
358  }
359  }
360  }
361  }//End of if(fMakeLightAnalysisTree)
362 
363 
364  if(!fUseLitePhotons)
365  {
366 
367  //Reset counters
368  fCountEventAll=0;
370 
371  //Get SimPhotonsCollection from Event
372 
373  for(auto mod : fInputModule){
375 
376 
377  if(TheHitCollection.size()>0)
378  {
380  //resetting the signalt to save in the analysis tree per event
381  const int maxNtracks = 1000;
382  for(size_t itrack=0; itrack!=maxNtracks; itrack++) {
383  for(size_t pmt_i=0; pmt_i!=geo->NOpChannels(); pmt_i++) {
384  fSignals_vuv[itrack][pmt_i].clear();
385  fSignals_vis[itrack][pmt_i].clear();
386  }
387  }
388  }
389 
390  if(fVerbosity > 0) std::cout<<"Found OpDet hit collection of size "<< TheHitCollection.size()<<std::endl;
391  if(TheHitCollection.size()>0)
392  {
393  for(sim::SimPhotonsCollection::const_iterator itOpDet=TheHitCollection.begin(); itOpDet!=TheHitCollection.end(); itOpDet++)
394  {
395  //Reset Counters
396  fCountOpDetAll=0;
399  //Reset t0 for visible light
400  fT0_vis = 999.;
401 
402  //Get data from HitCollection entry
403  fOpChannel=itOpDet->first;
404  const sim::SimPhotons& TheHit=itOpDet->second;
405 
406  //std::cout<<"OpDet " << fOpChannel << " has size " << TheHit.size()<<std::endl;
407 
408  // Loop through OpDet phots.
409  // Note we make the screen output decision outside the loop
410  // in order to avoid evaluating large numbers of unnecessary
411  // if conditions.
412 
413  if(fVerbosity > 3)
414  {
415  for(const sim::OnePhoton& Phot: TheHit)
416  {
417  // Calculate wavelength in nm
418  fWavelength= odresponse->wavelength(Phot.Energy);
419 
420  //Get arrival time from phot
421  fTime= Phot.Time;
422 
423  // Increment per OpDet counters and fill per phot trees
424  fCountOpDetAll++;
426  if(odresponse->detected(fOpChannel, Phot))
427  {
429  //only store direct direct light
430  if(!pvs->StoreReflected() || (pvs->StoreReflected() && fWavelength <200 ))
432  // reflected and shifted light is in visible range
433  else if(pvs->StoreReflected() && fWavelength >380 ) {
435  // find the first visible arrival time
436  if(pvs->StoreReflT0() && fTime < fT0_vis)
437  fT0_vis = fTime;
438  }
439 
440  std::cout<<"OpDetResponseInterface PerPhoton : Event "<<fEventID<<" OpChannel " <<fOpChannel << " Wavelength " << fWavelength << " Detected 1 "<<std::endl;
441  }
442  else
443  std::cout<<"OpDetResponseInterface PerPhoton : Event "<<fEventID<<" OpChannel " <<fOpChannel << " Wavelength " << fWavelength << " Detected 0 "<<std::endl;
444  }
445  }
446  else
447  {
448  for(const sim::OnePhoton& Phot: TheHit)
449  {
450  // Calculate wavelength in nm
451  fWavelength= odresponse->wavelength(Phot.Energy);
452  fTime= Phot.Time;
453 
455  if(fWavelength <200)
456  fSignals_vuv[Phot.MotherTrackID][fOpChannel].push_back(fTime);
457  else
458  fSignals_vis[Phot.MotherTrackID][fOpChannel].push_back(fTime);
459 
460  initialPhotonPosition = Phot.InitialPosition;
461  finalPhotonPosition = Phot.FinalLocalPosition;
462  }
463 
464  // Increment per OpDet counters and fill per phot trees
465  fCountOpDetAll++;
467  if(odresponse->detected(fOpChannel, Phot))
468  {
470  //only store direct/UV light
471  if(!pvs->StoreReflected() || (pvs->StoreReflected() && fWavelength <200 ))
473  //shifted light is in visible range
474  else if(pvs->StoreReflected() && fWavelength >380 ) {
476  // find the first visible arrival time
477  if(pvs->StoreReflT0() && fTime < fT0_vis )
478  fT0_vis= fTime;
479  }
480  }
481  }
482  }
483 
484  // If this is a library building job, fill relevant entry
486  if(pvs->IsBuildJob())
487  {
488  int VoxID; double NProd;
489  pvs->RetrieveLightProd(VoxID, NProd);
490  pvs->SetLibraryEntry(VoxID, fOpChannel, double(fCountOpDetDetected)/NProd);
491  //store reflected light
492  if(pvs->StoreReflected())
493  pvs->SetLibraryEntry(VoxID, fOpChannel, double(fCountOpDetReflDetected)/NProd,true);
494  //store reflected first arrival time
495  if(pvs->StoreReflT0())
497  }
498 
499  // Incremenent per event and fill Per OpDet trees
500  if(fMakeOpDetsTree) fTheOpDetTree->Fill();
503 
504  // Give per OpDet output
505  if(fVerbosity >2) std::cout<<"OpDetResponseInterface PerOpDet : Event "<<fEventID<<" OpDet " << fOpChannel << " All " << fCountOpDetAll << " Det " <<fCountOpDetDetected<<std::endl;
506  }
507 
508  // Fill per event tree
510 
511  // Give per event output
512  if(fVerbosity >1) std::cout<<"OpDetResponseInterface PerEvent : Event "<<fEventID<<" All " << fCountOpDetAll << " Det " <<fCountOpDetDetected<<std::endl;
513 
514  }
515  else
516  {
517  // if empty OpDet hit collection,
518  // add an empty record to the per event tree
520  }
522  std::cout<<"Building the analysis tree"<<std::endl;
523  //---------------Building the analysis tree-----------:
524  fRun = evt.run();
525  std::vector<double> thisPrexyz;
526  std::vector<double> thisPostxyz;
527 
529  evt.getByLabel("mcreco",mctrackHandle);
530  std::vector<sim::MCTrack> const& mctrackVec(*mctrackHandle);
531 
532  //loop over the particles (so over the tracks)
533  fEnergy = mctrackVec[0][0].E();
534  for(size_t i_p=0; i_p < mctrackVec.size(); i_p++){
535  //resetting the vectors
536  fstepPrePositions.clear();
537  fstepPostPositions.clear();
538  fstepPreTimes.clear();
539  fstepPostTimes.clear();
540  fSignalsvuv.clear();
541  fSignalsvis.clear();
542  fdEdx = -1.;
543  //filling the tree fields
544  fTrackID = mctrackVec[i_p].TrackID();
545  fpdg = mctrackVec[i_p].PdgCode();
546  fmotherTrackID = mctrackVec[i_p].MotherTrackID();
547  fdEdx = totalEnergy_track[fTrackID];
550  fProcess = mctrackVec[i_p].Process();
551  //filling the center positions of each step
552  for(size_t i_s=1; i_s < mctrackVec[i_p].size(); i_s++){
553  TVector3 const& vec1 = mctrackVec[i_p][i_s-1].Position().Vect();
554  TVector3 const& vec2 = mctrackVec[i_p][i_s].Position().Vect();
555  thisPrexyz.clear();
556  thisPrexyz.resize(3);
557  thisPrexyz[0] = vec1.X();
558  thisPrexyz[1] = vec1.Y();
559  thisPrexyz[2] = vec1.Z();
560  fstepPrePositions.push_back(thisPrexyz);
561  thisPostxyz.clear();
562  thisPostxyz.resize(3);
563  thisPostxyz[0] = vec2.X();
564  thisPostxyz[1] = vec2.Y();
565  thisPostxyz[2] = vec2.Z();
566  fstepPostPositions.push_back(thisPostxyz);
567  fstepPreTimes.push_back(mctrackVec[i_p][i_s-1].T());
568  fstepPostTimes.push_back(mctrackVec[i_p][i_s].T());
569  //double stepL = (vec2-vec1).Mag();
570  //std::cout<<"step length: "<<stepL<<std::endl;
571 
572  }
573  //filling the tree per track
574  fLightAnalysisTree->Fill();
575  }
576  }
577  }
578  }
579  }
580 
581 
582  if (fUseLitePhotons)
583  {
584  //Get SimPhotonsLite from Event
585 
586  for(auto mod : fInputModule){
588  evt.getByLabel(mod, photonHandle);
589 
590 
591 
592 
593  //Reset counters
594  fCountEventAll=0;
596 
597  if(fVerbosity > 0) std::cout<<"Found OpDet hit collection of size "<< (*photonHandle).size()<<std::endl;
598 
599 
600  if((*photonHandle).size()>0)
601  {
602 
603  for ( auto const& photon : (*photonHandle) )
604  {
605  //Get data from HitCollection entry
606  fOpChannel=photon.OpChannel;
607  std::map<int, int> PhotonsMap = photon.DetectedPhotons;
608 
609  //Reset Counters
610  fCountOpDetAll=0;
612 
613  if(fVerbosity > 3)
614  {
615  for(auto it = PhotonsMap.begin(); it!= PhotonsMap.end(); it++)
616  {
617  // Calculate wavelength in nm
618  fWavelength= 128;
619 
620  //Get arrival time from phot
621  fTime= it->first;
622  //std::cout<<"Arrival time: " << fTime<<std::endl;
623 
624  for(int i = 0; i < it->second ; i++)
625  {
626  // Increment per OpDet counters and fill per phot trees
627  fCountOpDetAll++;
629  if(odresponse->detectedLite(fOpChannel))
630  {
633  std::cout<<"OpDetResponseInterface PerPhoton : Event "<<fEventID<<" OpChannel " <<fOpChannel << " Wavelength " << fWavelength << " Detected 1 "<<std::endl;
634  }
635  else
636  std::cout<<"OpDetResponseInterface PerPhoton : Event "<<fEventID<<" OpChannel " <<fOpChannel << " Wavelength " << fWavelength << " Detected 0 "<<std::endl;
637  }
638  }
639  }
640  else
641  {
642  for(auto it = PhotonsMap.begin(); it!= PhotonsMap.end(); it++)
643  {
644  // Calculate wavelength in nm
645  fWavelength= 128;
646  fTime= it->first;
647 
648  for(int i = 0; i < it->second; i++)
649  {
650  // Increment per OpDet counters and fill per phot trees
651  fCountOpDetAll++;
653  if(odresponse->detectedLite(fOpChannel))
654  {
657  }
658  }
659  }
660  }
661 
662  // Incremenent per event and fill Per OpDet trees
663  if(fMakeOpDetsTree) fTheOpDetTree->Fill();
666 
667  // Give per OpDet output
668  if(fVerbosity >2) std::cout<<"OpDetResponseInterface PerOpDet : Event "<<fEventID<<" OpDet " << fOpChannel << " All " << fCountOpDetAll << " Det " <<fCountOpDetDetected<<std::endl;
669  }
670  // Fill per event tree
672 
673  // Give per event output
674  if(fVerbosity >1) std::cout<<"OpDetResponseInterface PerEvent : Event "<<fEventID<<" All " << fCountOpDetAll << " Det " <<fCountOpDetDetected<<std::endl;
675 
676  }
677  else
678  {
679  // if empty OpDet hit collection,
680  // add an empty record to the per event tree
682  }
683  }
684  }
685  }
686 }
687 namespace opdet{
688 
690 
691 }//end namespace opdet
692 
Store parameters for running LArG4.
void RetrieveLightProd(int &VoxID, double &N) const
std::vector< std::vector< double > > fstepPostPositions
cheat::ParticleInventoryService * pi_serv
std::vector< double > fPosition0
std::vector< std::vector< double > > fSignalsvuv
MaybeLogger_< ELseverityLevel::ELsev_error, false > LogError
virtual bool detected(int OpChannel, const sim::OnePhoton &Phot, int &newOpChannel) const
unsigned int NOpChannels() const
Number of electronics channels for all the optical detectors.
std::vector< std::vector< double > > fstepPrePositions
iterator find(const key_type &key)
Definition: ParticleList.h:318
std::vector< std::string > fInputModule
std::size_t getView(std::string const &moduleLabel, std::string const &productInstanceName, std::vector< ELEMENT const * > &result) const
Definition: DataViewImpl.h:474
#define DEFINE_ART_MODULE(klass)
Definition: ModuleMacros.h:42
void analyze(art::Event const &)
static const int NoParticleId
Definition: sim.h:28
void SetLibraryReflT0Entry(int VoxID, int OpChannel, float value)
T get(std::string const &key) const
Definition: ParameterSet.h:231
void SetLibraryEntry(int VoxID, int OpChannel, float N, bool wantReflected=false)
EDAnalyzer(Table< Config > const &config)
Definition: EDAnalyzer.h:100
Class def header for mctrack data container.
virtual bool detectedLite(int OpChannel, int &newOpChannel) const
cet::coded_exception< errors::ErrorCodes, ExceptionDetail::translate > Exception
Definition: Exception.h:66
T * make(ARGS...args) const
std::vector< double > fstepPostTimes
bool getByLabel(std::string const &label, std::string const &productInstanceName, Handle< PROD > &result) const
Definition: DataViewImpl.h:344
list_type::const_iterator const_iterator
Definition: SimPhotons.h:134
std::vector< std::vector< std::vector< double > > > fSignals_vis
MaybeLogger_< ELseverityLevel::ELsev_warning, false > LogWarning
object containing MC truth information necessary for making RawDigits and doing back tracking ...
IDNumber_t< Level::Event > EventNumber_t
Definition: IDNumber.h:117
EventNumber_t event() const
Definition: EventID.h:117
std::vector< std::vector< double > > fSignalsvis
Float_t e
Definition: plot.C:34
RunNumber_t run() const
Definition: Event.h:77
virtual float wavelength(double energy) const
Namespace collecting geometry-related classes utilities.
std::vector< std::vector< std::vector< double > > > fSignals_vuv
std::vector< double > fstepPreTimes
Tools and modules for checking out the basics of the Monte Carlo.
EventID id() const
Definition: Event.h:56
static sim::SimPhotonsCollection GetSimPhotonsCollection(const art::Event &evt, std::string moduleLabel)
bool UseLitePhotons() const
Event finding and building.