Public Member Functions | Protected Member Functions | Protected Attributes | Private Member Functions | Private Attributes | List of all members
fnex::NuEAnalysisSetup Class Reference

#include "/cvmfs/nova-development.opensciencegrid.org/novasoft/releases/N20-11-30/FNEX/custom/NuEAnalysisSetup.h"

Inheritance diagram for fnex::NuEAnalysisSetup:
fnex::AnalysisSetupBase

Public Member Functions

 NuEAnalysisSetup (fhicl::ParameterSet const &pset)
 
virtual ~NuEAnalysisSetup ()
 
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
 

Protected Member Functions

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
 
void FillGENIEWeightVars (fnex::MCVarVals &vars, rwgt::GENIEReweightTable const &) const
 
double FindXSecWeight (simb::MCTruth const &nu, simb::GTruth const &gt, rwgt::WeightType const &tag) const
 
double FindXSecWeightSA (simb::MCTruth const &nu) const
 
void FindRPAWeights (fnex::MCVarVals &vars, simb::MCTruth const &mct, simb::GTruth const &gt, rwgt::WeightType const &tag) const
 
void FindMECWeight (fnex::MCVarVals &vars, simb::MCTruth const &mct, simb::GTruth const &gt, rwgt::WeightType const &tag) const
 
void FindDISWeight (fnex::MCVarVals &vars, simb::MCTruth const &mct, simb::GTruth const &gt, rwgt::WeightType const &tag) const
 

Protected Attributes

art::ServiceHandle< rwgt::MCReweightfRwgt
 MCReweight service. More...
 
rwgt::WeightType fXSecWgtScheme
 which "Tufts" weighting to use More...
 

Private Member Functions

void Reconfigure (fhicl::ParameterSet const &pset) override
 
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
 
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
 
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
 

Private Attributes

std::string fNuEEEstimator
 
double fPIDMin
 minimum allowed PID value for this analysis More...
 
double fPIDMax
 maximum allowed PID value for this analysis More...
 
art::ServiceHandle< nova::dbi::RunHistoryServicefRH
 RunHistory service. More...
 
art::ServiceHandle< ds::DetectorServicefDetService
 which detector? More...
 
art::ServiceHandle< art::TFileServicefTFS
 

Detailed Description

Definition at line 54 of file NuEAnalysisSetup.h.

Constructor & Destructor Documentation

fnex::NuEAnalysisSetup::NuEAnalysisSetup ( fhicl::ParameterSet const &  pset)
explicit

Definition at line 59 of file NuEAnalysisSetup.cxx.

References Reconfigure().

60  {
61  this->Reconfigure(pset);
62  }
void Reconfigure(fhicl::ParameterSet const &pset) override
virtual fnex::NuEAnalysisSetup::~NuEAnalysisSetup ( )
inlinevirtual

Definition at line 59 of file NuEAnalysisSetup.h.

References evt, and getGoodRuns4SAM::tag.

59 {};

Member Function Documentation

void fnex::AnalysisSetupBase::FillGENIEWeightVars ( fnex::MCVarVals vars,
rwgt::GENIEReweightTable const &  rwgtTable 
) const
protectedinherited

Definition at line 47 of file AnalysisSetupBase.cxx.

References fnex::AnalysisSetupBase::fXSecWgtScheme, fnex::MCVarVals::GENIEWgts(), fnex::isSumSmallXSecJoint2017Name(), fnex::isUnusedGENIEName(), rwgt::kXSecCVWgt_2017, LOG_DEBUG, LOG_WARNING, rwgt::GENIEReweightTable::Minus1Sigma(), rwgt::GENIEReweightTable::Minus2Sigma(), rwgt::GENIEReweightTable::NShifts(), rwgt::GENIEReweightTable::Plus1Sigma(), rwgt::GENIEReweightTable::Plus2Sigma(), fnex::MCVarVals::set_GENIEWgt(), and string.

Referenced by fnex::AnalysisSetupBase::FillTruthVars().

49  {
50  static std::map<rwgt::EReweightLabel, std::string> labelMap
51  {
52  // NC elastic parameters
53  {rwgt::fReweightMaNCEL, "MaNCEL"},
54  {rwgt::fReweightEtaNCEL, "EtaNCEL"},
55 
56  // CCQE parameters
57  {rwgt::fReweightNormCCQE, "NormCCQE"},
58  {rwgt::fReweightNormCCQEenu, "NormCCQE_EnuDep"},
59  {rwgt::fReweightMaCCQEshape, "MaCCQE_shape"},
60  {rwgt::fReweightMaCCQE, "MaCCQE"},
61  {rwgt::fReweightVecCCQEshape, "VecCCQE_shape"},
62 
63  // Resonant production: CC
64  {rwgt::fReweightNormCCRES, "NormCCRES"},
65  {rwgt::fReweightMaCCRESshape, "MaCCRES_shape"},
66  {rwgt::fReweightMvCCRESshape, "MvCCRES_shape"},
67  {rwgt::fReweightMaCCRES, "MaCCRES"},
68  {rwgt::fReweightMvCCRES, "MvCCRES"},
69 
70  // Resonant production: NC
71  {rwgt::fReweightNormNCRES, "NormNCRES"},
72  {rwgt::fReweightMaNCRESshape, "MaNCRES_shape"},
73  {rwgt::fReweightMvNCRESshape, "MvNCRES_shape"},
74  {rwgt::fReweightMaNCRES, "MaNCRES"},
75  {rwgt::fReweightMvNCRES, "MvNCRES"},
76 
77  // Coherent pion production
78  {rwgt::fReweightMaCOHpi, "MaCOHpi"},
79  {rwgt::fReweightR0COHpi, "R0COHpi"},
80 
81  // Non-resonant background
82  {rwgt::fReweightRvpCC1pi, "RvpCC1pi"},
83  {rwgt::fReweightRvpCC2pi, "RvpCC2pi"},
84  {rwgt::fReweightRvpNC1pi, "RvpNC1pi"},
85  {rwgt::fReweightRvpNC2pi, "RvpNC2pi"},
86  {rwgt::fReweightRvnCC1pi, "RvnCC1pi"},
87  {rwgt::fReweightRvnCC2pi, "RvnCC2pi"},
88  {rwgt::fReweightRvnNC1pi, "RvnNC1pi"},
89  {rwgt::fReweightRvnNC2pi, "RvnNC2pi"},
90  {rwgt::fReweightRvbarpCC1pi, "RvbarpCC1pi"},
91  {rwgt::fReweightRvbarpCC2pi, "RvbarpCC2pi"},
92  {rwgt::fReweightRvbarpNC1pi, "RvbarpNC1pi"},
93  {rwgt::fReweightRvbarpNC2pi, "RvbarpNC2pi"},
94  {rwgt::fReweightRvbarnCC1pi, "RvbarnCC1pi"},
95  {rwgt::fReweightRvbarnCC2pi, "RvbarnCC2pi"},
96  {rwgt::fReweightRvbarnNC1pi, "RvbarnNC1pi"},
97  {rwgt::fReweightRvbarnNC2pi, "RvbarnNC2pi"},
98 
99  // DIS tweaking parameters
100  {rwgt::fReweightAhtBY, "AhtBY"},
101  {rwgt::fReweightBhtBY, "BhtBY"},
102  {rwgt::fReweightCV1uBY, "CV1uBY"},
103  {rwgt::fReweightCV2uBY, "CV2uBY"},
104  {rwgt::fReweightAhtBYshape, "AhtBYshape"},
105  {rwgt::fReweightBhtBYshape, "BhtBYshape"},
106  {rwgt::fReweightCV1uBYshape, "CV1uBYshape"},
107  {rwgt::fReweightCV2uBYshape, "CV2uBYshape"},
108  {rwgt::fReweightNormDISCC, "NormDISCC"},
109  {rwgt::fReweightRnubarnuCC, "RnubarnuCC"},
110  {rwgt::fReweightDISNuclMod, "DISNuclMod"},
111 
112  {rwgt::fReweightNC, "NC"},
113 
114  // Hadronization (free nucleon target)
115  {rwgt::fReweightAGKY_xF1pi, "AGKY_xF1pi"},
116  {rwgt::fReweightAGKY_pT1pi, "AGKY_pT1pi"},
117 
118  // Medium-effects to hadronization
119  {rwgt::fReweightFormZone, "FormZone"},
120 
121  // Intranuclear rescattering parameters.
122  {rwgt::fReweightMFP_pi, "MFP_pi"},
123  {rwgt::fReweightMFP_N, "MFP_N"},
124  {rwgt::fReweightFrCEx_pi, "FrCEx_pi"},
125  {rwgt::fReweightFrInel_pi, "FrInel_pi"},
126  {rwgt::fReweightFrAbs_pi, "FrAbs_pi"},
127  {rwgt::fReweightFrPiProd_pi, "FrPiProd_pi"},
128  {rwgt::fReweightFrCEx_N, "FrCEx_N"},
129  // the next two appear no longer to be in use with GENIE v3
130  //{rwgt::fReweightFrElas_pi, "FrElas_pi"},
131  //{rwgt::fReweightFrElas_N, "FrElas_N"},
132  {rwgt::fReweightFrInel_N, "FrInel_N"},
133  {rwgt::fReweightFrAbs_N, "FrAbs_N"},
134  {rwgt::fReweightFrPiProd_N, "FrPiProd_N"},
135 
136  // Nuclear model
137  {rwgt::fReweightCCQEPauliSupViaKF, "CCQEPauliSupViaKF"},
138  {rwgt::fReweightCCQEMomDistroFGtoSF, "CCQEMomDistroFGtoSF"},
139 
140  // Resonance decays
141  {rwgt::fReweightBR1gamma, "BR1gamma"},
142  {rwgt::fReweightBR1eta, "BR1eta"},
143  {rwgt::fReweightTheta_Delta2Npi, "Theta_Delta2Npi"}
144  };
145 
146  std::string rwgtLabel;
147  for (const auto rwgtPair : labelMap){
148  unsigned int rwgtInt = rwgtPair.first; // note: casting from enum to int since the rwgtTable wants ints
149  rwgtLabel = rwgtPair.second;
150  //To do: switch this to log_debug when you're confident this all works
151  LOG_DEBUG("AnalysisSetupBase")
152  << "Looking at GENIE var " << rwgtLabel
153  << " (" << rwgtTable.Minus2Sigma(rwgtInt) << ", "
154  << rwgtTable.Minus1Sigma(rwgtInt) << ", "
155  << rwgtTable.Plus1Sigma(rwgtInt) << ", "
156  << rwgtTable.Plus2Sigma(rwgtInt) << ")";
157  if (static_cast<unsigned int>(rwgtInt) > rwgtTable.NShifts())
158  continue;
159 
161  rwgtLabel = "SumSmallXSecJoint2017";
162 
163  // don't bother with GENIE weights we don't currently use
164  if( fnex::isUnusedGENIEName(rwgtLabel) ){
165  LOG_DEBUG("AnalysisSetupBase") << "\tactually don't store it, it's not used ";
166  continue;
167  }
168 
169  LOG_DEBUG("AnalysisSetupBase") << "\tstore as " << rwgtLabel;
170 
171  // check that the weight for this variable and event isn't completely crazy.
172  // It is, don't add the weight to the vars
173  if(rwgtTable.Minus2Sigma(rwgtInt) > 100. ||
174  rwgtTable.Minus1Sigma(rwgtInt) > 100. ||
175  rwgtTable.Plus1Sigma (rwgtInt) > 100. ||
176  rwgtTable.Plus2Sigma (rwgtInt) > 100. ){
177 
178  LOG_WARNING("AnalysisSetupBase")
179  << "Weight for "
180  << rwgtLabel
181  << " is crazy for at least one shift, skip this knob for this event";
182 
183  continue;
184  }
185 
186  // the set_GENIEWgt function multiplies the existing values already in
187  // the GENIEVar by the table vals for each sigma so when we are setting
188  // the SumSmallXSecJoint2017 variable it becomes an product of weights from all the
189  // individual contributions. Also, only the SumSmallXSecJoint2017 key will be stored
190  // in the eventual EventList tree file.
191 
192  vars.set_GENIEWgt(rwgtLabel, "-2sigma", rwgtTable.Minus2Sigma(rwgtInt));
193  vars.set_GENIEWgt(rwgtLabel, "-1sigma", rwgtTable.Minus1Sigma(rwgtInt));
194  vars.set_GENIEWgt(rwgtLabel, "+1sigma", rwgtTable.Plus1Sigma (rwgtInt));
195  vars.set_GENIEWgt(rwgtLabel, "+2sigma", rwgtTable.Plus2Sigma (rwgtInt));
196 
197  LOG_DEBUG("AnalysisSetupBase")
198  << "GENIE var " << rwgtLabel
199  << " stored as ("
200  << vars.GENIEWgts(rwgtLabel).at(-2.) << ", "
201  << vars.GENIEWgts(rwgtLabel).at(-1.) << ", "
202  << vars.GENIEWgts(rwgtLabel).at( 1.) << ", "
203  << vars.GENIEWgts(rwgtLabel).at( 2.) << ")";
204 
205  }
206 
207  return;
208  }
#define LOG_DEBUG(stream)
Definition: Messenger.h:149
bool isUnusedGENIEName(std::string const &varname)
Definition: VarVals.h:238
std::map< float, float > GENIEWgts(unsigned char const &varkey)
Definition: VarVals.cxx:116
rwgt::WeightType fXSecWgtScheme
which "Tufts" weighting to use
#define LOG_WARNING(category)
void set_GENIEWgt(unsigned char const &varkey, std::string const &sigma, float const &wgt)
Definition: VarVals.cxx:282
bool isSumSmallXSecJoint2017Name(std::string const &varname)
Definition: VarVals.h:193
enum BeamMode string
void fnex::NuEAnalysisSetup::FillRecoVars ( fnex::DataVarVals vars,
rb::Cluster const &  slice,
rb::Shower const &  shower,
slid::EventLID const &  elid,
cvn::Result const &  cvn,
lem::PIDDetails const &  lem,
std::vector< me::SlcME const * > const &  slcmes,
std::vector< me::TrkME const * > const &  trkmes 
) const
private

Definition at line 397 of file NuEAnalysisSetup.cxx.

References cvn::Result::fOutput, fnex::kHad_RecoE, fnex::kLep_RecoE, fnex::kNuE_CVN, fnex::kNuE_NumMichel, fnex::DataVarVals::set_val_at(), and rb::Cluster::TotalGeV().

Referenced by FillVars().

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  }
static const unsigned char kNuE_CVN
Definition: VarVals.h:32
Defines an enumeration for prong classification.
static const unsigned char kNuE_NumMichel
Definition: VarVals.h:33
void set_val_at(std::string const &varkey, float const &val)
Definition: VarVals.cxx:525
static const unsigned char kHad_RecoE
Definition: VarVals.h:34
static const unsigned char kLep_RecoE
Definition: VarVals.h:35
void fnex::NuEAnalysisSetup::FillRecoVars2017 ( fnex::DataVarVals vars,
rb::Cluster const &  slice,
const double  ShwE,
const double  HadE,
slid::EventLID const &  elid,
cvn::Result const &  cvn,
std::vector< me::SlcME const * > const &  slcmes,
std::vector< me::TrkME const * > const &  trkmes 
) const
private

Definition at line 441 of file NuEAnalysisSetup.cxx.

References cvn::Result::fOutput, fnex::kHad_RecoE, fnex::kLep_RecoE, fnex::kNuE_CVN, fnex::kNuE_NumMichel, and fnex::DataVarVals::set_val_at().

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  }
static const unsigned char kNuE_CVN
Definition: VarVals.h:32
Defines an enumeration for prong classification.
static const unsigned char kNuE_NumMichel
Definition: VarVals.h:33
void set_val_at(std::string const &varkey, float const &val)
Definition: VarVals.cxx:525
static const unsigned char kHad_RecoE
Definition: VarVals.h:34
static const unsigned char kLep_RecoE
Definition: VarVals.h:35
void fnex::NuEAnalysisSetup::FillRecoVars2018 ( fnex::DataVarVals vars,
rb::Cluster const &  slice,
const double  ShwE,
const double  HadE,
slid::EventLID const &  elid,
cvn::Result const &  cvn,
std::vector< me::SlcME const * > const &  slcmes,
std::vector< me::TrkME const * > const &  trkmes 
) const
private

2017 and before

2018 ...

Definition at line 488 of file NuEAnalysisSetup.cxx.

References caf::cvnStates, cvn::Result::fOutput, compare_h5_caf::idx, caf::kCVN_nE_Other, fnex::kHad_RecoE, fnex::kLep_RecoE, fnex::kNuE_CVN, fnex::kNuE_NumMichel, caf::kNumCVNFinalStates, SliceLID::nueid(), caf::CVNFinalState::nuPdg, fnex::DataVarVals::set_val_at(), and makeDatasetsPage::state.

Referenced by FillVars().

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  }
static const unsigned char kNuE_CVN
Definition: VarVals.h:32
Defines an enumeration for prong classification.
const int kCVN_nE_Other
Definition: CVNLabels.h:402
static Var nueid(const std::shared_ptr< CAFAnaModel > &model)
Definition: SliceLIDVar.h:83
static const unsigned char kNuE_NumMichel
Definition: VarVals.h:33
const int kNumCVNFinalStates
Definition: CVNLabels.h:11
void set_val_at(std::string const &varkey, float const &val)
Definition: VarVals.cxx:525
static const unsigned char kHad_RecoE
Definition: VarVals.h:34
const CVNFinalState cvnStates[kNumCVNFinalStates]
Definition: CVNLabels.h:12
static const unsigned char kLep_RecoE
Definition: VarVals.h:35
bool fnex::AnalysisSetupBase::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
protectedinherited

Definition at line 211 of file AnalysisSetupBase.cxx.

References evt, fnex::AnalysisSetupBase::FillGENIEWeightVars(), fnex::AnalysisSetupBase::FindDISWeight(), fnex::AnalysisSetupBase::FindMECWeight(), fnex::AnalysisSetupBase::FindRPAWeights(), fnex::AnalysisSetupBase::FindXSecWeight(), simb::MCFlux::fndecay, simb::MCFlux::fntype, simb::GTruth::fNumPi0, simb::GTruth::fNumPiMinus, simb::GTruth::fNumPiPlus, simb::MCFlux::fptype, simb::MCFlux::ftptype, simb::MCFlux::ftpx, simb::MCFlux::ftpy, simb::MCFlux::ftpz, fnex::AnalysisSetupBase::fXSecWgtScheme, simb::MCTruth::GetNeutrino(), fxwgt::FluxWeights::GetTotalCentralValue(), gt(), art::Event::isRealData(), cet::maybe_ref< T >::isValid(), simb::kCC, simb::kDIS, simb::kElectronScattering, simb::kMEC, simb::kRes, fnex::kTrueCCNC, fnex::kTrueE, fnex::kTrueHitNuc, fnex::kTrueIntMode, fnex::kTrueIntType, fnex::kTrueParentDecay, fnex::kTrueParentPDG, fnex::kTrueParentPT, fnex::kTrueParentPZ, fnex::kTrueParentTargetPDG, fnex::kTruePDG, fnex::kTruePDGOrig, fnex::kXSecCVPPFX_Weight, LOG_DEBUG, LOG_WARNING, gen_flatrecord::pt, cet::maybe_ref< T >::ref(), fnex::MCVarVals::set_val_at(), std::sqrt(), and fnex::MCVarVals::val_at().

Referenced by fnex::NuMuAnalysisSetup::FillVars(), and FillVars().

218  {
219  // do nothing if this is real data, return true because we did what we
220  // needed to
221  if( evt.isRealData() ) return true;
222 
223  if(fomct.size() < sliceNum){
224  LOG_WARNING("AnalysisSetupBase")
225  << "The association between slices and MCTruth objects "
226  << "is too small for the requested slice number "
227  << fomct.size()
228  << " / "
229  << sliceNum
230  << " bail on this slice";
231  return false;
232  }
233 
234  art::Ptr<simb::MCTruth> truth = fomct.at(sliceNum);
235 
236  LOG_DEBUG("AnalysisSetupBase")
237  << "Current MCTruth is "
238  << *truth;
239 
240  // if we can't find an MCTruth object we are in trouble, so move on
241  if(!truth){
242  LOG_WARNING("AnalysisSetupBase")
243  << "No MCTruth found for slice number "
244  << sliceNum
245  << " bail on this slice";
246  return false;
247  }
248 
249  // now get the FluxWeights and GTruth
250  double fluxWeight = 1.;
251  cet::maybe_ref<fxwgt::FluxWeights const> fw = fofw.at(sliceNum);
252  if(!fw.isValid()){
253  LOG_WARNING("AnalysisSetupBase")
254  << "No FluxWeights found for slice number "
255  << sliceNum;
256  }
257  else{
258  fluxWeight = fw.ref().GetTotalCentralValue();
259  LOG_DEBUG("AnalysisSetupBase")
260  << "FluxWeight set to "
261  << fluxWeight;
262  }
263 
264  cet::maybe_ref<simb::GTruth const> gt = fogt.at(sliceNum);
265  if(!gt.isValid())
266  LOG_WARNING("AnalysisSetupBase")
267  << "No GTruth found for slice number "
268  << sliceNum;
269 
270 
271  // Fill the information related to the MCTruth object
272  auto nu = truth->GetNeutrino();
273 
274  vars.set_val_at(fnex::kTrueE, nu.Nu().E() );
275  vars.set_val_at(fnex::kTruePDG, nu.Nu().PdgCode() );
276  vars.set_val_at(fnex::kTrueCCNC, nu.CCNC() );
277  vars.set_val_at(fnex::kTrueIntType, nu.InteractionType());
278  vars.set_val_at(fnex::kTrueIntMode, nu.Mode() );
279 
280  // HitNuc is used for the MECInitStateNPFracWeight systematic
281  vars.set_val_at(fnex::kTrueHitNuc, nu.HitNuc() );
282 
283  // get the GENIEReweight informaiton
285 
286  // For a numu or nutau scattering off an electron, the exchanged particle
287  // is a Z. But for a nue, there are two diagrams, one with a Z and one
288  // with a W. Both the final states have the electron ejected, so the
289  // interaction is a quantum-mechanical superposition between the
290  // two. It's neither really CC or NC. We do need to set this boolean
291  // though. Treating nu-on-e scattering as NC (ie not oscillating it) is
292  // wrong, the cross-section for nue is different to numu and nutau so
293  // oscillations do have an effect on the final spectrum. If we mark it CC
294  // the different oscillated fluxes will be weighted together in the fit
295  // appropriately, so this is safe, even if not perfectly physically
296  // accurate.
297  //
298  // Above reason is given by CAF group in the CAFMaker_module.cc
299  // We are simply taking this argument to make things consistent between FNEX and CAFAna.
301 
302  LOG_DEBUG("AnalysisSetupBase")
303  << " Inside AnalysisSetupBase::FillTruthVars function "
304  << " Run : "
305  << evt.run()
306  << " Subrun : "
307  << evt.subRun()
308  << " Event : "
309  << evt.id().event()
310  << " Slice : "
311  << sliceNum
312  << " TrueE "
313  << nu.Nu().E()
314  << " tru->GetNeutrino().CCNC() : "
315  << nu.CCNC()
316  << " srTruth.iscc : "
317  << vars.val_at(fnex::kTrueCCNC)
318  << " tru->GetNeutrino().Mode() : "
319  << nu.Mode()
320  << " kElectronScattering : "
322  << " simb::kCC : "
323  << simb::kCC;
324 
325  // In the 2017 version, the XsecCV weight is the product of the RPA,
326  // EmpericalMEC and non-res 1Pi. We'll also put the flux weights into
327  // the kXSecCVPPFX_Weight value for the event
328 
329  if( frw.isValid() && frw.size() > 0){
330  art::Ptr<rwgt::GENIEReweightTable> rw = frw.at(0); // should only be one...
331  if(rw) this->FillGENIEWeightVars(vars, *rw);
332 
334  this->FindXSecWeight(*truth, gt.ref(), fXSecWgtScheme) * fluxWeight);
335 
336  LOG_DEBUG("AnalysisSetupBase")
337  << "Check Weights "
338  << this->FindXSecWeight(*truth, gt.ref(), fXSecWgtScheme)
339  << " "
340  << fluxWeight
341  << " "
343 
344  LOG_DEBUG("AnalysisSetupBase")
345  << "About to start loading up 2017 systematics!"
346  << "\n \t CC? " << vars.val_at(fnex::kTrueCCNC) << " == " << 1. * simb::kCC
347  << "\n \t RES? " << vars.val_at(fnex::kTrueIntType) << " == " << 1. * simb::kRes
348  << "\n \t DIS? " << vars.val_at(fnex::kTrueIntType) << " == " << 1. * simb::kDIS
349  << "\n \t MEC? " << vars.val_at(fnex::kTrueIntType) << " == " << 1. * simb::kMEC
350  << "\n \t nu/nubar? " << vars.val_at(fnex::kTruePDG) << " > 0"
351  << "\n \t npions = " << gt.ref().fNumPiPlus + gt.ref().fNumPiMinus + gt.ref().fNumPi0
352  << "\n \t hits a neutron? " << nu.HitNuc() << " == 2112";
353 
354  this->FindRPAWeights(vars, *truth, gt.ref(), fXSecWgtScheme);
355  this->FindMECWeight (vars, *truth, gt.ref(), fXSecWgtScheme);
356  this->FindDISWeight (vars, *truth, gt.ref(), fXSecWgtScheme);
357 
358  }
359  else
360  LOG_WARNING("AnalysisSetupBase")
361  << "No GENIEReweightTable found for slice number "
362  << sliceNum;
363 
364  // now get the flux information
365  if(fomcf.size() < sliceNum)
366  LOG_WARNING("AnalysisSetupBase")
367  << "The association between MCFlux and slices is "
368  << "too small for the requested slice number "
369  << fomcf.size()
370  << " / "
371  << sliceNum
372  << " skip Flux information for this slice";
373  else{
374  cet::maybe_ref<simb::MCFlux const> mcf = fomcf.at(sliceNum);
375  if( mcf.isValid() ){
376  float pt = std::sqrt(mcf.ref().ftpx * mcf.ref().ftpx +
377  mcf.ref().ftpy * mcf.ref().ftpy);
378 
379  vars.set_val_at(fnex::kTruePDGOrig, mcf.ref().fntype );
383  vars.set_val_at(fnex::kTrueParentPZ, mcf.ref().ftpz );
384  vars.set_val_at(fnex::kTrueParentPT, pt );
385  }
386  else
387  LOG_WARNING("AnalysisSetupBase")
388  << "No MCFlux found for slice number "
389  << sliceNum;
390  } // end if fomcf is too small
391 
392  return true;
393  }
#define LOG_DEBUG(stream)
Definition: Messenger.h:149
double FindXSecWeight(simb::MCTruth const &nu, simb::GTruth const &gt, rwgt::WeightType const &tag) const
const simb::MCNeutrino & GetNeutrino() const
Definition: MCTruth.h:76
double ftpx
Definition: MCFlux.h:79
static const unsigned char kTrueParentPT
Definition: VarVals.h:48
int ftptype
Definition: MCFlux.h:82
void set_val_at(std::string const &varkey, float const &val)
Definition: VarVals.cxx:164
T sqrt(T number)
Definition: d0nt_math.hpp:156
static const unsigned char kXSecCVPPFX_Weight
Definition: VarVals.h:56
void FindRPAWeights(fnex::MCVarVals &vars, simb::MCTruth const &mct, simb::GTruth const &gt, rwgt::WeightType const &tag) const
static const unsigned char kTrueHitNuc
Definition: VarVals.h:52
int fNumPiPlus
number of pi pluses after reaction, before FSI
Definition: GTruth.h:78
int fNumPiMinus
number of pi minuses after reaction, before FSI
Definition: GTruth.h:79
static const unsigned char kTrueParentPDG
Definition: VarVals.h:47
bool isValid() const
Definition: maybe_ref.h:60
static const unsigned char kTruePDGOrig
Definition: VarVals.h:46
void FindMECWeight(fnex::MCVarVals &vars, simb::MCTruth const &mct, simb::GTruth const &gt, rwgt::WeightType const &tag) const
static const unsigned char kTrueCCNC
Definition: VarVals.h:44
rwgt::WeightType fXSecWgtScheme
which "Tufts" weighting to use
int fptype
Definition: MCFlux.h:63
int fndecay
Definition: MCFlux.h:50
int fNumPi0
number of pi0 after reaction, before FSI
Definition: GTruth.h:77
int evt
float val_at(unsigned char const &varkey) const
Access a Var by name.
Definition: VarVals.cxx:77
static const unsigned char kTrueIntType
Definition: VarVals.h:45
double ftpz
Definition: MCFlux.h:81
static const unsigned char kTrueParentDecay
Definition: VarVals.h:50
#define LOG_WARNING(category)
static const unsigned char kTrueParentTargetPDG
Definition: VarVals.h:51
int fntype
Definition: MCFlux.h:51
static const unsigned char kTrueE
Definition: VarVals.h:42
void FillGENIEWeightVars(fnex::MCVarVals &vars, rwgt::GENIEReweightTable const &) const
static const unsigned char kTrueIntMode
Definition: VarVals.h:53
double ftpy
Definition: MCFlux.h:80
bool gt(unsigned short int a, unsigned short int b)
static const unsigned char kTrueParentPZ
Definition: VarVals.h:49
void FindDISWeight(fnex::MCVarVals &vars, simb::MCTruth const &mct, simb::GTruth const &gt, rwgt::WeightType const &tag) const
float GetTotalCentralValue() const
Get the total central value correction calculated as the product of the HP and Beam Focusing componen...
Definition: FluxWeights.cxx:46
static const unsigned char kTruePDG
Definition: VarVals.h:43
void fnex::NuEAnalysisSetup::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
overridevirtual

Calculation for TA Shower and Hadronic energy is done here for the moment since it needs prongs and cvn associations (to be improved)

WARNING!!!! This block deals with a calibration bug (see docdb 23597) a correction factor of 0.9949/0.9844 is applied to low gain FD MC

ND

FD

Implements fnex::AnalysisSetupBase.

Definition at line 65 of file NuEAnalysisSetup.cxx.

References slid::CompareByEnergy(), fillBadChanDBTables::det, ds::DetectorService::DetId(), art::Event::event(), fDetService, FillRecoVars(), FillRecoVars2018(), fnex::AnalysisSetupBase::FillTruthVars(), fNuEEEstimator, fPIDMax, art::FindManyP< ProdB, Data >::get(), MECModelEnuComparisons::i, art::Event::isRealData(), fnex::kFHC, novadaq::cnv::kNEARDET, fnex::kNuE_CVN, fnex::kRHC, LOG_DEBUG, LOG_VERBATIM, LOG_WARNING, std::max(), min(), fnex::prongByLength(), art::Event::run(), fnex::showerByLength(), datagram_client::sl, art::Event::subRun(), and fnex::DataVarVals::val_at().

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
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
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?
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
bool CompareByEnergy(const slid::ShowerLID *a, const slid::ShowerLID *b)
Definition: ShowerLID.cxx:51
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
Near Detector in the NuMI cavern.
float val_at(unsigned char const &varkey, fnex::MetaData const &md) const
Definition: VarVals.cxx:499
#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)
T const * get() const
Definition: Ptr.h:321
double fPIDMax
maximum allowed PID value for this analysis
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
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)
bool showerByLength(art::Ptr< rb::Shower > s1, art::Ptr< rb::Shower > s2)
Definition: fwd.h:28
Base container for the MC related Vars that constitute an event.
Definition: VarVals.h:874
bool isValid() const
Definition: Handle.h:326
void fnex::AnalysisSetupBase::FindDISWeight ( fnex::MCVarVals vars,
simb::MCTruth const &  mct,
simb::GTruth const &  gt,
rwgt::WeightType const &  tag 
) const
protectedinherited

Definition at line 604 of file AnalysisSetupBase.cxx.

References simb::GTruth::fNumPi0, simb::GTruth::fNumPiMinus, simb::GTruth::fNumPiPlus, simb::MCTruth::GetNeutrino(), simb::kCCDIS, fnex::kDISvnCC1pi_Weight, simb::kNCDIS, fnex::kOtherDIS_Weight, fnex::kTrueIntType, fnex::kTruePDG, rwgt::kXSecCVWgt_2017, rwgt::kXSecCVWgt_2018, fnex::MCVarVals::set_val_at(), and fnex::MCVarVals::val_at().

Referenced by fnex::AnalysisSetupBase::FillTruthVars().

608  {
609  auto nu = mct.GetNeutrino();
610 
611  // 2017 DISvnCC1pi
612  // 2017 DIS weights: DISvnCC1pi gets its own weight
613  // All other v/vbar n/p NC/CC 0-4pi combinations get lumped into SumSmallXSecNumu2017
614  vars.set_val_at(fnex::kDISvnCC1pi_Weight, 1.); // will be changed if event is DIS CC neutrino hitting neutron producing 1 pion
615  vars.set_val_at(fnex::kOtherDIS_Weight, 1.); // will be changed if event is DIS but doesn't fall into the above category
616 
617  if(tag == rwgt::kXSecCVWgt_2017 ||
619 
620  auto numPions = gt.fNumPiPlus + gt.fNumPiMinus + gt.fNumPi0;
621 
622  if(vars.val_at(fnex::kTrueIntType) == 1. * simb::kCCDIS && //CC and DIS
623  vars.val_at(fnex::kTruePDG) > 0 && //not anti-nu
624  numPions == 1 && //1 pion
625  nu.HitNuc() == 2112){ //hits a neutron
626  if(nu.W() < 3.) vars.set_val_at(fnex::kDISvnCC1pi_Weight, 1.5);
627  else vars.set_val_at(fnex::kDISvnCC1pi_Weight, 1.05);
628  } else if((vars.val_at(fnex::kTrueIntType) == 1. * simb::kCCDIS ||
629  vars.val_at(fnex::kTrueIntType) == 1. * simb::kNCDIS ) && //DIS
630  (nu.HitNuc() == 2112 ||
631  nu.HitNuc() == 2212 ) && //hits a neutron or a proton
632  numPions < 4){ // <4 pions
633  if(nu.W() < 3.) vars.set_val_at(fnex::kOtherDIS_Weight, 1.5);
634  else vars.set_val_at(fnex::kOtherDIS_Weight, 1.05);
635  }
636  }
637 
638  return;
639  }
charged current deep inelastic scatter
Definition: MCNeutrino.h:134
static const unsigned char kOtherDIS_Weight
Definition: VarVals.h:63
static const unsigned char kDISvnCC1pi_Weight
Definition: VarVals.h:59
void set_val_at(std::string const &varkey, float const &val)
Definition: VarVals.cxx:164
float val_at(unsigned char const &varkey) const
Access a Var by name.
Definition: VarVals.cxx:77
static const unsigned char kTrueIntType
Definition: VarVals.h:45
charged current deep inelastic scatter
Definition: MCNeutrino.h:133
bool gt(unsigned short int a, unsigned short int b)
static const unsigned char kTruePDG
Definition: VarVals.h:43
void fnex::AnalysisSetupBase::FindMECWeight ( fnex::MCVarVals vars,
simb::MCTruth const &  mct,
simb::GTruth const &  gt,
rwgt::WeightType const &  tag 
) const
protectedinherited

Definition at line 545 of file AnalysisSetupBase.cxx.

References fnex::AnalysisSetupBase::fRwgt, simb::MCTruth::GetNeutrino(), rwgt::MCReweight::GetWeight(), rwgt::kEmpiricalMEC_2017, rwgt::kEmpiricalMEC_2018, fnex::kEmpiricalMEC_Weight, fnex::kEmpiricalMECtoGENIEQE_Weight, fnex::kEmpiricalMECtoGENIERES_Weight, simb::kMEC, fnex::kTruePDG, rwgt::kXSecCVWgt_2017, rwgt::kXSecCVWgt_2018, LOG_DEBUG, rwgt::MCReweight::MECq0q3ShapeSyst2018(), fnex::MCVarVals::set_val_at(), and fnex::MCVarVals::val_at().

Referenced by fnex::AnalysisSetupBase::FillTruthVars().

549  {
550  auto nu = mct.GetNeutrino();
551 
552  // 2017 MEC Systematics
553  // Store the empirical MEC weights so we can calculate the systematics
554  // in the ShifterAndWeighter function
555  if(nu.Mode() == 1. * simb::kMEC) {
556 
557  double empiricalMECWgt = 1.;
558  double empiricalMEC_to_GENIEQE_Wgt = 1.;
559  double empiricalMEC_to_GENIERES_Wgt = 1.;
560 
561  if(tag == rwgt::kXSecCVWgt_2017){
562  // const novarwgt::EmpiricalMEC_to_GENIEQE_Wgt kEmpiricalMEC_to_GENIEQE_Wgt;
563  // const novarwgt::EmpiricalMEC_to_GENIERES_Wgt kEmpiricalMEC_to_GENIERES_Wgt;
564 
565  empiricalMECWgt = fRwgt->GetWeight(&mct, rwgt::kEmpiricalMEC_2017, &gt);
566  // empiricalMEC_to_GENIEQE_Wgt = kEmpiricalMEC_to_GENIEQE_Wgt .GetWeight(params);
567  // empiricalMEC_to_GENIERES_Wgt = kEmpiricalMEC_to_GENIERES_Wgt.GetWeight(params);
568 
569  } // end if 2017
570  else if(tag == rwgt::kXSecCVWgt_2018){
571 
572  empiricalMECWgt = fRwgt->GetWeight(&mct, rwgt::kEmpiricalMEC_2018, &gt);
573  if(vars.val_at(fnex::kTruePDG) > 0) {
574  empiricalMEC_to_GENIEQE_Wgt = fRwgt->MECq0q3ShapeSyst2018( 1, &mct, &gt);
575  empiricalMEC_to_GENIERES_Wgt = fRwgt->MECq0q3ShapeSyst2018(-1, &mct, &gt);
576  } else {
577  empiricalMEC_to_GENIEQE_Wgt = fRwgt->MECq0q3ShapeSyst2018( 1, &mct, &gt);
578  empiricalMEC_to_GENIERES_Wgt = fRwgt->MECq0q3ShapeSyst2018(-1, &mct, &gt);
579  }
580  }
581 
582  vars.set_val_at(fnex::kEmpiricalMEC_Weight, empiricalMECWgt );
583  vars.set_val_at(fnex::kEmpiricalMECtoGENIEQE_Weight, empiricalMEC_to_GENIEQE_Wgt );
584  vars.set_val_at(fnex::kEmpiricalMECtoGENIERES_Weight, empiricalMEC_to_GENIERES_Wgt);
585  //vars.set_val_at(fnex::kEmpiricalMECtoValencia_Weight, empiricalMEC_to_Valencia_Wgt);
586 
587  LOG_DEBUG("AnalysisSetupBase")
588  << "\n calculate EmpiricalMECWgt: " << empiricalMECWgt
589  << "\n calculate EmpiricalMECtoGENIEQEWgt: " << empiricalMEC_to_GENIEQE_Wgt
590  << "\n calculate EmpiricalMECtoGENIERESWgt: " << empiricalMEC_to_GENIERES_Wgt;
591  //<< "\n calculate EmpiricalMECtoValenciaWgt: " << empiricalMEC_to_Valencia_Wgt;
592  }
593  else {
597  //vars.set_val_at(fnex::kEmpiricalMECtoValencia_Weight, 1.);
598  }
599 
600  return;
601  }
#define LOG_DEBUG(stream)
Definition: Messenger.h:149
double MECq0q3ShapeSyst2018(const double sigma, const simb::MCTruth *mctruth, const simb::GTruth *gtruth) const
static const unsigned char kEmpiricalMEC_Weight
Definition: VarVals.h:60
static const unsigned char kEmpiricalMECtoGENIERES_Weight
Definition: VarVals.h:62
void set_val_at(std::string const &varkey, float const &val)
Definition: VarVals.cxx:164
double GetWeight(const simb::MCTruth *mctruth, WeightType rwType, const simb::GTruth *gtruth=nullptr) const
Retrieves a weight by name. Calculates on demand, but only calculates once per neutrino.
float val_at(unsigned char const &varkey) const
Access a Var by name.
Definition: VarVals.cxx:77
static const unsigned char kEmpiricalMECtoGENIEQE_Weight
Definition: VarVals.h:61
art::ServiceHandle< rwgt::MCReweight > fRwgt
MCReweight service.
bool gt(unsigned short int a, unsigned short int b)
static const unsigned char kTruePDG
Definition: VarVals.h:43
void fnex::AnalysisSetupBase::FindRPAWeights ( fnex::MCVarVals vars,
simb::MCTruth const &  mct,
simb::GTruth const &  gt,
rwgt::WeightType const &  tag 
) const
protectedinherited

Definition at line 463 of file AnalysisSetupBase.cxx.

References std::abs(), fnex::AnalysisSetupBase::fRwgt, fnex::MCVarVals::GENIEWgts(), simb::MCTruth::GetNeutrino(), rwgt::MCReweight::GetWeight(), simb::kCC, simb::kCCQE, simb::kResCCNuBarProtonPi0Pi0, simb::kResCCNuProtonPiPlus, rwgt::kRPACCQE_2017, rwgt::kRPACCQE_SA, fnex::kRPACCQE_Weight, fnex::kRPACCQEshapeEnh, fnex::kRPACCQEshapeSupp, rwgt::kRPACCRES_2017, fnex::kRPARES_Weight, fnex::kTrueCCNC, fnex::kTrueIntType, fnex::kTruePDG, rwgt::kTuftsCC_SA, rwgt::kXSecCVWgt_2017, rwgt::kXSecCVWgt_2018, LOG_DEBUG, min(), rwgt::MCReweight::RPACCQEEnhSyst2018(), rwgt::MCReweight::RPACCQESuppSyst2018(), fnex::MCVarVals::set_GENIEWgt(), fnex::MCVarVals::set_val_at(), and fnex::MCVarVals::val_at().

Referenced by fnex::AnalysisSetupBase::FillTruthVars().

467  {
468  auto nu = mct.GetNeutrino();
469 
470  // Only set the weight from the table if the interaction type is CC QE,
471  // otherwise set it to 1 so that the calculation of the weight will return
472  // 1, ie no change in weight.
473  // The RPACCQE weights for the 2018 analysis are the same as for the 2017
474  // analysis when called from MCReweight
475  if((std::abs(vars.val_at(fnex::kTruePDG)) == 12 ||
476  std::abs(vars.val_at(fnex::kTruePDG)) == 14 ) &&
477  vars.val_at(fnex::kTrueIntType) == 1. * simb::kCCQE){
478  if(tag == rwgt::kTuftsCC_SA)
480  else if(tag == rwgt::kXSecCVWgt_2017)
482  else if(tag == rwgt::kXSecCVWgt_2018)
484  else
486  }
487  else
489 
490  // 2017 and 2018 RPA Systematics are the same
491  if(tag == rwgt::kXSecCVWgt_2017 ||
493  if(vars.val_at(fnex::kTrueCCNC) == 1. * simb::kCC &&
496 
498 
499  LOG_DEBUG("AnalysisSetupBase")
500  << "calculate RPARES("
501  << nu.QSqr()
502  << ", "
503  << double(vars.val_at(fnex::kTruePDG) < 0)
504  << ") = "
505  << fRwgt->GetWeight(&mct, rwgt::kRPACCRES_2017, &gt);
506  } // end if true cc, with appropriate resonance production
507  if(vars.val_at(fnex::kTrueIntType) == 1. * simb::kCCQE){
508  vars.set_GENIEWgt(fnex::kRPACCQEshapeEnh, "-1sigma", fRwgt->RPACCQEEnhSyst2018 (-1, &mct, &gt));
509  vars.set_GENIEWgt(fnex::kRPACCQEshapeEnh, "+1sigma", fRwgt->RPACCQEEnhSyst2018 ( 1, &mct, &gt));
510  vars.set_GENIEWgt(fnex::kRPACCQEshapeSupp, "-1sigma", fRwgt->RPACCQESuppSyst2018(-1, &mct, &gt));
511  vars.set_GENIEWgt(fnex::kRPACCQEshapeSupp, "+1sigma", fRwgt->RPACCQESuppSyst2018( 1, &mct, &gt));
512 
517 
518  LOG_DEBUG("AnalysisSetupBase")
519  << "RPACCQE CV wgt: " << fRwgt->GetWeight(&mct, rwgt::kRPACCQE_2017, &gt)
520  << "\nget RPA Enh weights (" << vars.GENIEWgts(fnex::kRPACCQEshapeEnh).at(-2)
521  << ", " << vars.GENIEWgts(fnex::kRPACCQEshapeEnh).at(-1)
522  << ", " << vars.GENIEWgts(fnex::kRPACCQEshapeEnh).at(1)
523  << ", " << vars.GENIEWgts(fnex::kRPACCQEshapeEnh).at(2)
524  << ")"
525  << "\nget RPA Supp weights (" << vars.GENIEWgts(fnex::kRPACCQEshapeSupp).at(-2)
526  << ", " << vars.GENIEWgts(fnex::kRPACCQEshapeSupp).at(-1)
527  << ", " << vars.GENIEWgts(fnex::kRPACCQEshapeSupp).at(1)
528  << ", " << vars.GENIEWgts(fnex::kRPACCQEshapeSupp).at(2)
529  << ")";
530  } // end if CCQE
531  } // end if 2017
532  else{
534 
535  vars.set_GENIEWgt(fnex::kRPACCQEshapeEnh, "-1sigma", 1.);
536  vars.set_GENIEWgt(fnex::kRPACCQEshapeEnh, "+1sigma", 1.);
537  vars.set_GENIEWgt(fnex::kRPACCQEshapeSupp, "-1sigma", 1.);
538  vars.set_GENIEWgt(fnex::kRPACCQEshapeSupp, "+1sigma", 1.);
539  }
540 
541  return;
542  }
#define LOG_DEBUG(stream)
Definition: Messenger.h:149
double RPACCQEEnhSyst2018(const double sigma, const simb::MCTruth *mctruth, const simb::GTruth *gtruth) const
void set_val_at(std::string const &varkey, float const &val)
Definition: VarVals.cxx:164
static const unsigned char kRPACCQEshapeSupp
Definition: VarVals.h:75
std::map< float, float > GENIEWgts(unsigned char const &varkey)
Definition: VarVals.cxx:116
charged current quasi-elastic
Definition: MCNeutrino.h:96
float abs(float number)
Definition: d0nt_math.hpp:39
static const unsigned char kRPARES_Weight
Definition: VarVals.h:58
static const unsigned char kTrueCCNC
Definition: VarVals.h:44
double GetWeight(const simb::MCTruth *mctruth, WeightType rwType, const simb::GTruth *gtruth=nullptr) const
Retrieves a weight by name. Calculates on demand, but only calculates once per neutrino.
float val_at(unsigned char const &varkey) const
Access a Var by name.
Definition: VarVals.cxx:77
static const unsigned char kTrueIntType
Definition: VarVals.h:45
resonant charged current, nu p -> l- p pi+
Definition: MCNeutrino.h:98
static float min(const float a, const float b, const float c)
Definition: absgeo.cxx:45
void set_GENIEWgt(unsigned char const &varkey, std::string const &sigma, float const &wgt)
Definition: VarVals.cxx:282
static const unsigned char kRPACCQE_Weight
Definition: VarVals.h:57
art::ServiceHandle< rwgt::MCReweight > fRwgt
MCReweight service.
double RPACCQESuppSyst2018(const double sigma, const simb::MCTruth *mctruth, const simb::GTruth *gtruth) const
static const unsigned char kRPACCQEshapeEnh
Definition: VarVals.h:74
bool gt(unsigned short int a, unsigned short int b)
static const unsigned char kTruePDG
Definition: VarVals.h:43
double fnex::AnalysisSetupBase::FindXSecWeight ( simb::MCTruth const &  nu,
simb::GTruth const &  gt,
rwgt::WeightType const &  tag 
) const
protectedinherited

Definition at line 396 of file AnalysisSetupBase.cxx.

References fnex::AnalysisSetupBase::FindXSecWeightSA(), fnex::AnalysisSetupBase::fRwgt, fnex::AnalysisSetupBase::fXSecWgtScheme, rwgt::MCReweight::GetWeight(), rwgt::kTuftsCC_SA, LOG_DEBUG, and getGoodRuns4SAM::tag.

Referenced by fnex::AnalysisSetupBase::FillTruthVars().

399  {
400  LOG_DEBUG("AnalysisSetupBase")
401  << "Using weight scheme: "
402  << tag;
403 
404  if(fXSecWgtScheme == rwgt::kTuftsCC_SA ) return this->FindXSecWeightSA(mc);
405 
406  return fRwgt->GetWeight(&mc, tag, &gt);
407  }
#define LOG_DEBUG(stream)
Definition: Messenger.h:149
rwgt::WeightType fXSecWgtScheme
which "Tufts" weighting to use
double GetWeight(const simb::MCTruth *mctruth, WeightType rwType, const simb::GTruth *gtruth=nullptr) const
Retrieves a weight by name. Calculates on demand, but only calculates once per neutrino.
art::ServiceHandle< rwgt::MCReweight > fRwgt
MCReweight service.
bool gt(unsigned short int a, unsigned short int b)
double FindXSecWeightSA(simb::MCTruth const &nu) const
double fnex::AnalysisSetupBase::FindXSecWeightSA ( simb::MCTruth const &  nu) const
protectedinherited

Definition at line 410 of file AnalysisSetupBase.cxx.

References wgt.

Referenced by fnex::AnalysisSetupBase::FindXSecWeight().

411  {
412  double wgt = 1.;
413 
414  // auto nu = mc.GetNeutrino();
415 
416  // // The second analysis CAF files were made without checking the EventGeneratorList
417  // // used by GENIE. For that reason, we have to explicitly set the InputVals
418  // // and call the EmpericalMECq0q3TuneWgt function here to recover their behavior.
419  // // We will actually call the DytmanMEC* weights separately too so that we can
420  // // be sure to get the correct values. The second analysis did not
421  // // check if an event was CC or NC or if it was neutrino or antineutrino.
422  // double q0 = nu.Y() * nu.Nu().E();
423  // double qmag = sqrt(nu.QSqr() + q0 * q0);
424 
425  // rwgt::DytmanMECFixXsecEdepWgt dytmanMECXsec;
426  // rwgt::DytmanMECFixItlStateWgt dytmanMECItl;
427 
428  // novarwgt::InputVals vals({{"OldGENIEMEC", true },
429  // {"qmag", qmag },
430  // {"q0", q0 },
431  // {"IsCC", true },
432  // {"IsAntiNu", nu.Nu().PdgCode() < 0},
433  // {"StruckNucleonPairPDG", nu.HitNuc() },
434  // {"Enu", nu.Nu().E() }});
435 
436  // if(nu.Mode() == simb::kMEC){
437  // // In the second analysis, an event only had to be MEC to have the
438  // // q0q3 weight applied
439  // wgt *= 0.75 * gq0q3Wgt.GetWeight(vals);
440 
441  // // In the second analysis, no checks were made on the GENIE version
442  // // to get the XsecEdep weight, here we have set the OldGENIEMEC flag
443  // // to true, which means the weight will be applied for all events
444  // wgt *= dytmanMECXsec.GetWeight(vals);
445 
446  // // In the second analysis, events were not required to be CC for the
447  // // initial state weight to be applied, but they did have to be neutrinos
448  // // in development as of 9/1/17 they were required to be CC, so we have
449  // // set the IsCC to be true for all events to replicate that behavior
450  // wgt *= dytmanMECItl.GetWeight(vals);
451  // }
452 
453  // if(nu.Mode() == simb::kDIS &&
454  // nu.W() < 1.7){
455  // rwgt::Nonres1PiWgt nonres1pi;
456  // wgt *= nonres1pi.GetWeight({{}});
457  // }
458 
459  return wgt;
460  }
const ana::Var wgt
void fnex::NuEAnalysisSetup::Reconfigure ( fhicl::ParameterSet const &  pset)
overrideprivatevirtual

The base version of this method just registers fnex::Shifters using RegisterShifters(). Derived classes can do other things in overrides (but should still call this base class method too).

Reimplemented from fnex::AnalysisSetupBase.

Definition at line 364 of file NuEAnalysisSetup.cxx.

References fNuEEEstimator, fPIDMax, fPIDMin, fhicl::ParameterSet::get(), cet::sqlite::max(), min(), fnex::AnalysisSetupBase::Reconfigure(), and string.

Referenced by NuEAnalysisSetup().

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  }
virtual void Reconfigure(fhicl::ParameterSet const &pset)
static float min(const float a, const float b, const float c)
Definition: absgeo.cxx:45
double fPIDMax
maximum allowed PID value for this analysis
T max(sqlite3 *const db, std::string const &table_name, std::string const &column_name)
Definition: statistics.h:68
double fPIDMin
minimum allowed PID value for this analysis
enum BeamMode string

Member Data Documentation

art::ServiceHandle<ds::DetectorService> fnex::NuEAnalysisSetup::fDetService
private

which detector?

Definition at line 106 of file NuEAnalysisSetup.h.

Referenced by FillVars().

std::string fnex::NuEAnalysisSetup::fNuEEEstimator
private

Definition at line 70 of file NuEAnalysisSetup.h.

Referenced by FillVars(), and Reconfigure().

double fnex::NuEAnalysisSetup::fPIDMax
private

maximum allowed PID value for this analysis

Definition at line 103 of file NuEAnalysisSetup.h.

Referenced by FillVars(), and Reconfigure().

double fnex::NuEAnalysisSetup::fPIDMin
private

minimum allowed PID value for this analysis

Definition at line 102 of file NuEAnalysisSetup.h.

Referenced by Reconfigure().

art::ServiceHandle<nova::dbi::RunHistoryService> fnex::NuEAnalysisSetup::fRH
private

RunHistory service.

Definition at line 105 of file NuEAnalysisSetup.h.

art::ServiceHandle<rwgt::MCReweight> fnex::AnalysisSetupBase::fRwgt
protectedinherited
art::ServiceHandle<art::TFileService> fnex::NuEAnalysisSetup::fTFS
private

Definition at line 108 of file NuEAnalysisSetup.h.

rwgt::WeightType fnex::AnalysisSetupBase::fXSecWgtScheme
protectedinherited

The documentation for this class was generated from the following files: