NuEAnalysisSetup.cxx
Go to the documentation of this file.
1 /*
2  * \file NuEAnalysisSetup.cxx
3  * \brief analysis configuration for nu_e analysis, First Analysis version
4  *
5  * Created on: \date Feb 5, 2016
6  * Original author: \author J. Wolcott <jwolcott@fnal.gov>
7  *
8  */
9 
11 
19 
20 #include "RecoJMShower/JMShower.h"
21 #include "RecoBase/Shower.h"
22 #include "RecoBase/Cluster.h"
23 #include "RecoBase/Vertex.h"
24 #include "RecoBase/Track.h"
25 #include "RecoBase/Prong.h"
26 #include "RecoBase/WeightedProng.h"
27 #include "ShowerLID/EventLID.h"
28 #include "ShowerLID/ShowerLID.h"
29 #include "MEFinder/MEClusters.h"
30 #include "LEM/PIDDetails.h"
31 #include "CVN/func/Result.h"
32 #include "FNEX/core/VarVals.h"
33 
35 
40 
41 
42 namespace fnex
43 {
44 
45 
46  //------------------------------------------------------------------------------
48  {
49  return s1->TotalLength() > s2->TotalLength();
50  }
51 
52  //------------------------------------------------------------------------------
54  {
55  return p1->TotalLength() > p2->TotalLength();
56  }
57 
58  //----------------------------------------------------------------------------
60  {
61  this->Reconfigure(pset);
62  }
63 
64  //----------------------------------------------------------------------------
66  art::ValidHandle<std::vector<rb::Cluster> > const& slices,
67  art::InputTag const& tag,
68  std::vector<fnex::DataVarVals> & dataVarVals,
69  std::vector<fnex::MCVarVals> & mcVarVals,
70  std::vector<fnex::EventId> & evIds,
71  fnex::BeamType_t const& beamType) const
72  {
73  dataVarVals.clear();
74  mcVarVals .clear();
75  evIds .clear();
76 
77  if( !slices.isValid() ){
78  LOG_WARNING("NuEAnalysisSetup")
79  << "could not find valid handle of rb::Cluster, ignore this event";
80  }
81  else{
82 
83  auto det = fDetService->DetId();
84 
85  // get the FindOnes
86  art::FindOne <slid::EventLID > folid (slices, evt, tag);
87  art::FindMany <slid::ShowerLID > fmShwLID(slices, evt, tag);
88  art::FindOne <lem::PIDDetails > folem (slices, evt, tag);
89  art::FindOne <cvn::Result > focvn (slices, evt, tag);
90  art::FindOneP <simb::MCTruth > fomct (slices, evt, tag);
91  art::FindOne <simb::MCFlux > fomcf (slices, evt, tag);
92  art::FindMany <me::SlcME > fmSlcME (slices, evt, tag);
93  art::FindMany <me::TrkME > fmTrkME (slices, evt, tag);
94  art::FindManyP<rb::Prong > fmp (slices, evt, tag);
95  art::FindManyP<rb::Shower > fms (slices, evt, tag); //<< tmp Nue Energy fix
96  art::FindOne <fxwgt::FluxWeights> fofw (slices, evt, tag);
97  art::FindOne <simb::GTruth > fogt (slices, evt, tag);
98 
99  for(size_t sl = 0; sl < slices->size(); ++sl){
100 
101  fnex::DataVarVals dataVars;
102  fnex::MCVarVals mcVars;
103  fnex::EventId evId(evt.run(),
104  evt.subRun(),
105  evt.event(),
107  (*slices)[sl].ID());
108 
109  if(folid .isValid() &&
110  //folem .isValid() && // No LEM for TA check later
111  fmShwLID.isValid() &&
112  focvn .isValid() &&
113  fmSlcME .isValid() &&
114  fmTrkME .isValid() ){
115 
116  // sort showers by energy and then use the most energetic one
117  // to evaluate the reconstructed leptonic energy
118  auto shwlids = fmShwLID.at(sl);
119  sort(shwlids.begin(), shwlids.end(), slid::CompareByEnergy);
120  art::FindOneP<rb::Shower> fos (shwlids, evt, tag);
121  cet::maybe_ref<art::Ptr<rb::Shower> const> rshw(fos.at(0));
122  art::Ptr<rb::Shower> shw = rshw.ref();
123 
124  auto slcMEs = fmSlcME.at(sl);
125  auto trkMEs = fmTrkME.at(sl);
126 
127  double CVNem_CalE = 0.0;
128  double CVNha_CalE = 0.0;
129  double pngSum_CalE = 0.0;
130 
131  std::vector< art::Ptr<rb::Shower> > showers;
132  fms.get(sl, showers );
133 
134  std::vector< art::Ptr<rb::Prong> > prongs;
135  fmp.get(sl, prongs );
136 
137  sort(showers.begin(), showers.end(), showerByLength );
138  sort(prongs.begin(), prongs.end(), prongByLength );
139 
140  art::FindMany<rb::PID> fmcvnp (prongs, evt, tag);
141  try{
142  art::FindOne<rb::Shower> fmshower(prongs, evt, tag);
143 
144  // Check if SA
145  if(!fNuEEEstimator.compare("SA")) {
146 
147  // check lem for SA
148  if(! folem.isValid() ) {
149  LOG_WARNING("NuEAnalysisSetup")
150  << "something is wrong with "
151  << "LEM object loading from ART record "
152  << "\nLEM: " << folem.isValid()
153  << "\nskipping this slice";
154  continue;
155  }
156 
157  // Fill Reco VArs SA Style
158  this->FillRecoVars(dataVars,
159  (*slices)[sl],
160  (*shw),
161  folid.at(sl).ref(),
162  focvn.at(sl).ref(),
163  folem.at(sl).ref(),
164  slcMEs,
165  trkMEs);
166 
167  }
168  else if (!fNuEEEstimator.compare("TA")|| (!fNuEEEstimator.compare("2018"))){
169 
170  /// Calculation for TA Shower and Hadronic energy is done here for the moment since
171  /// it needs prongs and cvn associations (to be improved)
172 
173  // need to keep track of maximum shower energy for special cases
174  int pngMaxEindex = -1;
175  double pngMaxE = 0.0;
176 
177  if(showers.size() != prongs.size() ) {
178  LOG_VERBATIM("NuEAnalysisSetup")
179  << "NuEAnalysisSetup - ERROR !!!!!!!! - Number of Showers and Prongs are different "
180  << showers.size()
181  << " "
182  << prongs.size();
183  }
184  else {
185 
186  //size_t iShw = 0;
187 
188  for(size_t iPng = 0; iPng < prongs.size(); ++iPng){
189 
190  auto shwassd = fmshower.at(iPng);
191 
192  double png_CalE = shwassd.ref().CalorimetricEnergy();
193 
194  if(png_CalE>pngMaxE) {
195  pngMaxE = png_CalE;
196  pngMaxEindex = iPng;
197  }
198 
199  if(fmcvnp.isValid()){
200 
201  auto cvnparts = fmcvnp.at(iPng);
202 
203  double emPID = 0;
204  double haPID = 0;
205 
206  for (size_t i = 0; i < cvnparts.size(); ++i){
207  float pidval = cvnparts[i]->Value();
208  int id = cvnparts[i]->Pdg();
209  if( id == 22 || id == 111 || id == 11 ) // photonid OR pizeroid OR electronid
210  emPID += pidval;
211  else
212  haPID += pidval;
213  } // for cvnparts
214 
215  pngSum_CalE += png_CalE;
216  if ( emPID <= 0 ) continue;
217  if ( emPID >= haPID ) CVNem_CalE += png_CalE;
218  LOG_DEBUG("NuEAnalysisSetup")
219  << "NuEAnalysisSetup - evt/prong "
220  << evt.event()
221  << " "
222  << iPng
223  << " prongs emPID : "
224  << emPID
225  << " haPID "
226  << haPID
227  << " CVNem_CalE "
228  << CVNem_CalE
229  << " png_calE "
230  << png_CalE;
231 
232 
233  } // if fmcvnp.isValid
234 
235  } // for prongs
236 
237  } // if else TA or 2018
238 
239 
240  // ShwE for 2018 Analysis (4A) has a condition on the longest prong (FHC) or zero (RHC)
241  if(!fNuEEEstimator.compare("2018")){
242 
243  if( (beamType == fnex::kFHC && prongs[0]->TotalLength() >= 500) ||
244  (beamType == fnex::kRHC && CVNem_CalE == 0 ) ){
245 
246  auto shwassd = fmshower.at(pngMaxEindex); // associate with largest caloriemtring energy prong
247  CVNem_CalE = shwassd.ref().CalorimetricEnergy();
248 
249  /*if(beamType == fnex::kFHC)
250  LOG_DEBUG("NuEAnalysisSetup") << "NuEAnalysisSetup FHC 4A LongestProng > 500 "
251  << " run/subrun/evt " << evt.run()
252  << " " << evt.subRun() << " " << evt.id().event()
253  << " length/ShwE " << prongs[0]->TotalLength() << " " << CVNem_CalE;
254 
255  if(beamType == fnex::kRHC)
256  LOG_DEBUG("NuEAnalysisSetup") << "NuEAnalysisSetup RHC 4A ShwE == 0 "
257  << " run/subrun/evt " << evt.run()
258  << " " << evt.subRun() << " " << evt.id().event()
259  << " ShwE " << CVNem_CalE;
260  */
261  } //
262  }// if 4A
263 
264 
265  CVNha_CalE = (*slices)[sl].CalorimetricEnergy() - CVNem_CalE;
266  double visHadE = std::max( CVNha_CalE, 0.0);
267  double visShwE = CVNem_CalE;
268  double ShwE = 0.0;
269  double HadE = 0.0;
270 
271  /// WARNING!!!! This block deals with a calibration bug (see docdb 23597)
272  /// a correction factor of 0.9949/0.9844 is applied to low gain FD MC
273  // a correction factor of 0.9949 is applied to FD Data
274  if(det == novadaq::cnv::kNEARDET){ /// ND
275  ShwE = visShwE;
276  HadE = visHadE;
277  } else { /// FD
278  if(!evt.isRealData() ){ // MC
279 
280  if( evt.run() < 20753){ //low gain
281  ShwE = (0.9949*visShwE)/0.9844;
282  HadE = (0.9949*visHadE)/0.9844;
283  }
284  else{ //high gain
285  ShwE = visShwE;
286  HadE = visHadE;
287  }
288  } else { //DATA
289  ShwE = 0.9949*visShwE;
290  HadE = 0.9949*visHadE;
291  }
292  }
293  LOG_DEBUG("NuEAnalysisSetup")
294  << "NuEAnalysisSetup - evt " << evt.event()
295  << " Slice Calorimetric Energy = " << (*slices)[sl].CalorimetricEnergy()
296  << " ShwE " << ShwE
297  << " visShwE = " << visShwE
298  << " HadE " << HadE
299  << " visHadE = " << visHadE
300  << " CalE " << (*slices)[sl].CalorimetricEnergy()
301  << " pngSumCalE " << pngSum_CalE;
302 
303  //----------------- End of Calibratiob Bug related block ----
304  //Fill Histograms
305 
306  // FillRecoVars 2017 and 2018 style
307  this->FillRecoVars2018(dataVars,
308  (*slices)[sl],
309  ShwE,
310  HadE,
311  folid.at(sl).ref(),
312  focvn.at(sl).ref(),
313  slcMEs,
314  trkMEs);
315  }
316  } // end try
317  catch(...){
318  LOG_WARNING("NuEAnalysisSetup")
319  << "problem forming the FindOne for Shower->Prong, move on to next slice."
320  << "there are "
321  << prongs.size()
322  << " prongs and "
323  << showers.size()
324  << " showers"
325  << evId;
326 
327  continue;
328  }
329  }// end filling recovariables
330  else{
331  LOG_WARNING("NuEAnalysisSetup")
332  << "something is wrong with at least one of the "
333  << "PID object(s) loading from ART record "
334  << "\nLID: " << folid.isValid()
335  ///// << "\nLEM: " << folem.isValid()
336  << "\nShwLID: " << fmShwLID.isValid()
337  << "\nCVN: " << focvn.isValid()
338  << "\nskipping this slice";
339  continue;
340  }
341 
342 
343  // check the cvn value and only bother filling the truth variables
344  // if we are in the desired range
345  auto cvnVal = dataVars.val_at(fnex::kNuE_CVN, fnex::MetaData());
346  if(cvnVal < fPIDMin || cvnVal > fPIDMax ) continue;
347 
348  // now for the MC variables, if this is a MC event
349  if( !this->FillTruthVars(mcVars, evt, sl, fomct, fomcf, fofw, fogt) ) continue;
350 
351  // we got here, so the event is one we want for this PID
352  dataVarVals.push_back(dataVars);
353  mcVarVals .push_back(mcVars);
354  evIds .push_back(evId);
355 
356  } // end loop over slices
357 
358  } // end if the handle was valid
359 
360  return;
361  } // NuEAnalysisSetup::FillVars
362 
363  //----------------------------------------------------------------------------
365  {
366  // call base class to get Cuts & shifters registered
367  this->AnalysisSetupBase::Reconfigure(pset);
368  fNuEEEstimator = pset.get<std::string>("NuEEEstimator", "SA");
369 
370  // get the selection type and determine the PID range
371  auto const& type = pset.get<std::string>("AnalysisType");
372 
375 
376  if(type.compare("NuE_LowPID") == 0){
377  fPIDMin = pset.get<double>("PIDMin");
378  fPIDMax = pset.get<double>("PIDMax");
379  }
380  else if(type.compare("NuE_MidPID") == 0){
381  fPIDMin = pset.get<double>("PIDMin");
382  fPIDMax = pset.get<double>("PIDMax");
383  }
384  else if(type.compare("NuE_HighPID") == 0){
385  fPIDMin = pset.get<double>("PIDMin");
386  fPIDMax = pset.get<double>("PIDMax");
387  }
388  else if(type.compare("NuE_Peripheral") == 0){
389  fPIDMin = pset.get<double>("PIDMin");
390  fPIDMax = pset.get<double>("PIDMax");
391  }
392 
393  return;
394  }
395 
396  //----------------------------------------------------------------------------
398  rb::Cluster const& slice,
399  rb::Shower const& shower,
400  slid::EventLID const& elid,
401  cvn::Result const& cvn,
402  lem::PIDDetails const& lem,
403  std::vector<me::SlcME const*> const& slcmes,
404  std::vector<me::TrkME const*> const& trkmes) const
405  {
406  double Elep = shower.TotalGeV();
407  double Ehad = slice.TotalGeV() - Elep;
408  //double lidval = elid.Value();
409  //double lemval = lem.Value();
410  double cvnval = (cvn.fOutput[4] +
411  cvn.fOutput[5] +
412  cvn.fOutput[6] +
413  cvn.fOutput[7] );
414 
415  double numME = 0.;
416 
417  for(auto slme : slcmes){
418  if(slme->MID() > 2. && slme->DeltaT() > 800.) numME += 1.;
419  }
420  for(auto trme : trkmes){
421  if(trme->MID() > 2. && trme->DeltaT() > 800.) numME += 1.;
422  }
423 
424  // apparently any number of Michel electrons >= 2 is treated the same
425  if(numME > 2.) numME = 2.;
426 
427  vars.set_val_at(fnex::kLep_RecoE, Elep);
428  vars.set_val_at(fnex::kHad_RecoE, Ehad);
429 // vars.set_val_at(fnex::kNuE_CalorE, Ehad + Elep);
430 // vars.set_val_at(fnex::kNuE_LID, lidval);
431 // vars.set_val_at(fnex::kNuE_LEM, lemval);
432  vars.set_val_at(fnex::kNuE_CVN, cvnval);
433  vars.set_val_at(fnex::kNuE_NumMichel, numME);
434 
435  return;
436  }
437 
438 
439 
440  //---------------------------------- No LEM for Analysi 2017 ------------------------------------------
442  rb::Cluster const& slice,
443  const double ShwE,
444  const double HadE,
445  slid::EventLID const& elid,
446  cvn::Result const& cvn,
447  std::vector<me::SlcME const*> const& slcmes,
448  std::vector<me::TrkME const*> const& trkmes) const
449  {
450 
451 
452 
453  ///// double lidval = elid.Value();
454  ///// double lemval = lem.Value();
455  double cvnval = (cvn.fOutput[4] +
456  cvn.fOutput[5] +
457  cvn.fOutput[6] +
458  cvn.fOutput[7] );
459 
460  double numME = 0.;
461 
462  for(auto slme : slcmes){
463  if(slme->MID() > 2. && slme->DeltaT() > 800.) numME += 1.;
464  }
465  for(auto trme : trkmes){
466  if(trme->MID() > 2. && trme->DeltaT() > 800.) numME += 1.;
467  }
468 
469  // apparently any number of Michel electrons >= 2 is treated the same
470  if(numME > 2.) numME = 2.;
471 
472  vars.set_val_at(fnex::kLep_RecoE, ShwE);
473  vars.set_val_at(fnex::kHad_RecoE, HadE);
474 // vars.set_val_at(fnex::kNuE_CalorE, Ehad + Elep);
475 // vars.set_val_at(fnex::kNuE_LID, lidval);
476 // vars.set_val_at(fnex::kNuE_LEM, lemval);
477  vars.set_val_at(fnex::kNuE_CVN, cvnval);
478  vars.set_val_at(fnex::kNuE_NumMichel, numME);
479 
480  return;
481  }
482 
483 
484 
485 
486 
487  //---------------------------------- New CVN Analysi 2018 ------------------------------------------
489  rb::Cluster const& slice,
490  const double ShwE,
491  const double HadE,
492  slid::EventLID const& elid,
493  cvn::Result const& cvn,
494  std::vector<me::SlcME const*> const& slcmes,
495  std::vector<me::TrkME const*> const& trkmes) const
496  {
497 
498 
499  //////////////////////// CVN ///////////////////////////
500  // Differnet versions have different number of outputs
501  //
502  // Explanation for Production4 is in :
503  // https://cdcvs.fnal.gov/redmine/projects/nova_reconstruction/wiki/Prod4_tag
504 
505  double cvnval = -1;
506 
507  // check Output Vector Size
508  int cvnOutputSize = cvn.fOutput.size();
509 
510  if( cvnOutputSize == 16 ) { /// 2017 and before
511 
512  // CVN Value formula from CAFMaker: FillPIDs.cxx -->
513  cvnval = cvn.fOutput[4]+cvn.fOutput[5]+cvn.fOutput[6]+cvn.fOutput[7];
514 
515  } else if( cvnOutputSize == 392 ) { /// 2018 ...
516  // See StandardRecord/CVNLabels.h for constants
517 
518  float nueid = 0;
519 
520  //std::vector<float>::const_iterator maxIt = std::max_element(cvn.fOutput.cbegin(), cvn.fOutput.cend());
521 
522  for(int idx = 0; idx < caf::kNumCVNFinalStates; ++idx){
524  const double prob = cvn.fOutput[idx];
525  if(state.nuPdg == 12) nueid += prob;
526  }
527 
528  nueid += cvn.fOutput[caf::kCVN_nE_Other];
529 
530  cvnval = nueid;
531  }
532 
533  /////////////////////////////////////////////////////
534 
535  double numME = 0.;
536 
537  for(auto slme : slcmes){
538  if(slme->MID() > 2. && slme->DeltaT() > 800.) numME += 1.;
539  }
540  for(auto trme : trkmes){
541  if(trme->MID() > 2. && trme->DeltaT() > 800.) numME += 1.;
542  }
543 
544  // apparently any number of Michel electrons >= 2 is treated the same
545  if(numME > 2.) numME = 2.;
546 
547  vars.set_val_at(fnex::kLep_RecoE, ShwE);
548  vars.set_val_at(fnex::kHad_RecoE, HadE);
549  vars.set_val_at(fnex::kNuE_CVN, cvnval);
550  vars.set_val_at(fnex::kNuE_NumMichel, numME);
551 
552  return;
553  }
554 
555 } // namespace fnex
556 
T max(const caf::Proxy< T > &a, T b)
#define LOG_DEBUG(stream)
Definition: Messenger.h:149
novadaq::cnv::DetId DetId() const
What detector are we in?
SubRunNumber_t subRun() const
Definition: Event.h:72
static const unsigned char kNuE_CVN
Definition: VarVals.h:32
Base container for the MC related Vars that constitute an event.
Definition: VarVals.h:930
void FillVars(art::Event const &evt, art::ValidHandle< std::vector< rb::Cluster > > const &slices, art::InputTag const &tag, std::vector< fnex::DataVarVals > &dataVarVals, std::vector< fnex::MCVarVals > &mcVarVals, std::vector< fnex::EventId > &evIds, fnex::BeamType_t const &beamType) const override
A collection of associated CellHits.
Definition: Cluster.h:47
Create a list of fnex::Events to be used in fits.
bool isRealData() const
Definition: Event.h:83
Defines an enumeration for prong classification.
const int kCVN_nE_Other
Definition: CVNLabels.h:402
std::vector< float > fOutput
Vector of outputs from neural net.
Definition: Result.h:30
bool CompareByEnergy(const slid::ShowerLID *a, const slid::ShowerLID *b)
Definition: ShowerLID.cxx:51
object containing MC flux information
virtual double TotalLength() const
Length (cm) of a shower.
Definition: Shower.cxx:43
PID
Definition: FillPIDs.h:14
virtual double TotalLength() const
Distance along prong to reach last cell hit.
Definition: Prong.cxx:186
void Reconfigure(fhicl::ParameterSet const &pset) override
Result for CVN.
virtual void Reconfigure(fhicl::ParameterSet const &pset)
static Var nueid(const std::shared_ptr< CAFAnaModel > &model)
Definition: SliceLIDVar.h:83
T get(std::string const &key) const
Definition: ParameterSet.h:231
art::ServiceHandle< ds::DetectorService > fDetService
which detector?
int evt
void FillRecoVars2018(fnex::DataVarVals &vars, rb::Cluster const &, const double ShwE, const double HadE, slid::EventLID const &, cvn::Result const &, std::vector< me::SlcME const * > const &slcmes, std::vector< me::TrkME const * > const &trkmes) const
static const unsigned char kNuE_NumMichel
Definition: VarVals.h:33
Near Detector in the NuMI cavern.
float val_at(unsigned char const &varkey, fnex::MetaData const &md) const
Definition: VarVals.cxx:499
const std::map< std::pair< std::string, std::string >, Variable > vars
EventNumber_t event() const
Definition: Event.h:67
NuEAnalysisSetup(fhicl::ParameterSet const &pset)
Vertex location in position and time.
#define LOG_WARNING(category)
static float min(const float a, const float b, const float c)
Definition: absgeo.cxx:45
bool prongByLength(art::Ptr< rb::Prong > p1, art::Ptr< rb::Prong > p2)
::xsd::cxx::tree::string< char, simple_type > string
Definition: Database.h:154
Result, basic output of CVN neural net.
Definition: Result.h:15
const int kNumCVNFinalStates
Definition: CVNLabels.h:11
double fPIDMax
maximum allowed PID value for this analysis
A rb::Prong with a length.
Definition: Shower.h:18
void FillRecoVars(fnex::DataVarVals &vars, rb::Cluster const &, rb::Shower const &, slid::EventLID const &, cvn::Result const &, lem::PIDDetails const &, std::vector< me::SlcME const * > const &slcmes, std::vector< me::TrkME const * > const &trkmes) const
double TotalGeV(EEnergyCalcScheme escheme=kRecomputeEnergy) const
Simple sum of the estimated GeV of all the hits.
Definition: Cluster.cxx:378
enum fnex::beam_type BeamType_t
void set_val_at(std::string const &varkey, float const &val)
Definition: VarVals.cxx:525
Attach LEM-specific info to the base PID object.
Definition: PIDDetails.h:20
static const unsigned char kHad_RecoE
Definition: VarVals.h:34
const CVNFinalState cvnStates[kNumCVNFinalStates]
Definition: CVNLabels.h:12
size_type get(size_type i, reference item, data_reference data) const
Definition: FindManyP.h:469
bool FillTruthVars(fnex::MCVarVals &vars, art::Event const &evt, size_t const &sliceNum, art::FindOneP< simb::MCTruth > const &fomct, art::FindOne< simb::MCFlux > const &fomcf, art::FindOne< fxwgt::FluxWeights > const &fofw, art::FindOne< simb::GTruth > const &fogt) const
#define LOG_VERBATIM(category)
RunNumber_t run() const
Definition: Event.h:77
T max(sqlite3 *const db, std::string const &table_name, std::string const &column_name)
Definition: statistics.h:68
void FillRecoVars2017(fnex::DataVarVals &vars, rb::Cluster const &, const double ShwE, const double HadE, slid::EventLID const &, cvn::Result const &, std::vector< me::SlcME const * > const &slcmes, std::vector< me::TrkME const * > const &trkmes) const
static const unsigned char kLep_RecoE
Definition: VarVals.h:35
bool showerByLength(art::Ptr< rb::Shower > s1, art::Ptr< rb::Shower > s2)
Definition: fwd.h:28
double fPIDMin
minimum allowed PID value for this analysis
Base container for the MC related Vars that constitute an event.
Definition: VarVals.h:874