|
| SystShifts | GetShift (TString systName, double sigma) |
| |
| const Cut | kW_TL ([](const caf::SRProxy *sr){bool IsTrue=(sr->trk.kalman.tracks[0].start.X()< XCent && sr->trk.kalman.tracks[0].start.Y() > YCent);return IsTrue;}) |
| |
| const Cut | kW_TR ([](const caf::SRProxy *sr){bool IsTrue(sr->trk.kalman.tracks[0].start.X() > XCent && sr->trk.kalman.tracks[0].start.Y() > YCent);return IsTrue;}) |
| |
| const Cut | kW_BL ([](const caf::SRProxy *sr){bool IsTrue(sr->trk.kalman.tracks[0].start.X()< XCent && sr->trk.kalman.tracks[0].start.Y()< YCent);return IsTrue;}) |
| |
| const Cut | kW_BR ([](const caf::SRProxy *sr){bool IsTrue(sr->trk.kalman.tracks[0].start.X() > XCent && sr->trk.kalman.tracks[0].start.Y()< YCent);return IsTrue;}) |
| |
| const Var | kKalFwdCell ([](const caf::SRProxy *sr){return sr->sel.contain.kalfwdcell;}) |
| |
| const Var | kKalBakCell ([](const caf::SRProxy *sr){return sr->sel.contain.kalbakcell;}) |
| |
| const Var | kMaxKalYPos ([](const caf::SRProxy *sr){if(sr->trk.kalman.ntracks< 1) return-10.0f;return std::max(sr->trk.kalman.tracks[0].start.Y()/100, sr->trk.kalman.tracks[0].stop.Y()/100);}) |
| |
| const Var | kMaxKalZPos ([](const caf::SRProxy *sr){if(sr->trk.kalman.ntracks< 1) return-10.0f;return std::max(sr->trk.kalman.tracks[0].start.Z()/100, sr->trk.kalman.tracks[0].stop.Z()/100);}) |
| |
| const Var | kScattTrLen ([](const caf::SRProxy *sr){if(sr->trk.kalman.ntracks< 1) return-10.0f;return(float)((float) sr->sel.cosrej.scatt/(float) sr->trk.kalman.tracks[0].len);}) |
| |
| const Var | kMinCellEdg ([](const caf::SRProxy *sr){return std::min((sr->sel.contain.kalfwdcell+sr->sel.contain.kalbakcell), (sr->sel.contain.cosfwdcell+sr->sel.contain.cosbakcell));}) |
| |
| const Var | kRatOfKalHi ([](const caf::SRProxy *sr){if(sr->trk.kalman.ntracks< 1) return-10.0f;return(float)((float) sr->trk.kalman.tracks[0].nhit/(float) sr->slc.nhit);}) |
| |
| const Var | kSANumuContPID ([](const caf::SRProxy *sr){return sr->sel.cosrej.numuSAcontpid;}) |
| |
| const Var | kFirstCell ([](const caf::SRProxy *sr){return sr->slc.firstcell;}) |
| |
| const Var | kLastCell ([](const caf::SRProxy *sr){return sr->slc.lastcell;}) |
| |
| const Var | kVisESlc ([](const caf::SRProxy *sr){return sr->slc.calE;}) |
| |
| const Var | kNHitSlc ([](const caf::SRProxy *sr){return sr->slc.nhit;}) |
| |
| const Var | kEnPHSlc ([](const caf::SRProxy *sr){if(sr->slc.nhit< 1) return-10.0f;return(float)(sr->slc.calE)/(float)(1.78 *sr->slc.nhit);}) |
| |
| const Var | kVisETrk ([](const caf::SRProxy *sr){if(sr->trk.kalman.ntracks< 1) return-10.0f;return(float) sr->trk.kalman.tracks[0].calE;}) |
| |
| const Var | kNHitTrk ([](const caf::SRProxy *sr){if(sr->trk.kalman.ntracks< 1) return-10.0f;return(float) sr->trk.kalman.tracks[0].nhit;}) |
| |
| const Var | kEnPHTrk ([](const caf::SRProxy *sr){if(sr->trk.kalman.ntracks< 1) return-10.0f;return(float)(sr->trk.kalman.tracks[0].calE)/(float)(1.78 *sr->trk.kalman.tracks[0].nhit);}) |
| |
| const Var | kVisEHad ([](const caf::SRProxy *sr){if(sr->trk.kalman.ntracks< 1) return-10.0f;return(float)(sr->slc.calE-sr->trk.kalman.tracks[0].calE);}) |
| |
| const Var | kNHitHad ([](const caf::SRProxy *sr){if(sr->trk.kalman.ntracks< 1) return-10.0f;return(float)(sr->slc.nhit-sr->trk.kalman.tracks[0].nhit);}) |
| |
| const Var | kEnPHHad ([](const caf::SRProxy *sr){if(sr->trk.kalman.ntracks< 1) return-10.0f;return(float)(sr->slc.calE-sr->trk.kalman.tracks[0].calE)/(float)(1.78 *(sr->slc.nhit-sr->trk.kalman.tracks[0].nhit));}) |
| |
| const Var | kTrkLenXY ([](const caf::SRProxy *sr){if(sr->trk.kalman.ntracks< 1) return-10.0f;float XLen=(sr->trk.kalman.tracks[0].start.X()-sr->trk.kalman.tracks[0].stop.X())/100;float YLen=(sr->trk.kalman.tracks[0].start.Y()-sr->trk.kalman.tracks[0].stop.Y())/100;return XLen-YLen;}) |
| |
| const Var | kTrueHFrE ([](const caf::SRProxy *sr){float HadE=kTrueHadE(sr);float TruE=kTrueE(sr);return(HadE/TruE);}) |
| |
| void | DefaultFormatNue (DataMCComponets &comp, int linestyle=1) |
| |
| struct DataMCComponets | GetNDComponents (TDirectory *d_no, double kNDPOT, int linestyle=1) |
| |
| struct DataMCComponets | GetFDMCComponents (osc::IOscCalc *calc, IPrediction *pred_no, TString output_name="nue", int linestyle=1, bool bkgdetails=false) |
| |
| void | CompareNDDataOneMC (TDirectory *d_no, TDirectory *d_sh, TString plottitle, TString out_name, TString pidtag, bool printtable=true, AxisType pidaxis=kNue1bin) |
| |
| void | CompareNDDataTwoMC (TDirectory *d_no, TDirectory *d_pl, TDirectory *d_mi, TString plottitle, TString out_name, TString pidtag, bool printtable=true, AxisType pidaxis=kNue1bin) |
| |
| void | CompareNDDataMCFromVector (TDirectory *d_no, std::vector< TDirectory * > d_sh, TString plottitle, TString out_name, TString tag, bool printtable=true, AxisType pidaxis=kNue1bin) |
| |
| void | CompareOneShiftPred (IPrediction *pred_no, IPrediction *pred_sh, TString plottitle, TString out_name, TString pidtag, bool printtable=true, AxisType pidaxis=kNue1bin, bool PrintParams=false) |
| |
| void | CompareTwoShiftPred (IPrediction *pred_no, IPrediction *pred_pl, IPrediction *pred_mi, TString plottitle, TString out_name, TString pidtag, bool printtable=true, AxisType pidaxis=kNue1bin, bool PrintParams=false) |
| |
| void | ComparePredictionsFromVector (TDirectory *dpred_no, std::vector< TDirectory * > dpred_sh, TString plottitle, TString out_name, bool printtable=true, AxisType pidaxis=kNue1bin) |
| |
| void | ComparePredictionsPeripheralFromVector (TDirectory *dpred_no_xp, TDirectory *dpred_no_nxp, std::vector< TDirectory * > dpred_sh_xp, std::vector< TDirectory * > dpred_sh_nxp, TString plottitle, TString out_name, bool printtable=true, AxisType pidaxis=kNue4bin) |
| |
| double | CalcChi2 (TH1 *hmc, TH1 *hdata) |
| |
| TString | MakeLatexCommandName (TString mystring) |
| |
| TString | FixPlotName (TString mystring) |
| |
| void | PrintLatexFigure (TString name, TString plotdir="plots/") |
| |
| void | PrintTableHeader (TString ltxcommand="", TString labelcol_style="l", TString bincol_style="| r r r", int nbins=1) |
| |
| void | PrintTableFooter () |
| |
| bool | sort_chisq_sig (SystResults a, SystResults b) |
| |
| bool | sort_chisq_bkg (SystResults a, SystResults b) |
| |
| void | SetVecValues_Diff (SystResults &MyVec, int Ind, double Sig0, double Sig1, double Bkg0, double Bkg1, double Tot0, double Tot1) |
| |
| void | SetVecValues_ChiSq (SystResults &MyVec, double Sig0, double Sig1, double Bkg0, double Bkg1, double Tot0, double Tot1) |
| |
| void | AddToSummaryV (TString ltxcommand, TString systName, const std::vector< TH1 * > &mcnom, const std::vector< TH1 * > &mcplu, const std::vector< TH1 * > &mcmin) |
| |
| void | ComparisonTableOne (const std::vector< TH1 * > &mcnom, const std::vector< TH1 * > &mcshift, const std::vector< TString > &labels, const TString ltxcommand="") |
| |
| void | ComparisonTableOneNbins (const std::vector< TH1 * > &mcnom, const std::vector< TH1 * > &mcshift, const std::vector< TString > &labels, TString ltxcommand, int N=3) |
| |
| void | ComparisonTable (const std::vector< TH1 * > &mcnom, const std::vector< TH1 * > &mcplus, const std::vector< TH1 * > &mcminus, std::vector< TString > labels, TString ltxcommand="") |
| |
| TString | FixMeSummary (double number, bool isdiff=true) |
| |
| void | MakeSummaryV (bool signal=true, TString xptype="nxp", bool sorted=false) |
| |
| void | ComparisonTableNbins (const std::vector< TH1 * > &mcnom, const std::vector< TH1 * > &mcplus, const std::vector< TH1 * > &mcminus, std::vector< TString > labels, TString ltxcommand="", int N=3) |
| |
| void | PrintRawEventCounts (TDirectory *dpred, TString title) |
| |
| void | PrintOscilationParameters (osc::IOscCalc *calc, bool usingdumb) |
| |
| double | CalcPrimE (const caf::SRProxy *sr, int WhPDG, bool GetUncontE) |
| |
| const Var | kNeutrinoEn ([](const caf::SRProxy *sr){float ThisEn=0.;ThisEn=sr->mc.nu[0].E;return ThisEn;}) |
| |
| const Var | kTotUncontEn ([](const caf::SRProxy *sr){float TotEn=0.0;for(unsigned int PrimL=0;PrimL< sr->mc.nu[0].prim.size();++PrimL){TotEn+=sr->mc.nu[0].prim[PrimL].totEscE;} std::cout<< "Energy "<< TotEn<< " Run "<< sr->hdr.run<< ", SubRun "<< sr->hdr.subrun<< ", Cycle "<< sr->hdr.cycle<< ", Batch "<< sr->hdr.batch<< ", Event "<< sr->hdr.evt<< ", Slice "<< sr->hdr.subevt<< std::endl;return TotEn;}) |
| |
| const Var | kMuonEn ([](const caf::SRProxy *sr){float ThisEn=0.;ThisEn=CalcPrimE(sr, 13, false);return ThisEn;}) |
| |
| const Var | kUncontMuonEn ([](const caf::SRProxy *sr){float ThisEn=0.;ThisEn=CalcPrimE(sr, 13, true);return ThisEn;}) |
| |
| const Var | kNeutronEn ([](const caf::SRProxy *sr){float ThisEn=0.;ThisEn=CalcPrimE(sr, 2112, false);return ThisEn;}) |
| |
| const Var | kUncontNeutronEn ([](const caf::SRProxy *sr){float ThisEn=0.;ThisEn=CalcPrimE(sr, 2112, true);return ThisEn;}) |
| |
| const Var | kProtonEn ([](const caf::SRProxy *sr){float ThisEn=0.;ThisEn=CalcPrimE(sr, 2212, false);return ThisEn;}) |
| |
| const Var | kUncontProtonEn ([](const caf::SRProxy *sr){float ThisEn=0.;ThisEn=CalcPrimE(sr, 2212, true);return ThisEn;}) |
| |
| const Var | kPionEn ([](const caf::SRProxy *sr){float ThisEn=0.;ThisEn=CalcPrimE(sr, 211, false);return ThisEn;}) |
| |
| const Var | kUncontPionEn ([](const caf::SRProxy *sr){float ThisEn=0.;ThisEn=CalcPrimE(sr, 211, true);return ThisEn;}) |
| |
| const Var | kPi0En ([](const caf::SRProxy *sr){float ThisEn=0.;ThisEn=CalcPrimE(sr, 111, false);return ThisEn;}) |
| |
| const Var | kUncontPi0En ([](const caf::SRProxy *sr){float ThisEn=0.;ThisEn=CalcPrimE(sr, 111, true);return ThisEn;}) |
| |
| const Var | kPhotonEn ([](const caf::SRProxy *sr){float ThisEn=0.;ThisEn=CalcPrimE(sr, 22, false);return ThisEn;}) |
| |
| const Var | kUncontPhotonEn ([](const caf::SRProxy *sr){float ThisEn=0.;ThisEn=CalcPrimE(sr, 22, true);return ThisEn;}) |
| |
| const Var | kKaonEn ([](const caf::SRProxy *sr){float ThisEn=0.;ThisEn=CalcPrimE(sr, 321, false);return ThisEn;}) |
| |
| const Var | kUncontKaonEn ([](const caf::SRProxy *sr){float ThisEn=0.;ThisEn=CalcPrimE(sr, 321, true);return ThisEn;}) |
| |
| const Var | kElectronEn ([](const caf::SRProxy *sr){float ThisEn=0.;ThisEn=CalcPrimE(sr, 11, false);return ThisEn;}) |
| |
| const Var | kUncontElectronEn ([](const caf::SRProxy *sr){float ThisEn=0.;ThisEn=CalcPrimE(sr, 11, true);return ThisEn;}) |
| |
| const Var | kNuMinusAll ([](const caf::SRProxy *sr){return kNeutrinoEn(sr)-kMuonEn(sr)-kNeutronEn(sr)-kProtonEn(sr)-kPionEn(sr)-kPi0En(sr)-kPhotonEn(sr)-kKaonEn(sr)-kElectronEn(sr);}) |
| |
| const Var | kUncontMiscEn ([](const caf::SRProxy *sr){return kTotUncontEn(sr)-kUncontMuonEn(sr)-kUncontNeutronEn(sr)-kUncontProtonEn(sr)-kUncontPionEn(sr)-kUncontPi0En(sr)-kUncontPhotonEn(sr)-kUncontKaonEn(sr)-kUncontElectronEn(sr);}) |
| |
| double | CalcFracE (const caf::SRProxy *sr, int WhPDG, bool GetUncontE, bool UncontOverTotal=false) |
| |
| const Var | kTotUncontEnFrac ([](const caf::SRProxy *sr){if(sr->mc.nu[0].E<=0.0) return-5.0;else return(kTotUncontEn(sr)/sr->mc.nu[0].E);}) |
| |
| const Var | kMuonEnFrac ([](const caf::SRProxy *sr){return CalcFracE(sr, 13, false);}) |
| |
| const Var | kUncontMuonEnFrac ([](const caf::SRProxy *sr){return CalcFracE(sr, 13, true);}) |
| |
| const Var | kUncontMuonEnFracTot ([](const caf::SRProxy *sr){return CalcFracE(sr, 13, true, true);}) |
| |
| const Var | kNeutronEnFrac ([](const caf::SRProxy *sr){return CalcFracE(sr, 2112, false);}) |
| |
| const Var | kUncontNeutronEnFrac ([](const caf::SRProxy *sr){return CalcFracE(sr, 2112, true);}) |
| |
| const Var | kUncontNeutronEnFracTot ([](const caf::SRProxy *sr){return CalcFracE(sr, 2112, true, true);}) |
| |
| const Var | kProtonEnFrac ([](const caf::SRProxy *sr){return CalcFracE(sr, 2212, false);}) |
| |
| const Var | kUncontProtonEnFrac ([](const caf::SRProxy *sr){return CalcFracE(sr, 2212, true);}) |
| |
| const Var | kUncontProtonEnFracTot ([](const caf::SRProxy *sr){return CalcFracE(sr, 2212, true, true);}) |
| |
| const Var | kPionEnFrac ([](const caf::SRProxy *sr){return CalcFracE(sr, 211, false);}) |
| |
| const Var | kUncontPionEnFrac ([](const caf::SRProxy *sr){return CalcFracE(sr, 211, true);}) |
| |
| const Var | kUncontPionEnFracTot ([](const caf::SRProxy *sr){return CalcFracE(sr, 211, true, true);}) |
| |
| const Var | kPi0EnFrac ([](const caf::SRProxy *sr){return CalcFracE(sr, 111, false);}) |
| |
| const Var | kUncontPi0EnFrac ([](const caf::SRProxy *sr){return CalcFracE(sr, 111, true);}) |
| |
| const Var | kUncontPi0EnFracTot ([](const caf::SRProxy *sr){return CalcFracE(sr, 111, true, true);}) |
| |
| const Var | kPhotonEnFrac ([](const caf::SRProxy *sr){return CalcFracE(sr, 22, false);}) |
| |
| const Var | kUncontPhotonEnFrac ([](const caf::SRProxy *sr){return CalcFracE(sr, 22, true);}) |
| |
| const Var | kUncontPhotonEnFracTot ([](const caf::SRProxy *sr){return CalcFracE(sr, 22, true, true);}) |
| |
| const Var | kKaonEnFrac ([](const caf::SRProxy *sr){return CalcFracE(sr, 321, false);}) |
| |
| const Var | kUncontKaonEnFrac ([](const caf::SRProxy *sr){return CalcFracE(sr, 321, true);}) |
| |
| const Var | kUncontKaonEnFracTot ([](const caf::SRProxy *sr){return CalcFracE(sr, 321, true, true);}) |
| |
| const Var | kElectronEnFrac ([](const caf::SRProxy *sr){return CalcFracE(sr, 11, false);}) |
| |
| const Var | kUncontElectronEnFrac ([](const caf::SRProxy *sr){return CalcFracE(sr, 11, true);}) |
| |
| const Var | kUncontElectronEnFracTot ([](const caf::SRProxy *sr){return CalcFracE(sr, 11, true, true);}) |
| |
| const Var | kNNeutrons ([](const caf::SRProxy *sr){float NPar=0.;if(DEBUGGING){std::cout<< "\nLooking at event "<< sr->hdr.evt<< ", there are "<< sr->mc.nu.size()<< ", the 0th neutrino is a "<< sr->mc.nu[0].pdg<< ", with Energy "<< sr->mc.nu[0].E<< ". There were a total of "<< sr->mc.nu[0].prim.size()<< " other primaries associated with that neutrino, "<< sr->mc.nu[0].nneutron<< " were neutrons."<< std::endl;if(kIsDytmanMEC(sr)) std::cout<< " The neutrino was a MEC"<< std::endl;else if(kIsDIS(sr)) std::cout<< " The neutrino was a DIS"<< std::endl;else if(kIsRes(sr)) std::cout<< " The neutrino was a Resonance"<< std::endl;else if(kIsCoh(sr)) std::cout<< " The neutrino was a Coherent"<< std::endl;float TotEn=0.0;for(unsigned int PrimL=0;PrimL< sr->mc.nu[0].prim.size();++PrimL){std::cout<< "\t\tLooking at Prim "<< PrimL<< " of "<< sr->mc.nu[0].prim.size()<< ", it was a "<< sr->mc.nu[0].prim[PrimL].pdg<< ", VisE "<< sr->mc.nu[0].prim[PrimL].visE<< ", VisEInslc "<< sr->mc.nu[0].prim[PrimL].visEinslc<< ", E0 "<< sr->mc.nu[0].prim[PrimL].p.E<< ", enteringE "<< sr->mc.nu[0].prim[PrimL].enteringE<< ", totEscE "<< sr->mc.nu[0].prim[PrimL].totEscE<< std::endl;TotEn+=sr->mc.nu[0].prim[PrimL].totEscE;}std::cout<< "\tThe total uncontained energy was "<< TotEn<< std::endl;NPar=sr->mc.nu[0].nneutron;}return NPar;}) |
| |
| const Var | kNProtons ([](const caf::SRProxy *sr){float NPar=0.;NPar=sr->mc.nu[0].nproton;return NPar;}) |
| |
| const Var | kNPions ([](const caf::SRProxy *sr){float NPar=0.;NPar=sr->mc.nu[0].npiplus+sr->mc.nu[0].npiminus;return NPar;}) |
| |
| const Var | kNPi0s ([](const caf::SRProxy *sr){float NPar=0.;NPar=sr->mc.nu[0].npizero;return NPar;}) |
| |
| void | DefaultFormatNue (DataMCComponents &comp, int linestyle=1) |
| |
| const DataMCComponents | GetNDCompsFromDecomp (const IDecomp *decomp) |
| |
| void | CompareNDDataOneMC (DataMCComponents h_no, DataMCComponents h_sh, TString plottitle, TString out_name, TString pidtag, AxisType pidaxis, bool printtable=true) |
| |
| void | CompareNDDataTwoMC (DataMCComponents hnom, DataMCComponents hplu, DataMCComponents hmin, TString plottitle, TString out_name, TString pidtag, AxisType pidaxis, bool printtable=true) |
| |
| const IDecomp * | GetDecomp (IPrediction *prediction, EModExtrapComps modExtrapComp) |
| |
| void | CompareNDDataMCFromVector (PredictionSystJoint2018 *predictionSyst, const ISyst *syst, EModExtrapComps modExtrapComp, TString plottitle, TString out_name, TString tag, AxisType pidaxis, bool printtable=true) |
| |
| void | ComparePredictionsFromVector (PredictionSystJoint2018 *predictionSyst, const ISyst *syst, TString plottitle, TString out_name, bool printtable=true, AxisType pidaxis=kNue3bin) |
| |
| const DataMCComponents | GetNDComponents (const IDecomp *decomp) |
| |
| void | MakeCutFlowVecs (std::vector< std::string > &NuMu_CutNames, std::vector< Cut > &NuMu_TieredCuts, std::vector< std::string > &Nue_CutNames, std::vector< Cut > &Nue_TieredCuts) |
| |
| const IPrediction * | GetNuePrediction2020 (std::string decomp, osc::IOscCalc *calc, bool corrSysts, std::string beam, bool isFakeData, bool GetFromUPS=false, bool minimizeMemory=true, bool NERSC=false) |
| |
| std::pair< Spectrum *, double > | GetNueCosmics2020 (std::string beam, bool GetFromUPS=false, bool NERSC=false) |
| |
| Spectrum * | GetNueData2020 (std::string beam, bool GetFromUPS=false) |
| |
| std::vector< const IPrediction * > | GetNumuPredictions2020 (const int nq=4, std::string decomp="noPt", osc::IOscCalc *calc=DefaultOscCalc(), bool useSysts=true, std::string beam="fhc", bool isFakeData=false, bool GetFromUPS=false, bool minimizeMemory=true, bool NERSC=false) |
| |
| std::vector< std::pair< Spectrum *, double > > | GetNumuCosmics2020 (const int nq=4, std::string beam="fhc", bool GetFromUPS=false, bool NERSC=false) |
| |
| std::vector< Spectrum * > | GetNumuData2020 (const int nq=4, std::string beam="fhc", bool GetFromUPS=false) |
| |
| std::vector< const ISyst * > | GetJointFitSystematicList (bool corrSysts, bool nueExclusive=false, bool numuExclusive=false, bool isFHC=true, bool isRHC=true, bool intersection=true, bool ptExtrap=true) |
| |
| std::vector< std::pair< const ISyst *, const ISyst * > > | GetCorrelations (bool isNue, bool isFHC, bool ptExtrap) |
| |
| double | GetPOT (bool isFHC=true) |
| |
| double | GetLT (bool isFHC=true) |
| |
| std::pair< double, double > | GetExposure (bool isFHC=true) |
| |
| std::vector< predictions > | LoadPredictions (bool corrSysts=false, bool runOnGrid=false, std::string decomp="", bool nue=true, bool numu=true, bool fhc=true, bool rhc=true, bool NERSC=false) |
| |
| std::vector< Spectrum * > | LoadRealData (bool runOnGrid=false, bool nue=true, bool numu=true, bool fhc=true, bool rhc=true) |
| |
| const Var | kdistTop ([](const caf::SRProxy *sr){if(!sr->vtx.elastic.IsValid||!(sr->vtx.elastic.fuzzyk.png.size() >0)) return(float)-5;float y_val=sr->vtx.elastic.vtx.y;for(unsigned int pngID=0;pngID< sr->vtx.elastic.fuzzyk.png.size();pngID++){float tmp=sr->vtx.elastic.fuzzyk.png[pngID].shwlid.stop.y;if(tmp > y_val) y_val=tmp;}float dist_to_top=765-y_val;return dist_to_top;}) |
| |
| const Var | kdistBottom ([](const caf::SRProxy *sr){if(!sr->vtx.elastic.IsValid||!(sr->vtx.elastic.fuzzyk.png.size() >0)) return(float)-5;float y_val=sr->vtx.elastic.vtx.y;for(unsigned int pngID=0;pngID< sr->vtx.elastic.fuzzyk.png.size();pngID++){float tmp=sr->vtx.elastic.fuzzyk.png[pngID].shwlid.stop.y;if(tmp< y_val) y_val=tmp;}float dist_to_bot=y_val+749;return dist_to_bot;}) |
| |
| const Var | kdistFront ([](const caf::SRProxy *sr){if(!sr->vtx.elastic.IsValid||!(sr->vtx.elastic.fuzzyk.png.size() >0)) return(float)-5;float z_val=sr->vtx.elastic.vtx.z;for(unsigned int pngID=0;pngID< sr->vtx.elastic.fuzzyk.png.size();pngID++){float tmp=sr->vtx.elastic.fuzzyk.png[pngID].shwlid.stop.z;if(tmp< z_val) z_val=tmp;}return z_val;}) |
| |
| const Var | kdistBack ([](const caf::SRProxy *sr){if(!sr->vtx.elastic.IsValid||!(sr->vtx.elastic.fuzzyk.png.size() >0)) return(float)-5;float z_val=sr->vtx.elastic.vtx.z;for(unsigned int pngID=0;pngID< sr->vtx.elastic.fuzzyk.png.size();pngID++){float tmp=sr->vtx.elastic.fuzzyk.png[pngID].shwlid.stop.z;if(tmp > z_val) z_val=tmp;}return 5962-z_val;}) |
| |
| const Var | kdistWest ([](const caf::SRProxy *sr){if(!sr->vtx.elastic.IsValid||!(sr->vtx.elastic.fuzzyk.png.size() >0)) return(float)-5;float x_val=sr->vtx.elastic.vtx.x;for(unsigned int pngID=0;pngID< sr->vtx.elastic.fuzzyk.png.size();pngID++){float tmp=sr->vtx.elastic.fuzzyk.png[pngID].shwlid.stop.x;if(tmp< x_val) x_val=tmp;}float dist_to_west=x_val+758;return dist_to_west;}) |
| |
| const Var | kdistEast ([](const caf::SRProxy *sr){if(!sr->vtx.elastic.IsValid||!(sr->vtx.elastic.fuzzyk.png.size() >0)) return(float)-5;float x_val=sr->vtx.elastic.vtx.x;for(unsigned int pngID=0;pngID< sr->vtx.elastic.fuzzyk.png.size();pngID++){float tmp=sr->vtx.elastic.fuzzyk.png[pngID].shwlid.stop.x;if(tmp > x_val) x_val=tmp;}float dist_to_east=765-x_val;return dist_to_east;}) |
| |
| const Cut | kSingleSlice ([](const caf::SRProxy *sr){return(sr->hdr.subevt< 2);}) |
| |
| const Cut | kDiFBasicQuality ([](const caf::SRProxy *sr){if(!sr->vtx.elastic.IsValid) return false;if(sr->vtx.elastic.fuzzyk.npng==0) return false;return(kApplySecondAnalysisMask(sr)&&kCosRejVeto(sr));}) |
| |
| const Cut | kLooseCVNeCut ([](const caf::SRProxy *sr){return sr->sel.cvnloosepreselptp.nueid > 0.3;}) |
| |
| const Cut | kTestSuperLoose_PTP ([](const caf::SRProxy *sr){return(kNumuQuality(sr)&&kNumuContainFD2017(sr)&&sr->sel.remid.pid > 0.2 &&sr->sel.cvnloosepreselptp.numuid > 0.2);}) |
| |
| const Cut | kTestSuperLoose_Old ([](const caf::SRProxy *sr){return(kNumuQuality(sr)&&kNumuContainFD2017(sr)&&sr->sel.remid.pid > 0.2 &&sr->sel.cvnoldpresel .numuid > 0.2);}) |
| |
| const Cut | kTestLoose_PTP ([](const caf::SRProxy *sr){return(kNumuQuality(sr)&&kNumuContainFD2017(sr)&&sr->sel.remid.pid > 0.4 &&sr->sel.cvnloosepreselptp.numuid > 0.4);}) |
| |
| const Cut | kTestLoose_Old ([](const caf::SRProxy *sr){return(kNumuQuality(sr)&&kNumuContainFD2017(sr)&&sr->sel.remid.pid > 0.4 &&sr->sel.cvnoldpresel .numuid > 0.4);}) |
| |
| const Cut | kTestRelax_PTP ([](const caf::SRProxy *sr){return(kNumuQuality(sr)&&kNumuContainFD2017(sr)&&sr->sel.remid.pid > 0.6 &&sr->sel.cvnloosepreselptp.numuid > 0.6 &&sr->sel.cosrej.numucontpid2020 > 0.45);}) |
| |
| const Cut | kTestRelax_Old ([](const caf::SRProxy *sr){return(kNumuQuality(sr)&&kNumuContainFD2017(sr)&&sr->sel.remid.pid > 0.6 &&sr->sel.cvnoldpresel .numuid > 0.6 &&sr->sel.cosrej.numucontpid2020 > 0.45);}) |
| |
| const Cut | kNumu2020LoosePTP ([](const caf::SRProxy *sr){return(sr->sel.remid.pid > 0.4 &&sr->sel.cvnloosepreselptp.numuid > 0.80);}) |
| |
| const Cut | kNumu2020OldPresel ([](const caf::SRProxy *sr){return(sr->sel.remid.pid > 0.4 &&sr->sel.cvnoldpresel.numuid > 0.84);}) |
| |
| std::vector< std::pair< Cut, std::string > > | BasicPIDPlots_Cuts (bool isFHC, bool isFD, bool isData) |
| |
| std::vector< std::pair< Cut, std::string > > | BasicPIDPlots2019_Cuts (bool isFHC, bool isFD, bool isData) |
| |
| const Var | kShwDirX ([](const caf::SRProxy *sr){if(!sr->vtx.elastic.IsValid||sr->vtx.elastic.fuzzyk.npng< 1) return-5.f;return sr->vtx.elastic.fuzzyk.png[0].dir.X();}) |
| |
| const Var | kShwDirY ([](const caf::SRProxy *sr){if(!sr->vtx.elastic.IsValid||sr->vtx.elastic.fuzzyk.npng< 1) return-5.f;return sr->vtx.elastic.fuzzyk.png[0].dir.Y();}) |
| |
| const Var | kShwDirZ ([](const caf::SRProxy *sr){if(!sr->vtx.elastic.IsValid||sr->vtx.elastic.fuzzyk.npng< 1) return-5.f;return sr->vtx.elastic.fuzzyk.png[0].dir.Z();}) |
| |
| const Var | kShwCosNumi ([](const caf::SRProxy *sr){if(sr->vtx.elastic.IsValid &&sr->vtx.elastic.fuzzyk.npng > 0){if(sr->hdr.det==1){return sr->vtx.elastic.fuzzyk.png[0].dir.Dot(beamDirND);}if(sr->hdr.det==2){return sr->vtx.elastic.fuzzyk.png[0].dir.Dot(beamDirFD);}}return-5.f;}) |
| |
| const DataMCComponents | GetNDDecompsFromDecomp (const IDecomp *decomp) |
| |
| void | CompareNDDataTwoMC (DataMCComponents hnom, DataMCComponents hplu, DataMCComponents hmin, TString plottitle, TString out_name, TString pidtag, AxisType pidaxis, bool printtable=true, bool decomps=false) |
| |
| void | CompareNDDataMCFromVector (PredictionSyst3Flavor2020 *predictionSyst, const ISyst *syst, EModExtrapComps modExtrapComp, TString plottitle, TString out_name, TString tag, AxisType pidaxis, bool printtable=true) |
| |
| void | ComparePredictionsFromVector (PredictionSyst3Flavor2020 *predictionSyst, const ISyst *syst, TString plottitle, TString out_name, bool printtable=true, AxisType pidaxis=kNue3bin) |
| |
| bool | sort_chisq_tot (SystResults a, SystResults b) |
| |
| void | ComparisonTableOneNbins (const std::vector< TH1 * > &mcnom, const std::vector< TH1 * > &mcshift, const std::vector< TString > &labels, TString ltxcommand, AxisType pidaxis) |
| |
| void | MakeSummaryV (TString sample="tot", TString xptype="nxp", bool sorted=false) |
| |
| void | ComparisonTableNbins (const std::vector< TH1 * > &mcnom, const std::vector< TH1 * > &mcplus, const std::vector< TH1 * > &mcminus, std::vector< TString > labels, TString ltxcommand="", AxisType pidaxis=kNue3bin) |
| |
| bool | kNue2017BasicPartFunc (const caf::SRProxy *sr) |
| |
| const Cut | kNue2017BasicPart (kNue2017BasicPartFunc) |
| |
| bool | kNue2018PeripheralPreselFunc (const caf::SRProxy *sr) |
| |
| bool | kNue2018CVNVsCosPIDFunc (const caf::SRProxy *sr) |
| |
| bool | kNue2018FDPeripheralFunc (const caf::SRProxy *sr) |
| | Use this cut for the full FD Peripheral sample, the same for RHC and FHC. More...
|
| |
| const Cut | kNue2018PeripheralPresel (kNue2018PeripheralPreselFunc) |
| |
| const Cut | kNue2018CVNVsCosPID (kNue2018CVNVsCosPIDFunc) |
| |
| const Cut | kNue2018FDPeripheral (kNue2018FDPeripheralFunc) |
| |
| const HistAxis | kNue2018Axis ("NuE Energy / Analysis Bin", kNue2018Binning, kNue2018AnaBin) |
| | Use this Axis for Ana2018, official Axis. More...
|
| |
| bool | kNue2020CVN_VsCosPIDFunc (const caf::SRProxy *sr) |
| |
| bool | kNue2020FDPeripheralFunc (const caf::SRProxy *sr) |
| | Use this cut for the full FD Peripheral sample, the same for RHC and FHC. More...
|
| |
| bool | kNue2020FDPeripheralFunc_MRBrem (const caf::SRProxy *sr) |
| |
| const Cut | kNue2020CVN_VsCosPID (kNue2020CVN_VsCosPIDFunc) |
| |
| const Cut | kNue2020FDPeripheral (kNue2020FDPeripheralFunc) |
| |
| const Cut | kNue2020FDPeripheral_MRBrem (kNue2020FDPeripheralFunc_MRBrem) |
| |
| double | ZFrontPosition (int diblock) |
| |
| double | ZEndPosition (int diblock) |
| |
| Cut | k2018PIDs (double bdtCut, double remidCut, double cvnCut) |
| |
| Cut | OverlayCutFromNuTruthCut (const NuTruthCut stc) |
| |
| const TVector3 | ovtxmin (-180,-180, 25) |
| |
| const TVector3 | ovtxmax (180, 180, 1150) |
| |
| const TVector3 | ovtxminLoose (-220,-220, 0) |
| |
| const TVector3 | ovtxmaxLoose (220, 220, 1150) |
| |
| TH2 * | MakeQuantileHistogram (SpectrumLoader &loader, const HistAxis &independentAxis, const HistAxis &quantileAxis, const Cut &cut, const SpillCut &spillCut, const SystShifts &shift, const Var &wei) |
| | Returns a TH2D with xAxis as independentAxis and yAxis as quantileAxis Quantiles in yAxis can be calculated from this using ana::GetQuantileBins. More...
|
| |
| std::vector< std::vector< double > > | GetQuantileBins (TH2 *quantileHist, const HistAxis &independentAxis, const HistAxis &quantileAxis, const unsigned int &numQuantiles, const bool verbose) |
| | Returns a 2D vector First index is the independentAxis bin number Second index is the high bin edge for a quantile [i][j-1] is jth quantile's low edge for ith independentAxis bin [i][j] is jth quantile's high edge for ith independentAxis bin. More...
|
| |
| std::vector< std::vector< double > > | GetQuantileBins (SpectrumLoader &loader, const HistAxis &independentAxis, const HistAxis &quantileAxis, const Cut &cut, const unsigned int &numQuantiles, const SpillCut &spillCut, const SystShifts &shift, const Var &wei, const bool verbose) |
| | Returns a 2D vector First index is the independentAxis bin number Second index is the high bin edge for a quantile [i][j-1] is jth quantile's low edge for ith independentAxis bin [i][j] is jth quantile's high edge for ith independentAxis bin. More...
|
| |
| const Cut | QuantileCut (const std::vector< std::vector< double >> &quantileBins, const HistAxis &independentAxis, const HistAxis &quantileAxis, const unsigned int &quantile) |
| | Returns a Cut that will only pass events falling into a particular quantile of quantileAxis, where quantiles have been calculated for each independentAxis bin Quantiles have been precalculated in 'quantileBins' (number of quantiles, bin edges etc.) More...
|
| |
| std::vector< Cut > | QuantileCuts (SpectrumLoader &loader, const HistAxis &independentAxis, const HistAxis &quantileAxis, const Cut &cut, const unsigned int &numQuantiles, const SpillCut &spillCut, const SystShifts &shift, const Var &wei, const bool verbose) |
| | Returns a vector of Cuts, each one for a different quantile An individual cut will only pass events falling into a particular quantile of quantileAxis, where quantiles have been calculated for each independentAxis bin. More...
|
| |
| std::vector< Cut > | QuantileCutsFromTH2 (TH2 *quantileHist, const HistAxis &independentAxis, const HistAxis &quantileAxis, const unsigned int &numQuantiles, const bool verbose) |
| | : Do the same as the QuantileCuts function but taking in the TH2 instead of making it. More...
|
| |
| std::vector< Cut > | QuantileAndPIDCutsFromTH2 (TH2 *quantileHist, const HistAxis &independentAxis, const HistAxis &quantileAxis, const unsigned int &numQuantiles, const bool rhc, const bool verbose) |
| |
| std::vector< Cut > | GetNumuEhadFracQuantCuts2020 (const bool isRHC, const unsigned int nquants) |
| |
| std::vector< Cut > | GetNumuPtQuantCuts2020 (const bool isRHC, const unsigned int ehad_quant, const unsigned int nquants) |
| |
| std::vector< Cut > | GetNueQuantCuts2020 (const bool isRHC, const caf::Det_t det, const unsigned int nquants, const ExtrapVar var) |
| |
| const Var | kNueCVNProngBin ([](const caf::SRProxy *sr){if(!kCutCVNProngMaxProtonScore(sr)) return float(0.5);else return float(1.5);return float(-1.5);}) |
| |
| | REGISTER_LOADFROM ("BENDecomp", IDecomp, BENDecomp) |
| |
| | REGISTER_LOADFROM ("FluxDecomp", IDecomp, FluxDecomp) |
| |
| | REGISTER_LOADFROM ("MichelDecomp", IDecomp, MichelDecomp) |
| |
| | REGISTER_LOADFROM ("NueDecomp", IDecomp, NueDecomp) |
| |
| | REGISTER_LOADFROM ("NumuDecomp", IDecomp, NumuDecomp) |
| |
| const Cut | onlyMuOpt (float muCVN) |
| | ------------—selected events with variable CVN score------------------— More...
|
| |
| const Cut | kMuPrOpt (float muCVN, float prCVN) |
| |
| const Cut | kMuPrPrOpt (float muCVN, float prCVN) |
| |
| const Cut | kMuPrEtcOpt (float muCVN, float prCVN) |
| |
| const Cut | kMuEtcOpt (float muCVN, float prCVN) |
| |
| const Cut | kMuGaGaOpt (float muCVN, float gaCVN) |
| |
| const Cut | kMuPiEtcOpt (float muCVN, float piCVN) |
| |
| const Cut | kMu1PiOpt (float muCVN, float piCVN) |
| |
| std::string | GetFittingDirectory () |
| |
| std::string | samplenames (TString samplelist) |
| |
| std::string | systnames (TString systslist) |
| |
| std::vector< const ana::ISyst * > | MECsysts () |
| |
| std::vector< const ana::ISyst * > | getMECtuneSysts () |
| |
| std::vector< const ana::ISyst * > | QEsysts () |
| |
| std::vector< const ana::ISyst * > | RESsysts () |
| |
| std::vector< const ana::ISyst * > | DISsysts () |
| |
| std::vector< const ana::ISyst * > | FSIsysts () |
| |
| std::vector< const ana::ISyst * > | Othersysts () |
| |
| std::vector< const ana::ISyst * > | getSomeXsecSysts (TString opt) |
| |
| std::vector< const ana::ISyst * > | getAllFluxSysts_2020 () |
| |
| std::vector< const ana::ISyst * > | getLightSystsND_2020 () |
| |
| std::vector< const ana::ISyst * > | getCalibSysts_2020 () |
| |
| std::vector< const ana::ISyst * > | getNeutronSyst_2020 () |
| |
| const Var | kTrueEVis ([](const caf::SRProxy *sr){if(sr->mc.nu.empty()) return 0.;double ret=sr->mc.nu[0].E;if(!sr->mc.nu[0].iscc) ret *=sr->mc.nu[0].y;return ret;}) |
| |
| const Var | kCVNeSS ([](const caf::SRProxy *sr){return sr->sel.cvnProd3Train.nueid;}) |
| |  CVN short-simple PID More...
|
| |
| const Var | kCVNeELU ([](const caf::SRProxy *sr){return sr->sel.cvn.nueid;}) |
| | CVN ELU PID More...
|
| |
| const Var | kCVNe2017 ([](const caf::SRProxy *sr){return sr->sel.cvn2017.nueid;}) |
| | CVN 2017 PID More...
|
| |
| const Cut | kNearestSliceCosRejCoreNoCVN ([](const caf::SRProxy *sr){if(kNue2018CorePresel(sr)){return!(sr->slc.closestslicetime >-100.&& sr->slc.closestslicetime< 100.&& sr->slc.closestsliceminfromtop< 400 && sr->slc.closestslicemindist< 500.);}return false;}) |
| |
| const Var | kOneSelBinRHC ([](const caf::SRProxy *sr){if(sr->sel.cvnProd3Train.nueid >=0.89) return float(0.5);else return float(-5.0);}) |
| |
| const Var | kOneAnaBinRHC ([](const caf::SRProxy *sr){int selBin=kOneSelBinRHC(sr);float nuE=kNueEnergy2018(sr);int nuEBin=nuE/0.5;assert(nuEBin<=8 &&"An event with nuE > 4.5 should never happen");int anaBin=9 *selBin+nuEBin;return anaBin;}) |
| |
| const HistAxis | kOneBinRHCAxis ("NuE Energy / RHC Analysis Bin", kNue2018Binning, kOneAnaBinRHC) |
| |
| const Var | kTwoSelBinRHC ([](const caf::SRProxy *sr){if(sr->sel.cvnProd3Train.nueid >=0.76 &&sr->sel.cvnProd3Train.nueid< 0.96) return float(0.5);else if(sr->sel.cvnProd3Train.nueid >=0.96) return float(1.5);else return float(-5.0);}) |
| |
| const Var | kTwoAnaBinRHC ([](const caf::SRProxy *sr){int selBin=kTwoSelBinRHC(sr);float nuE=kNueEnergy2018(sr);int nuEBin=nuE/0.5;assert(nuEBin<=8 &&"An event with nuE > 4.5 should never happen");int anaBin=9 *selBin+nuEBin;return anaBin;}) |
| |
| const HistAxis | kTwoBinRHCAxis ("NuE Energy / RHC Analysis Bin", kNue2018Binning, kTwoAnaBinRHC) |
| |
| const Var | kTwoSelBinHiPurRHC ([](const caf::SRProxy *sr){if(sr->sel.cvnProd3Train.nueid >=0.89 &&sr->sel.cvnProd3Train.nueid< 0.99) return float(0.5);else if(sr->sel.cvnProd3Train.nueid >=0.99) return float(1.5);else return float(-5.0);}) |
| |
| const Var | kTwoAnaBinHiPurRHC ([](const caf::SRProxy *sr){int selBin=kTwoSelBinHiPurRHC(sr);float nuE=kNueEnergy2018(sr);int nuEBin=nuE/0.5;assert(nuEBin<=8 &&"An event with nuE > 4.5 should never happen");int anaBin=9 *selBin+nuEBin;return anaBin;}) |
| |
| const HistAxis | kTwoBinHiPurRHCAxis ("NuE Energy / RHC Analysis Bin", kNue2018Binning, kTwoAnaBinHiPurRHC) |
| |
| const Var | kThreeSelBinRHC ([](const caf::SRProxy *sr){if(sr->sel.cvnProd3Train.nueid >=0.71 &&sr->sel.cvnProd3Train.nueid< 0.92) return float(0.5);else if(sr->sel.cvnProd3Train.nueid >=0.92 && sr->sel.cvnProd3Train.nueid< 0.98) return float(1.5);else if(sr->sel.cvnProd3Train.nueid >=0.98) return float(2.5);else return float(-5.0);}) |
| |
| const Var | kThreeAnaBinRHC ([](const caf::SRProxy *sr){int selBin=kThreeSelBinRHC(sr);float nuE=kNueEnergy2018(sr);int nuEBin=nuE/0.5;assert(nuEBin<=8 &&"An event with nuE > 4.5 should never happen");int anaBin=9 *selBin+nuEBin;return anaBin;}) |
| |
| const HistAxis | kThreeBinRHCAxis ("NuE Energy / RHC Analysis Bin", kNue2018Binning, kThreeAnaBinRHC) |
| |
| const Var | kFourSelBinRHC ([](const caf::SRProxy *sr){if(sr->sel.cvnProd3Train.nueid >=0.71 && sr->sel.cvnProd3Train.nueid< 0.92) return float(0.5);else if(sr->sel.cvnProd3Train.nueid >=0.92 && sr->sel.cvnProd3Train.nueid< 0.98) return float(1.5);else if(sr->sel.cvnProd3Train.nueid >=0.98 && sr->sel.cvnProd3Train.nueid< 0.99) return float(2.5);else if(sr->sel.cvnProd3Train.nueid >=0.99) return float(3.5);else return float(-5.0);}) |
| |
| const Var | kFourAnaBinRHC ([](const caf::SRProxy *sr){int selBin=kFourSelBinRHC(sr);float nuE=kNueEnergy2018(sr);int nuEBin=nuE/0.5;assert(nuEBin<=8 &&"An event with nuE > 4.5 should never happen");int anaBin=9 *selBin+nuEBin;return anaBin;}) |
| |
| const HistAxis | kFourBinRHCAxis ("NuE Energy / RHC Analysis Bin", kNue2018Binning, kFourAnaBinRHC) |
| |
| const Var | kOneSelBinFHC ([](const caf::SRProxy *sr){if(sr->sel.cvnProd3Train.nueid >=0.86) return float(0.5);else return float(-5.0);}) |
| |
| const Var | kOneAnaBinFHC ([](const caf::SRProxy *sr){int selBin=kOneSelBinFHC(sr);float nuE=kNueEnergy2018(sr);int nuEBin=nuE/0.5;assert(nuEBin<=8 &&"An event with nuE > 4.5 should never happen");int anaBin=9 *selBin+nuEBin;return anaBin;}) |
| |
| const HistAxis | kOneBinFHCAxis ("NuE Energy / FHC Analysis Bin", kNue2018Binning, kOneAnaBinFHC) |
| |
| const Var | kTwoSelBinFHC ([](const caf::SRProxy *sr){if(sr->sel.cvnProd3Train.nueid >=0.72 &&sr->sel.cvnProd3Train.nueid< 0.94) return float(0.5);else if(sr->sel.cvnProd3Train.nueid >=0.94) return float(1.5);else return float(-5.0);}) |
| |
| const Var | kTwoAnaBinFHC ([](const caf::SRProxy *sr){int selBin=kTwoSelBinFHC(sr);float nuE=kNueEnergy2018(sr);int nuEBin=nuE/0.5;assert(nuEBin<=8 &&"An event with nuE > 4.5 should never happen");int anaBin=9 *selBin+nuEBin;return anaBin;}) |
| |
| const HistAxis | kTwoBinFHCAxis ("NuE Energy / FHC Analysis Bin", kNue2018Binning, kTwoAnaBinFHC) |
| |
| const Var | kThreeSelBinFHC ([](const caf::SRProxy *sr){if(sr->sel.cvnProd3Train.nueid >=0.54 &&sr->sel.cvnProd3Train.nueid< 0.84) return float(0.5);else if(sr->sel.cvnProd3Train.nueid >=0.84 && sr->sel.cvnProd3Train.nueid< 0.96) return float(1.5);else if(sr->sel.cvnProd3Train.nueid >=0.96) return float(2.5);else return float(-5.0);}) |
| |
| const Var | kThreeAnaBinFHC ([](const caf::SRProxy *sr){int selBin=kThreeSelBinFHC(sr);float nuE=kNueEnergy2018(sr);int nuEBin=nuE/0.5;assert(nuEBin<=8 &&"An event with nuE > 4.5 should never happen");int anaBin=9 *selBin+nuEBin;return anaBin;}) |
| |
| const HistAxis | kThreeBinFHCAxis ("NuE Energy / FHC Analysis Bin", kNue2018Binning, kThreeAnaBinFHC) |
| |
| const Var | kFourSelBinFHC ([](const caf::SRProxy *sr){if(sr->sel.cvnProd3Train.nueid >=0.54 && sr->sel.cvnProd3Train.nueid< 0.84) return float(0.5);else if(sr->sel.cvnProd3Train.nueid >=0.84 && sr->sel.cvnProd3Train.nueid< 0.96) return float(1.5);else if(sr->sel.cvnProd3Train.nueid >=0.96 && sr->sel.cvnProd3Train.nueid< 0.99) return float(2.5);else if(sr->sel.cvnProd3Train.nueid >=0.99) return float(3.5);else return float(-5.0);}) |
| |
| const Var | kFourAnaBinFHC ([](const caf::SRProxy *sr){int selBin=kFourSelBinFHC(sr);float nuE=kNueEnergy2018(sr);int nuEBin=nuE/0.5;assert(nuEBin<=8 &&"An event with nuE > 4.5 should never happen");int anaBin=9 *selBin+nuEBin;return anaBin;}) |
| |
| const HistAxis | kFourBinFHCAxis ("NuE Energy / FHC Analysis Bin", kNue2018Binning, kFourAnaBinFHC) |
| |
| const Cut | kNueFHCSosbCVNSS ([](const caf::SRProxy *sr){return(sr->sel.cvnProd3Train.nueid > 0.97);}) |
| |
| const Cut | kNueFHCSossbCVNSS ([](const caf::SRProxy *sr){return(sr->sel.cvnProd3Train.nueid > 0.86);}) |
| |
| const Cut | kNueFHCSosbCVNELU ([](const caf::SRProxy *sr){return(sr->sel.cvn.nueid > 0.93);}) |
| |
| const Cut | kNueFHCSossbCVNELU ([](const caf::SRProxy *sr){return(sr->sel.cvn.nueid > 0.66);}) |
| |
| const Cut | kNueFHCSosbCVN2017 ([](const caf::SRProxy *sr){return(sr->sel.cvn2017.nueid > 0.96);}) |
| |
| const Cut | kNueFHCSossbCVN2017 ([](const caf::SRProxy *sr){return(sr->sel.cvn2017.nueid > 0.66);}) |
| |
| const Cut | kNueRHCSosbCVNSS ([](const caf::SRProxy *sr){return(sr->sel.cvnProd3Train.nueid > 0.98);}) |
| |
| const Cut | kNueRHCSossbCVNSS ([](const caf::SRProxy *sr){return(sr->sel.cvnProd3Train.nueid > 0.89);}) |
| |
| const Cut | kNueRHCSosbCVNELU ([](const caf::SRProxy *sr){return(sr->sel.cvn.nueid > 0.92);}) |
| |
| const Cut | kNueRHCSossbCVNELU ([](const caf::SRProxy *sr){return(sr->sel.cvn.nueid > 0.67);}) |
| |
| const Cut | kNueRHCSosbCVN2017 ([](const caf::SRProxy *sr){return(sr->sel.cvn2017.nueid > 0.94);}) |
| |
| const Cut | kNueRHCSossbCVN2017 ([](const caf::SRProxy *sr){return(sr->sel.cvn2017.nueid > 0.72);}) |
| |
| const Var | kCVNmuSS ([](const caf::SRProxy *sr){return sr->sel.cvnProd3Train.numuid;}) |
| | CVN short-simple PID More...
|
| |
| const Var | kCVNmuELU ([](const caf::SRProxy *sr){return sr->sel.cvn.numuid;}) |
| | CVN ELU PID More...
|
| |
| const Var | kCVNmu2017 ([](const caf::SRProxy *sr){return sr->sel.cvn2017.numuid;}) |
| | CVN 2017 PID More...
|
| |
| const Cut | kNumu2017remid ([](const caf::SRProxy *sr){return(sr->sel.remid.pid > 0.5);}) |
| | Numu RemID cut. More...
|
| |
| const Cut | kNumuFHCSosbRemID ([](const caf::SRProxy *sr){return(sr->sel.remid.pid > 0.99);}) |
| |
| const Cut | kNumuFHCSossbRemID ([](const caf::SRProxy *sr){return(sr->sel.remid.pid > 0.68);}) |
| |
| const Cut | kNumuRHCSosbRemID ([](const caf::SRProxy *sr){return(sr->sel.remid.pid > 0.99);}) |
| |
| const Cut | kNumuRHCSossbRemID ([](const caf::SRProxy *sr){return(sr->sel.remid.pid > 0.69);}) |
| |
| const Cut | kNumuFHCSosbCVNSS ([](const caf::SRProxy *sr){return(sr->sel.cvnProd3Train.numuid > 0.98);}) |
| |
| const Cut | kNumuFHCSossbCVNSS ([](const caf::SRProxy *sr){return(sr->sel.cvnProd3Train.numuid > 0.38);}) |
| |
| const Cut | kNumuFHCSosbCVNELU ([](const caf::SRProxy *sr){return(sr->sel.cvn.numuid > 0.98);}) |
| |
| const Cut | kNumuFHCSossbCVNELU ([](const caf::SRProxy *sr){return(sr->sel.cvn.numuid > 0.52);}) |
| |
| const Cut | kNumuFHCSosbCVN2017 ([](const caf::SRProxy *sr){return(sr->sel.cvn2017.numuid > 0.98);}) |
| |
| const Cut | kNumuFHCSossbCVN2017 ([](const caf::SRProxy *sr){return(sr->sel.cvn2017.numuid > 0.43);}) |
| |
| const Cut | kNumuRHCSosbCVNSS ([](const caf::SRProxy *sr){return(sr->sel.cvnProd3Train.numuid > 0.99);}) |
| |
| const Cut | kNumuRHCSossbCVNSS ([](const caf::SRProxy *sr){return(sr->sel.cvnProd3Train.numuid > 0.36);}) |
| |
| const Cut | kNumuRHCSosbCVNELU ([](const caf::SRProxy *sr){return(sr->sel.cvn.numuid > 0.95);}) |
| |
| const Cut | kNumuRHCSossbCVNELU ([](const caf::SRProxy *sr){return(sr->sel.cvn.numuid > 0.50);}) |
| |
| const Cut | kNumuRHCSosbCVN2017 ([](const caf::SRProxy *sr){return(sr->sel.cvn2017.numuid > 0.97);}) |
| |
| const Cut | kNumuRHCSossbCVN2017 ([](const caf::SRProxy *sr){return(sr->sel.cvn2017.numuid > 0.34);}) |
| |
| const Var | kCVNncSS ([](const caf::SRProxy *sr){return sr->sel.cvnProd3Train.ncid;}) |
| |  CVN short-simple PID More...
|
| |
| const Var | kCVNncELU ([](const caf::SRProxy *sr){return sr->sel.cvn.ncid;}) |
| | CVN ELU PID More...
|
| |
| const Var | kCVNnc2017 ([](const caf::SRProxy *sr){return sr->sel.cvn2017.ncid;}) |
| | CVN 2017 PID More...
|
| |
| const Cut | kNusFHCSosbCVNSS ([](const caf::SRProxy *sr){return(sr->sel.cvnProd3Train.ncid > 0.99);}) |
| |
| const Cut | kNusFHCSossbCVNSS ([](const caf::SRProxy *sr){return(sr->sel.cvnProd3Train.ncid > 0.24);}) |
| |
| const Cut | kNusFHCSosbCVNELU ([](const caf::SRProxy *sr){return(sr->sel.cvn.ncid > 0.97);}) |
| |
| const Cut | kNusFHCSossbCVNELU ([](const caf::SRProxy *sr){return(sr->sel.cvn.ncid > 0.21);}) |
| |
| const Cut | kNusFHCSosbCVN2017 ([](const caf::SRProxy *sr){return(sr->sel.cvn2017.ncid > 0.88);}) |
| |
| const Cut | kNusFHCSossbCVN2017 ([](const caf::SRProxy *sr){return(sr->sel.cvn2017.ncid > 0.24);}) |
| |
| const Cut | kNusRHCSosbCVNSS ([](const caf::SRProxy *sr){return(sr->sel.cvnProd3Train.ncid > 0.99);}) |
| |
| const Cut | kNusRHCSossbCVNSS ([](const caf::SRProxy *sr){return(sr->sel.cvnProd3Train.ncid > 0.24);}) |
| |
| const Cut | kNusRHCSosbCVNELU ([](const caf::SRProxy *sr){return(sr->sel.cvn.ncid > 0.99);}) |
| |
| const Cut | kNusRHCSossbCVNELU ([](const caf::SRProxy *sr){return(sr->sel.cvn.ncid > 0.20);}) |
| |
| const Cut | kNusRHCSosbCVN2017 ([](const caf::SRProxy *sr){return(sr->sel.cvn2017.ncid > 0.85);}) |
| |
| const Cut | kNusRHCSossbCVN2017 ([](const caf::SRProxy *sr){return(sr->sel.cvn2017.ncid > 0.22);}) |
| |
| const std::vector< VarDef > | GetVars (TString opt, TString type="all") |
| |
| std::vector< CutDef > | GetCuts (TString opt, bool pastCuts=false, bool noCut=true) |
| |
| std::vector< WeightDef > | GetWeights (TString opt, bool noWeight=false) |
| |
| std::vector< std::vector< PIDCutDef > > | GetPIDCuts (TString opt, bool noCut=true) |
| |
| void | ComparisonTable (std::vector< TH1 * > mcnom, std::vector< TH1 * > mcshift, std::vector< TString > labels, TString ltxcommand="") |
| |
| void | ComparisonTable (std::vector< TH1 * > mcnom, std::vector< TH1 * > mcplus, std::vector< TH1 * > mcminus, std::vector< TString > labels, TString ltxcommand="") |
| |
| void | FixLegend (TLegend *leg, TString opt="default") |
| |
| TLegend * | DefaultNueLegend (bool sig=true, bool tot=true, bool data=false, double x1=kLegendDefaultX1, double y1=kLegendDefaultY1, double x2=kLegendDefaultX2, double y2=kLegendDefaultY2) |
| |
| TLegend * | CustomLegend (std::vector< TH1 * >h, std::vector< bool >isdata, std::vector< TString >title, double x1=kLegendDefaultX1, double y1=kLegendDefaultY1, double x2=kLegendDefaultX2, double y2=kLegendDefaultY2) |
| |
| TCanvas * | ExPIDPlot (std::vector< TH1 * > topHistos, std::vector< TString > topOption) |
| |
| TCanvas * | RatioPlot (std::vector< TH1 * > topHistos, std::vector< TString > topOption, std::vector< TH1 * > bottomHistos, std::vector< TString > bottomOption, TString pidtag, bool pidaxis=false) |
| |
| void | PlotDataMC (std::vector< TH1 * >vnom, std::vector< bool >isdata, TLegend *leg, TString pidtag="", TString htag="", TString out_name="plot_FD", bool ratioplot=false, bool ratioerrors=false, bool pidaxis=0) |
| |
| void | PlotNDDataTotalMCComparison (TH1 *hdata, std::vector< TH1 * > htots, TLegend *leg, TString pidtag="", TString out_name="plot_nd", bool ratioplot=false, bool pidaxis=false) |
| |
| void | PlotMCComponentsComparison (std::vector< TH1 * >vnom, std::vector< TH1 * >vshi, TLegend *leg, TString pidtag="", TString out_name="plot_nd", bool ratioplot=false, bool ratioerrors=false, bool pidaxis=0) |
| |
| void | CompareNDDataMC (TDirectory *d_no, TDirectory *d_sh, TString plottitle, TString out_name, TString pidtag, bool printtable=true, bool pidaxis=0) |
| |
| void | ComparePredictions (IPrediction *pred_no, IPrediction *pred_sh, TString plottitle, TString out_name, TString pidtag, bool printtable=true, bool pidaxis=false) |
| |
| void | FormatErrorBand (TH1 *hplus, TH1 *hminus, bool signal=false, bool fixbins=false) |
| |
| void | PlotMCComponentsErrorBand (std::vector< TH1 * >vnom, std::vector< TH1 * >vshi, TLegend *leg, TString pidtag="", TString out_name="plot_nd", bool ratioplot=false, bool ratioerrors=false, bool pidaxis=0) |
| |
| struct NueMCComponents | GetNDMCComponents (TDirectory *d_no, double kNDPOT, int linestyle=1) |
| |
| void | CompareNDDataMC (TDirectory *d_no, TDirectory *d_pl, TDirectory *d_mi, TString plottitle, TString out_name, TString pidtag, bool printtable=true, bool pidaxis=0) |
| |
| struct NueMCComponents | GetFDMCComponents (IPrediction *pred_no, int linestyle=1) |
| |
| TString | Latexify (TString s) |
| |
| void | ComparePredictions (IPrediction *pred_no, IPrediction *pred_pl, IPrediction *pred_mi, TString plottitle, TString out_name, TString pidtag, bool printtable=true, bool pidaxis=false) |
| |
| void | MakeNueSystematicsFile (IPrediction *pred_no, IPrediction *pred_sh, TString pid, TString sigma, TFile *nue_syst_file) |
| |
| void | AddNueHistDefShowerND (std::vector< ana::HistDef > &hd) |
| |
| void | AddNueHistDefShowerFD (std::vector< HistDef > &hd) |
| |
| void | AddNueHistDefVertexND (std::vector< HistDef > &hd) |
| |
| void | AddNueHistDefVertexFD (std::vector< HistDef > &hd) |
| |
| void | AddNueHistDefShower (std::vector< HistDef > &hd) |
| |
| void | AddNueHistDefForLid (std::vector< HistDef > &hd) |
| |
| void | AddNueHistDefPIDs (std::vector< HistDef > &hd) |
| |
| void | AddNueHistDefConfusion (std::vector< HistDef > &hd) |
| |
| void | AddNueHistDefBasic (std::vector< HistDef > &hd) |
| |
| void | AddNueHistDefSelectionExtras (std::vector< HistDef > &hd) |
| |
| void | AddNueHistDefTruth (std::vector< HistDef > &hd) |
| |
| void | AddNueHistDefWeight (std::vector< HistDef > &hd) |
| |
| void | AddNueHistDefFinalStatesCvn (std::vector< HistDef > &hd) |
| |
| void | AddNueHistDefProngCVN (std::vector< HistDef > &hd) |
| |
| void | AddNueHistDefShowerND (std::vector< HistDef > &) |
| |
| void | AddNueHistDefForLem (std::vector< HistDef > &) |
| |
| void | FillWithDimColor (TH1 *h, bool usealpha, float dim) |
| |
| void | XAxisDeltaCPLabels (TH1 *axes, bool t2kunits=false) |
| | Label the x-axis with fractions of pi. More...
|
| |
| void | Nue2017FourBinDivisions (const int color, const int style) |
| |
| void | Nue2017FourBinLabels (const double yNDC, const double textsize, const int color, const bool merged) |
| |
| void | Nue2017FourBinAxis (TH1 *axes, bool drawLabels, bool merged) |
| |
| void | Nue2018ThreeBinDivisions (bool coreOnly, const int color, const int style) |
| |
| void | Nue2018ThreeBinLabels (const double yNDC, const double textsize, const int color, const bool nd) |
| |
| void | Nue2018ThreeBinAxis (THStack *axes, bool drawLabels, bool merged, bool coreOnly) |
| |
| void | Nue2018ThreeBinAxis (TH1 *axes, bool drawLabels, bool merged, bool coreOnly) |
| |
| void | Nue2018ThreeBinDivisions_Reduced (bool coreOnly, const int color, const int style) |
| |
| void | Nue2018ThreeBinLabels_Reduced (const double yNDC, const double textsize, const int color, const bool nd) |
| |
| void | Nue2018ThreeBinAxis_Reduced (TH1 *axes, bool drawLabels, bool merged, bool coreOnly, bool drawTitle) |
| |
| void | Nue2018ThreeBinAxis_Reduced (THStack *axes, bool drawLabels, bool merged, bool coreOnly, bool drawTitle) |
| |
| TH1 * | RemoveBins (TH1 *h, bool sum) |
| |
| TGraphAsymmErrors * | PlotErrorBand (TH1 *¢er, TH1 *&nom, std::vector< TH1 * > &ups, std::vector< TH1 * > &dns, int col, int errCol) |
| |
| void | AddNumuHistDefND (std::vector< HistDef > &hd) |
| |
| void | AddNumuMultiHistDefND (std::vector< MultiHistDef > &hd) |
| |
| void | AddNumuHistDefFD (std::vector< HistDef > &hd) |
| |
| void | AddNumuMultiHistDefFD (std::vector< MultiHistDef > &hd) |
| |
| void | AddNumuHistDefPIDs (std::vector< HistDef > &hd) |
| |
| void | AddNumuHistDefCosRej (std::vector< HistDef > &hd) |
| |
| void | AddNumuHistDefBasic (std::vector< HistDef > &hd) |
| |
| void | AddNumuHistDefSliceTruth (std::vector< HistDef > &hd) |
| |
| void | AddNumuHistDefNuTruth (std::vector< NuTruthHistDef > &hd) |
| |
| void | AddNumuHistDefWeight (std::vector< HistDef > &hd) |
| |
| void | AddNumuHistDefProngCVN (std::vector< HistDef > &hd) |
| |
| void | AddNumuHistDefBPF (std::vector< HistDef > &hd) |
| |
| void | AddNumuHistDefKalman (std::vector< HistDef > &hd) |
| |
| void | AddNumuHistDefReMId (std::vector< HistDef > &hd) |
| |
| void | AddNumuHistDefEnergy (std::vector< HistDef > &hd) |
| |
| void | AddNumuHistDefProng (std::vector< MultiHistDef > &hd) |
| |
| void | AddNumuHistDefLeftovers (std::vector< HistDef > &hd) |
| |
| void | AddNumuHistDefMultiVar (std::vector< MultiHistDef > &hd) |
| |
| std::vector< HistDef > | getAllNumuProd4NDHistDef () |
| |
| std::vector< HistDef > | getAllNumuProd4FDHistDef () |
| |
| std::vector< HistDef > | getAllNumuProd5NDHistDef () |
| |
| std::vector< NuTruthHistDef > | getAllNumuProd5NDNuTruthHistDef () |
| |
| std::vector< MultiHistDef > | getAllNumuProd5NDMultiHistDef () |
| |
| std::vector< HistDef > | getAllNumuProd5FDHistDef () |
| |
| std::vector< NuTruthHistDef > | getAllNumuProd5FDNuTruthHistDef () |
| |
| std::vector< MultiHistDef > | getAllNumuProd5FDMultiHistDef () |
| |
| void | AddHistDefRecoND (std::vector< HistDef > &hd) |
| |
| void | AddMultiHistDefRecoND (std::vector< MultiHistDef > &hd) |
| |
| void | AddHistDefTruthND (std::vector< HistDef > &hd) |
| |
| void | AddHistDefRecoFD (std::vector< HistDef > &hd) |
| |
| void | AddMultiHistDefRecoFD (std::vector< MultiHistDef > &hd) |
| |
| void | AddHistDefTruthFD (std::vector< HistDef > &hd) |
| |
| void | AddHistDefSlice (std::vector< HistDef > &hd) |
| |
| void | AddHistDefSliceTruth (std::vector< HistDef > &hd) |
| |
| void | AddNTHistDef (std::vector< NuTruthHistDef > &hd) |
| |
| void | AddNTHistDefND (std::vector< NuTruthHistDef > &hd) |
| |
| void | AddNTHistDefFD (std::vector< NuTruthHistDef > &hd) |
| |
| void | AddHistDefWeights (std::vector< HistDef > &hd) |
| |
| void | AddMultiHistDefProng (std::vector< MultiHistDef > &hd) |
| |
| void | AddHistDefProngCVN (std::vector< HistDef > &hd) |
| |
| void | AddHistDefPIDs (std::vector< HistDef > &hd) |
| |
| void | AddHistDefNumuND (std::vector< HistDef > &hd) |
| |
| void | AddHistDefNumuFD (std::vector< HistDef > &hd) |
| |
| void | AddHistDefNumuMuon (std::vector< HistDef > &hd) |
| |
| void | AddHistDefNumuRecoE (std::vector< HistDef > &hd) |
| |
| void | AddHistDefNumuNDDataMC (std::vector< HistDef > &hd) |
| |
| void | AddHistDefNueND (std::vector< HistDef > &hd) |
| |
| void | AddHistDefNueFD (std::vector< HistDef > &hd) |
| |
| void | AddHistDefNueShower (std::vector< HistDef > &hd) |
| |
| void | AddHistDefNueLID (std::vector< HistDef > &hd) |
| |
| void | AddHistDefNuePID (std::vector< HistDef > &hd) |
| |
| void | AddHistDefNueEnergy (std::vector< HistDef > &hd) |
| |
| void | AddHistDefNueSelectionExtras (std::vector< HistDef > &hd) |
| |
| void | AddHistDefNueDataMC (std::vector< HistDef > &hd) |
| |
| void | AddHistDefNusND (std::vector< HistDef > &hd) |
| |
| void | AddHistDefNusFD (std::vector< HistDef > &hd) |
| |
| void | AddHistDefXSecND (std::vector< HistDef > &hd) |
| |
| void | AddHistDefXSecFD (std::vector< HistDef > &hd) |
| |
| | REGISTER_LOADFROM ("PredictionAddRock", IPrediction, PredictionAddRock) |
| |
| | REGISTER_LOADFROM ("PredictionExtendToPeripheral", IPrediction, PredictionExtendToPeripheral) |
| |
| const NumuExtrapGenerator | kNumuCCExtrap (kNumuCCAxis, kNumuFD, kNumuND) |
| |
| const NumuExtrapGenerator | kNumuQEExtrap (kNumuQEAxis, kNumuQEFD, kNumuQEND) |
| |
| const NumuExtrapGenerator | kNumuNonQEExtrap (kNumuNonQEAxis, kNumuNonQEFD, kNumuNonQEND) |
| |
| | REGISTER_LOADFROM ("PredictionSyst3Flavor2020", IPrediction, PredictionSyst3Flavor2020) |
| |
| | REGISTER_LOADFROM ("PredictionSystJoint2018", IPrediction, PredictionSystJoint2018) |
| |
| | REGISTER_LOADFROM ("PredictionSystJointDemo", IPrediction, PredictionSystJointDemo) |
| |
| | REGISTER_LOADFROM ("PredictionSystNue2017", IPrediction, PredictionSystNue2017) |
| |
| | REGISTER_LOADFROM ("PredictionSystNumu2017", IPrediction, PredictionSystNumu2017) |
| |
| std::string | AnaTypeToString (const EAnaType2020 ana) |
| |
| std::vector< const ISyst * > | get3FlavorAna2020LargeXsecSysts (const EAnaType2020 ana) |
| |
| void | Add3FlavorAna2020XSecSysts (std::vector< const ISyst * > &systs, const EAnaType2020 ana, bool smallgenie) |
| |
| void | Add3FlavorAna2020BeamSysts (std::vector< const ISyst * > &systs, const EAnaType2020 ana) |
| |
| void | Add3FlavorAna2020CalibSysts (std::vector< const ISyst * > &systs) |
| |
| void | Add3FlavorAna2020LightSysts (std::vector< const ISyst * > &systs) |
| |
| void | Add3FlavorAna2020FileSysts (std::vector< const ISyst * > &systs) |
| |
| void | Add3FlavorAna2020MuEnergySysts (std::vector< const ISyst * > &systs, const EAnaType2020 ana) |
| |
| void | Add3FlavorAna2020LeptonAngleSysts (std::vector< const ISyst * > &systs, const bool ptExtrap) |
| |
| void | Add3FlavorAna2020NeutronSysts (std::vector< const ISyst * > &systs) |
| |
| void | Add3FlavorAna2020NueAcceptSysts (std::vector< const ISyst * > &systs, const EAnaType2020 ana, const BeamType2020 beam, const bool ptExtrap) |
| |
| void | Add3FlavorAna2020MichelTagSysts (std::vector< const ISyst * > &systs, const EAnaType2020 ana, const BeamType2020 beam) |
| |
| void | Add3FlavorAna2020NotCorrelSysts (std::vector< const ISyst * > &systs, const EAnaType2020 ana, const BeamType2020 beam, const bool ptExtrap) |
| |
| void | Add3FlavorAna2020NormSysts (std::vector< const ISyst * > &systs, const BeamType2020 beam) |
| |
| void | AddNonLoadable2020Systs (std::vector< const ISyst * > &systs, const EAnaType2020 ana) |
| |
| void | Add3FlavorAna2020OtherSysts (std::vector< const ISyst * > &systs, const EAnaType2020 ana, const BeamType2020 beam, const bool ptExtrap) |
| |
| std::vector< const ISyst * > | get3FlavorAna2020AllSysts (const EAnaType2020 ana, const bool smallgenie, const BeamType2020 beam, const bool isFit, const bool ptExtrap) |
| |
| std::vector< const ISyst * > | get3FlavorAna2020AllCPTSysts (const EAnaType2020 ana, const bool smallgenie, const BeamType2020 beam, const bool isFit, const bool ptExtrap) |
| |
| std::vector< const ISyst * > | get3FlavorAna2020SmallXsecSysts (const EAnaType2020 ana) |
| |
| const SummedSyst * | get3FlavorAna2020SummedSmallXsecSysts (const EAnaType2020 ana) |
| |
| std::vector< const ISyst * > | getAna2020NueOnly (const BeamType2020 beam, const bool ptExtrap) |
| |
| std::vector< const ISyst * > | getAna2020NumuOnly (const BeamType2020 beam) |
| |
| std::vector< const ISyst * > | GetSystematics2020 (const TString option) |
| |
| std::vector< ShiDef > | GetShifts2020 (const TString option) |
| |
| std::vector< SNameDef > | GetShiftNames2020 (const TString option) |
| |
| std::vector< int > | GetDummyShifts (const ISyst *s) |
| |
| GeniePCASyst * | GetGeniePrincipals2020Small (int PCIdx) |
| |
| GeniePCASyst * | GetGeniePrincipals2018 (int PCIdx) |
| |
| GeniePCASyst * | GetGeniePrincipals2018Small (int PCIdx) |
| |
| std::string | AnaTypeToString (const EAnaType2017 ana) |
| |
| std::vector< const ISyst * > | getAna2017LargeXsecSysts (const EAnaType2017 ana) |
| |
| std::vector< const ISyst * > | getAna2017SmallXsecSysts (const EAnaType2017 ana) |
| |
| const SummedSyst * | getAna2017SummedSmallXsecSysts (const EAnaType2017 ana) |
| |
| void | AddJointAna2017XSecSysts (std::vector< const ISyst * > &systs, const EAnaType2017 ana, bool smallgenie) |
| |
| void | AddJointAna2017BeamSysts (std::vector< const ISyst * > &systs, const EAnaType2017 ana) |
| |
| void | AddJointAna2017FileSysts (std::vector< const ISyst * > &systs, const EAnaType2017 ana) |
| |
| void | AddJointAna2017NormSysts (std::vector< const ISyst * > &systs, const EAnaType2017 ana) |
| |
| void | AddJointAna2017OtherSysts (std::vector< const ISyst * > &systs, const EAnaType2017 ana) |
| |
| std::vector< const ISyst * > | getAllAna2017Systs (const EAnaType2017 ana, const bool smallgenie) |
| |
| std::string | AnaTypeToString (const EAnaType2018 ana) |
| |
| std::vector< const ISyst * > | getAna2018LargeXsecSysts (const EAnaType2018 ana) |
| |
| void | AddJointAna2018XSecSysts (std::vector< const ISyst * > &systs, const EAnaType2018 ana, bool smallgenie) |
| |
| void | AddJointAna2018BeamSysts (std::vector< const ISyst * > &systs, const EAnaType2018 ana) |
| |
| void | AddJointAna2018FileSysts (std::vector< const ISyst * > &systs, const EAnaType2018 ana, const BeamType2018 beam) |
| |
| void | AddJointAna2018NotCorrelSysts (std::vector< const ISyst * > &systs, const EAnaType2018 ana, const BeamType2018 beam) |
| |
| void | AddJointAna2018OtherSysts (std::vector< const ISyst * > &systs, const EAnaType2018 ana, const BeamType2018 beam) |
| |
| void | AddNonLoadable2018Systs (std::vector< const ISyst * > &systs, const EAnaType2018 ana) |
| |
| void | AddWrongSignSysts (std::vector< const ISyst * > &systs, const EAnaType2018 ana) |
| |
| std::vector< const ISyst * > | getAllAna2018Systs (const EAnaType2018 ana, const bool smallgenie, const BeamType2018 beam, bool isFit) |
| |
| std::vector< const ISyst * > | getAllCPTSysts (const EAnaType2018 ana, const bool smallgenie, const BeamType2018 beam, bool isFit) |
| |
| std::vector< const ISyst * > | getAna2018SmallXsecSysts (const EAnaType2018 ana) |
| |
| const SummedSyst * | getAna2018SummedSmallXsecSysts (const EAnaType2018 ana) |
| |
| std::vector< const ISyst * > | getAna2018NueOnly (const BeamType2018 beam) |
| |
| std::vector< const ISyst * > | getAna2018NumuOnly (const BeamType2018 beam) |
| |
| void | AddJointAna2018NormSysts (std::vector< const ISyst * > &systs, const EAnaType2018 ana=kJointAna2018) |
| |
| std::vector< const ISyst * > | GetSystematics2018 (const TString option) |
| |
| std::vector< ShiDef > | GetShifts2018 (const TString option) |
| |
| std::vector< SNameDef > | GetShiftNames2018 (const TString option) |
| |
| std::vector< const ISyst * > | getAllDirectNumuSysts2018 () |
| |
| std::vector< const ISyst * > | getAllDirectNumuSysts2017 () |
| | Get a vector of all the numu group systs. More...
|
| |
| double | GetBinScaleWS (double nuE=0.) |
| |
| std::vector< const IFitVar * > | getNumuMarginalisedOscParam () |
| |
| std::vector< const IFitVar * > | getNumuMarginalisedBar () |
| |
| std::vector< const IFitVar * > | getNumuMarginalisedNu () |
| |
| MultiVar | constructPng2dVar (const std::function< double(const caf::SRProngProxy *png2d)> &func) |
| |
| MultiVar | constructPng3dVar (const std::function< double(const caf::SRFuzzyKProngProxy *png)> &func) |
| |
| MultiVar | constructCVNPng3dVar (const std::function< double(const caf::SRFuzzyKProngProxy *png)> &func, bool isMuonID) |
| |
| MultiVar | constructBPFPng3dVar (const std::function< double(const caf::SRBpfTrackProxy *bpf)> &func, size_t bpfIdx) |
| |
| const std::vector< std::pair< std::string, Var > > | kSliceVarDefs ({{"coarseTiming", kCoarseTiming},{"lowGain", kLowGain},{"remPngCalE", kRemPngCalE},{"nHit", kNHit},{"calE", SIMPLEVAR(slc.calE)},{"orphCalE", SIMPLEVAR(vtx.elastic.fuzzyk.orphCalE)}}) |
| |
| const std::vector< std::pair< std::string, MultiVar > > | kPng2dVarDefs ({SIMPLE_PNG2D_VAR(dir.x), SIMPLE_PNG2D_VAR(dir.y), SIMPLE_PNG2D_VAR(dir.z), SIMPLE_PNG2D_VAR(nhit), SIMPLE_PNG2D_VAR(nhitx), SIMPLE_PNG2D_VAR(nhity), SIMPLE_PNG2D_VAR(nplane), SIMPLE_PNG2D_VAR(len), SIMPLE_PNG2D_VAR(weightedCalE), SIMPLE_PNG2D_VAR(calE), SIMPLE_PNG2D_VAR(start.x), SIMPLE_PNG2D_VAR(start.y),}) |
| |
| const std::vector< std::pair< std::string, MultiVar > > | kPng3dVarDefs ({SIMPLE_PNG3D_VAR(dir.x), SIMPLE_PNG3D_VAR(dir.y), SIMPLE_PNG3D_VAR(dir.z), SIMPLE_PNG3D_VAR(start.x), SIMPLE_PNG3D_VAR(start.y), SIMPLE_PNG3D_VAR(start.z), SIMPLE_PNG3D_VAR(len), SIMPLE_PNG3D_VAR(weightedCalE), SIMPLE_PNG3D_VAR(calE), SIMPLE_PNG3D_VAR(nhit), SIMPLE_PNG3D_VAR(nhitx), SIMPLE_PNG3D_VAR(nhity), SIMPLE_PNG3D_VAR(nplane), CVN_PNG3D_VAR(cvnpart.muonid, true), CVN_PNG3D_VAR(cvnpart.electronid, false), CVN_PNG3D_VAR(cvnpart.pionid, false), CVN_PNG3D_VAR(cvnpart.protonid, false), CVN_PNG3D_VAR(cvnpart.photonid, false), BPF_PNG3D_VAR(energy, 0), BPF_PNG3D_VAR(overlapE, 0), BPF_PNG3D_VAR(momentum.x, 0), BPF_PNG3D_VAR(momentum.y, 0), BPF_PNG3D_VAR(momentum.z, 0), BPF_PNG3D_VAR(nhit, 0), BPF_PNG3D_VAR(nhitx, 0), BPF_PNG3D_VAR(nhity, 0), BPF_PNG3D_VAR(nplane, 0), BPF_PNG3D_VAR(energy, 1), BPF_PNG3D_VAR(overlapE, 1), BPF_PNG3D_VAR(momentum.x, 1), BPF_PNG3D_VAR(momentum.y, 1), BPF_PNG3D_VAR(momentum.z, 1), BPF_PNG3D_VAR(nhit, 1), BPF_PNG3D_VAR(nhitx, 1), BPF_PNG3D_VAR(nhity, 1), BPF_PNG3D_VAR(nplane, 1), BPF_PNG3D_VAR(energy, 2), BPF_PNG3D_VAR(overlapE, 2), BPF_PNG3D_VAR(momentum.x, 2), BPF_PNG3D_VAR(momentum.y, 2), BPF_PNG3D_VAR(momentum.z, 2), BPF_PNG3D_VAR(nhit, 2), BPF_PNG3D_VAR(nhitx, 2), BPF_PNG3D_VAR(nhity, 2),}) |
| |
| double | NueRecoE_2017FDFit (double rawEM, double rawHA) |
| |
| double | NueRecoE_2018RHCFit (double rawEM, double rawHA) |
| |
| double | NueRecoE_2018FHCFit (double rawEM, double rawHA) |
| |
| double | NueRecoE_2020RHCFit_2D3D (double rawEM, double rawHA) |
| |
| double | NueRecoE_2020RHCFit (double rawEM, double rawHA) |
| |
| double | NueRecoE_2020FHCFit_2D3D (double rawEM, double rawHA) |
| |
| double | NueRecoE_2020FHCFit (double rawEM, double rawHA) |
| |
| double | predict_special_fd_p1_muon_energy (double trkLen) |
| |
| double | predict_special_fd_p2_muon_energy (double trkLen) |
| |
| double | predict_special_fd_p3_muon_energy (double trkLen) |
| |
| double | predict_special_fd_p5_muon_energy (double trkLen) |
| |
| double | predict_special_fd_p1_had_energy (double hadVisE) |
| |
| double | predict_special_fd_p2_had_energy (double hadVisE) |
| |
| double | predict_special_fd_p3_had_energy (double hadVisE) |
| |
| double | predict_special_fd_p5_had_energy (double hadVisE) |
| |
| double | predict_special_nd_p3_act_energy (double ndtrklenact) |
| |
| double | predict_special_nd_p3_cat_energy (double ndtrklencat) |
| |
| double | predict_special_nd_p3_had_energy (double hadVisE) |
| |
| double | predict_special_fd_p1_muon_energy_corr (double trkLen, bool ismc) |
| |
| double | predict_special_fd_p2_muon_energy_corr (double trkLen, bool ismc) |
| |
| double | predict_special_fd_p3_muon_energy_corr (double trkLen, bool ismc) |
| |
| double | predict_special_fd_p5_muon_energy_corr (double trkLen, bool ismc) |
| |
| double | predict_special_fd_p1_had_energy_corr (double hadVisE, bool ismc) |
| |
| double | predict_special_fd_p2_had_energy_corr (double hadVisE, bool ismc) |
| |
| double | predict_special_fd_p3_had_energy_corr (double hadVisE, bool ismc) |
| |
| double | predict_special_fd_p5_had_energy_corr (double hadVisE, bool ismc) |
| |
| double | predict_special_fd_muon_energy (double trkLen, int run, bool ismc) |
| |
| double | predict_special_fd_had_energy (double hadVisE, int run, bool ismc) |
| |
| double | predict_special_nd_act_energy (double ndtrklenact) |
| |
| double | predict_special_nd_cat_energy (double ndtrklencat) |
| |
| double | predict_special_nd_had_energy (double hadVisE) |
| |
| Var | initNumuMuE2020FDpXVar (const std::function< NumuEnergyFunc::prod5_fd_energy_p_func_t > &f) |
| |
| Var | initNumuHadE2020FDpXVar (const std::function< NumuEnergyFunc::prod5_fd_energy_p_func_t > &f) |
| |
| Var | initNumuMuE2020NDpXVar (const std::function< NumuEnergyFunc::prod5_nd_energy_p_func_t > &f_act, const std::function< NumuEnergyFunc::prod5_nd_energy_p_func_t > &f_cat) |
| |
| Var | initNumuHadE2020NDpXVar (const std::function< NumuEnergyFunc::prod5_nd_energy_p_func_t > &f) |
| |
| Var | initNumuMuE2020Var (const std::function< NumuEnergyFunc::prod5_fd_energy_func_t > &f_fd, const std::function< NumuEnergyFunc::prod5_nd_energy_func_t > &f_nd_act, const std::function< NumuEnergyFunc::prod5_nd_energy_func_t > &f_nd_cat) |
| |
| Var | initNumuHadE2020Var (const std::function< NumuEnergyFunc::prod5_fd_energy_func_t > &f_fd, const std::function< NumuEnergyFunc::prod5_nd_energy_func_t > &f_nd) |
| |
| Var | initNumuMuE2018FDpXVar (const std::function< NumuEnergyFunc::prod4_fd_energy_p_func_t > &f) |
| |
| Var | initNumuHadE2018FDpXVar (const std::function< NumuEnergyFunc::prod4_fd_energy_p_func_t > &f) |
| |
| Var | initNumuMuE2018NDpXVar (const std::function< NumuEnergyFunc::prod4_nd_energy_p_func_t > &f_act, const std::function< NumuEnergyFunc::prod4_nd_energy_p_func_t > &f_cat) |
| |
| Var | initNumuHadE2018NDpXVar (const std::function< NumuEnergyFunc::prod4_nd_energy_p_func_t > &f) |
| |
| Var | initNumuMuE2018Var (const std::function< NumuEnergyFunc::prod4_fd_energy_func_t > &f_fd, const std::function< NumuEnergyFunc::prod4_nd_energy_func_t > &f_nd_act, const std::function< NumuEnergyFunc::prod4_nd_energy_func_t > &f_nd_cat) |
| |
| Var | initNumuHadE2018Var (const std::function< NumuEnergyFunc::prod4_fd_energy_func_t > &f_fd, const std::function< NumuEnergyFunc::prod4_nd_energy_func_t > &f_nd) |
| |
| float | TAMuE (double trklen) |
| |
| float | TAGetNDActLen (double trkLenact, double trkLencat) |
| |
| float | TAHadEND (double HadVisE) |
| |
| float | SAMuE (double trkLen) |
| |
| float | SAGetNDCatEffLen (double trkLenCat) |
| |
| float | SAHadEFD (double hadVisE, int run) |
| |
| float | SAHadEND (double hadVisE) |
| |
| double | SAMuEND (double lenact, double lencat, double actE, double tranE, double catE) |
| |
| Var | OverlayVarFromNuTruthVar (const NuTruthVar stv, double _default) |
| |
| void | ResetOscCalcToTemplate (osc::IOscCalcAdjustable *calc, osc::IOscCalcAdjustable *tmp) |
| |
| void | ResetOscCalcToDefault (osc::IOscCalcAdjustable *calc) |
| | Reset calculator to default assumptions for all parameters. More...
|
| |
| osc::IOscCalcAdjustable * | DefaultOscCalc () |
| | Create a new calculator with default assumptions for all parameters. More...
|
| |
| void | ResetOscCalcToDefaultIH (osc::IOscCalcAdjustable *calc) |
| |
| osc::IOscCalcAdjustable * | DefaultOscCalcIH () |
| |
| void | ResetSterileCalcToDefault (osc::OscCalcSterile *calc) |
| | Reset calculator to default assumptions for all parameters. More...
|
| |
| osc::OscCalcSterile * | DefaultSterileCalc (int nflavors) |
| | Create a sterile calculator with default assumptions for all parameters. More...
|
| |
| double | factorial (int x) |
| | There doesn't seem to be a standard header for this. Implement our own. More...
|
| |
| double | PValueToSigma (double p) |
| | Compute the equivalent number of gaussian sigma for a p-value. More...
|
| |
| double | CountingExperimentPValue (int N, double b0, double sigma) |
| | Compute the probability of seeing N or more events. More...
|
| |
| double | CountingExperimentSigma (int N, double b0, double sigma) |
| |
| double | CountingExperimentPValueByLL (int N, double b0, double sigma) |
| |
| double | CountingExperimentSigmaByLL (int N, double b0, double sigma) |
| |
| template<class T , class S > |
| bool | printSeparatedValues (std::ostream &output, const std::vector< T > &values, bool firstValuePrinted, S separator, std::function< void(std::ostream &, const T &)> printValue) |
| |
| std::string | replaceAll (const std::string &str, const std::string &from, const std::string &to) |
| |
| TString | TableNum (float num) |
| | Format numbers for tables, with two nice digits after decimal. More...
|
| |
| TH1 * | DataMCComparison (const Spectrum &data, const Spectrum &mc, EBinType bintype) |
| |
| TH1 * | DataMCComparison (const Spectrum &data, const IPrediction *mc, osc::IOscCalc *calc, const SystShifts &shifts, EBinType bintype) |
| |
| TH1 * | DataMCComparisonAreaNormalized (const Spectrum &data, const Spectrum &mc) |
| |
| TH1 * | DataMCComparisonAreaNormalized (const Spectrum &data, const IPrediction *mc, osc::IOscCalc *calc) |
| |
| TH1 * | DataMCComparisonComponents (const Spectrum &data, const IPrediction *mc, osc::IOscCalc *calc) |
| | Plot MC broken down into flavour components, overlayed with data. More...
|
| |
| void | DataMCRatio (const Spectrum &data, const IPrediction *mc, osc::IOscCalc *calc, double miny=0, double maxy=3) |
| | Plot data/MC ratio for the given spectrum. Normalize MC to Data by POT. More...
|
| |
| void | DataMCRatio (const Spectrum &data, const Spectrum &mc, double miny=0, double maxy=3) |
| | Plot data/MC ratio for the given spectrum. Normalize MC to Data by POT. More...
|
| |
| void | DataMCAreaNormalizedRatio (const Spectrum &data, const IPrediction *mc, osc::IOscCalc *calc, double miny=0, double maxy=3) |
| | Plot data/MC ratio for the given spectrum. Normalize MC to Data by area. More...
|
| |
| void | DataMCAreaNormalizedRatio (const Spectrum &data, const Spectrum &mc, double miny=0, double maxy=3) |
| | Plot data/MC ratio for the given spectrum. Normalize MC to Data by area. More...
|
| |
| void | RatioPlot (const Spectrum &data, const Spectrum &expected, const Spectrum &fit, double miny=0, double maxy=1.2) |
| | Plot data/expected, compared with fit/expected. More...
|
| |
| void | GetSystBands (osc::IOscCalc *calc, const IPrediction *pred, std::vector< const ISyst * > systs, std::vector< TH1 * > &hUps, std::vector< TH1 * > &hDns, double pot, Flavors::Flavors_t flav, Current::Current_t curr, Sign::Sign_t sign) |
| |
| void | GetBFSystBands (osc::IOscCalc *calc, const IPrediction *pred, std::vector< const ISyst * > systs, const SystShifts &bfshifts, std::vector< TH1 * > &hUps, std::vector< TH1 * > &hDns, double pot, Flavors::Flavors_t flav, Current::Current_t curr, Sign::Sign_t sign) |
| |
| TGraphAsymmErrors * | PlotWithSystErrorBand (IPrediction *pred, const std::vector< const ISyst * > &systs, osc::IOscCalc *calc, double pot, int col=-1, int errCol=-1, float headroom=1.3, bool newaxis=true, EBinType bintype=kBinContent, double alpha=1) |
| | Plot prediction with +/-1sigma error band. More...
|
| |
| TGraphAsymmErrors * | PlotWithSystErrorBand (const Spectrum &nominal, const std::vector< Spectrum > &upShifts, const std::vector< Spectrum > &downShifts, double pot, int col=-1, int errCol=-1, float headroom=1.3, bool newaxis=true, EBinType bintype=kBinContent, double alpha=1) |
| | Plot prediction with error band. More...
|
| |
| TGraphAsymmErrors * | PlotWithSystErrorBand (TH1 *&nom, std::vector< TH1 * > &ups, std::vector< TH1 * > &dns, int col, int errCol, float headroom, bool newaxis, double alpha) |
| |
| void | PlotWithAreaSystErrorBand (IPrediction *pred, const std::vector< const ISyst * > &systs, osc::IOscCalc *calc, double pot, int col=-1, int errCol=-1, float headroom=1.3, bool newaxis=true, EBinType bintype=kBinContent) |
| | Plot prediction with +/-1sigma shape-only error band. More...
|
| |
| void | PlotWithAreaSystErrorBand (const Spectrum &nominal, std::vector< Spectrum > upShifts, std::vector< Spectrum > downShifts, double pot, int col=-1, int errCol=-1, float headroom=1.3, bool newaxis=true, EBinType bintype=kBinContent) |
| | Plot prediction with error band where syst(s) is (are) shape-only. More...
|
| |
| void | PlotWithSystErrorBandTwoPreds (const Spectrum &nominal, const std::vector< Spectrum > &upShifts, const std::vector< Spectrum > &downShifts, const Spectrum &nominal2, const std::vector< Spectrum > &upShifts2, const std::vector< Spectrum > &downShifts2, double pot, int col=-1, int errCol=-1, float headroom=1.3, bool newaxis=true, EBinType bintype=kBinContent) |
| | Plot two different predictions with +/-1sigma shape-only error bands. More...
|
| |
| TGraphAsymmErrors * | PlotWithSystErrorBand_Quant (const int quant, IPrediction *pred, const std::vector< const ISyst * > &systs, osc::IOscCalc *calc, double pot, int col, int errCol, float maxy, bool newaxis) |
| |
| TGraphAsymmErrors * | PlotWithSystErrorBand_Quant (const int quant, const Spectrum &nominal, const std::vector< Spectrum > &upShifts, const std::vector< Spectrum > &downShifts, double pot, int col, int errCol, float maxy, bool newaxis) |
| |
| TGraphAsymmErrors * | PlotWithSystErrorBand_Quant (const int quant, TH1 *&nom, std::vector< TH1 * > &ups, std::vector< TH1 * > &dns, int col, int errCol, float maxy, bool newaxis) |
| |
| THStack * | ToTHStack (const std::vector< std::pair< const Spectrum &, Color_t >> &s, double pot) |
| | Can call like ToTHStack({{h1, kRed}, {h2, kBlue}}, pot) More...
|
| |
| double | PointDistanceToBox (double x, double y, double x0, double y0, double x1, double y1) |
| | Helper for AutoPlaceLegend. More...
|
| |
| TLegend * | AutoPlaceLegend (double dx, double dy, double yPin=-1) |
| | Create a legend, maximizing distance from all histograms. More...
|
| |
| void | ErrorBarChart (const std::map< std::string, std::pair< double, double >> &systErrors, const std::pair< double, double > &statErr=std::make_pair(0., 0.), const std::string &label="Error") |
| | Make a simple plot of relative size of different errors. More...
|
| |
| void | CountingExperimentErrorBarChart (const std::map< std::string, double > &systs, double statErr=0, bool bkgdOrSig=false, bool shortchart=false) |
| | Make a simple plot of relative size of different errors. More...
|
| |
| TGraphAsymmErrors * | GraphWithPoissonErrors (const TH1 *h, bool noErrorsXaxis=false, bool drawEmptyBins=true) |
| | Calculate statistical errors appropriate for small Poisson numbers. More...
|
| |
| TGraphAsymmErrors * | GraphWithPoissonErrors2 (const TH1 *h, const TH1 *h2, bool noErrorsXaxis=false, bool drawEmptyBins=true) |
| | Same as above but use a reference histogram to determine which empty bins to draw. More...
|
| |
| TGraph * | graphAsymmErrorScaled (TH1 *histScaled, TH1 *hist, double overallScale) |
| |
| TGraph * | graphAsymmErrorWithBkgScaled (TH1 *data, TH1 *bkgd, double overallScale) |
| |
| TGraph * | RatioAsymmError (TH1 *data, TH1 *pred) |
| |
| TGraph * | RatioAsymmErrorScaled (TH1 *data, TH1 *pred, double overallScale) |
| |
| TGraph * | RatioAsymmErrorWithBkg (TH1 *data, TH1 *pred, TH1 *bkgd) |
| |
| TGraph * | RatioAsymmErrorWithBkgScaled (TH1 *data, TH1 *pred, TH1 *bkgd, double overallScale) |
| |
| TGraph * | ShadeBetweenHistograms (TH1 *hmin, TH1 *hmax) |
| |
| TGraphAsymmErrors * | ProfileQuantile (const TH2 *hist, const std::string &axis_name, const std::string &graph_name="", const std::pair< double, double > &quantile_divisions={0.159, 0.841}) |
| | Calculate profile with error bars corresponding to specified quantiles of a 2D distribution (by default, 68% coverage) More...
|
| |
| void | drawBFSingle (double bfSin, double bfDm, Color_t color, Style_t marker, double size) |
| | Draw a single BF point. More...
|
| |
| void | drawBFMirror (double bfSin, double bfDm, Color_t color, Style_t marker, double size) |
| | Draw best fit at both octants. Truth for neutrinos, not sure about antineutrinos. More...
|
| |
| void | MakeHistCanvasReady_Quant (const int quant, TH1 *hist, double ymax) |
| |
| void | PimpHist (TH1 *hist, Style_t linestyle, Color_t linecolor, int linewidth, Style_t markerstyle, Color_t markercolor, double markersize) |
| | Pimp histogram once and for all. More...
|
| |
| void | SplitCanvas (double ysplit, TPad *&p1, TPad *&p2) |
| | Split the current pad into two vertically stacked pieces, suitable for ratio plots and so on. More...
|
| |
| void | SplitCanvasQuant (TCanvas *&canvas, TPad *&pad1, TPad *&pad2, TPad *&pad3, TPad *&pad4) |
| |
| void | CenterTitles (TH1 *histo) |
| |
| bool | SortSystsName (const ISyst *systA, const ISyst *systB) |
| |
| TH1 * | PlotSystShifts (const SystShifts &shifts, bool sortName) |
| |
| TGraph * | JoinGraphs (TGraph *a, TGraph *b, int fillcol=0) |
| | Join graphs and set a fill color. Useful for contours. More...
|
| |
| TGraph * | ExtendGraphToTop (TGraph *g, int col, double xmin, double xmax, double y) |
| |
| TPaveText * | DrawBeamLabel (bool isFHC=true) |
| | Put the standardized beam label in the left corner of the active canvas. More...
|
| |
| TPaveText * | DrawQuantLabel (int quant) |
| |
| const std::string | ECAFTypeToString (ECAFType type) |
| |
| void | SetPaletteBlueRedWhite () |
| |
| void | SetPaletteBlueRedCyclic () |
| |
| void | SetPaletteWhiteBlueDark () |
| |
| void | SetPaletteFernandaSunset () |
| |
| void | SetPaletteLiudmilaViolet () |
| |
| void | SetPaletteHeroBlue () |
| |
| void | SetPaletteFlamenco () |
| |
| void | SetPaletteErikaTeal () |
| |
| Binning | TrueEnergyBins () |
| | Default true-energy bin edges. More...
|
| |
| std::vector< double > | TrueEnergyBinCenters () |
| | No entries for underflow or overflow. More...
|
| |
| Binning | TrueLOverTrueEBins () |
| | Default trueL Over true-energy bin edges. More...
|
| |
| Cut | CutFromNuTruthCut (const NuTruthCut &stc) |
| |
| void | gdb_backtrace () |
| |
| void | handle_terminate () |
| |
| void | handle_signal (int sig, siginfo_t *, void *) |
| |
| Eigen::MatrixXd | EigenMatrixXdFromTMatrixD (const TMatrixD *mat) |
| |
| TMatrixD | TMatrixDFromEigenMatrixXd (const Eigen::MatrixXd &mat) |
| |
| double | LogLikelihood (const Eigen::ArrayXd &exp, const Eigen::ArrayXd &obs, bool useOverflow=false) |
| | The log-likelihood formula from the PDG. More...
|
| |
| double | Chi2CovMx (const Eigen::ArrayXd &e, const Eigen::ArrayXd &o, const Eigen::MatrixXd &covmxinv) |
| |
| Eigen::MatrixXd | SymmMxInverse (const Eigen::MatrixXd &mx) |
| |
| template<class T , class U > |
| void | MakeTextListFileHelper (const T &source, const std::vector< Cut > &cut, const std::vector< std::string > &output, const std::vector< U > &floatVars, const std::vector< U > &intVars, const SpillCut *spillCut) |
| |
| void | MakeTextListFile (const std::string &wildcard, const std::vector< Cut > &cut, const std::vector< std::string > &output, const std::vector< const Var * > &floatVars, const std::vector< const Var * > &intVars, const SpillCut *spillCut=0) |
| | Make a file listing all the events passing the specified cut. More...
|
| |
| void | MakeTextListFile (const std::vector< std::string > &fnames, const std::vector< Cut > &cut, const std::vector< std::string > &output, const std::vector< const Var * > &floatVars, const std::vector< const Var * > &intVars, const SpillCut *spillCut=0) |
| | Make a file listing all the events passing the specified cut. More...
|
| |
| void | MakeTextListFile (const std::string &wildcard, const std::vector< Cut > &cut, const std::vector< std::string > &output, const std::vector< const MultiVar * > &multivars={}, const SpillCut *spillCut=0) |
| | Make a file listing multi-var values. More...
|
| |
| template<class T > |
| void | MakeEventListFileHelper (const T &source, const std::vector< Cut > &cuts, const std::vector< std::string > &outputs, bool includeSliceIndex, bool includeSliceTime, bool includeCycleNumber, const SpillCut *spillCut, bool includeBatchNumber) |
| |
| void | MakeEventListFile (const std::string &wildcard, const std::vector< Cut > &cuts, const std::vector< std::string > &outputs, bool includeSliceIndex=false, bool includeSliceTime=false, bool includeCycleNumber=false, const SpillCut *spillCut=0, bool includeBatchNumber=false) |
| | Make a set of files listing all the events passing cuts One output file is created for each cut in the cuts vector. More...
|
| |
| void | MakeEventListFile (const std::vector< std::string > &fnames, const std::vector< Cut > &cuts, const std::vector< std::string > &outputs, bool includeSliceIndex=false, bool includeSliceTime=false, bool includeCycleNumber=false, const SpillCut *spillCut=0, bool includeBatchNumber=false) |
| | Make a set of files listing all the events passing cuts One output file is created for each cut in the cuts vector. More...
|
| |
| void | MakeEventListFile (const std::string &wildcard, const Cut &cut, const std::string &output, bool includeSliceIndex=false, bool includeSliceTime=false, bool includeCycleNumber=false, const SpillCut *spillCut=0, bool includeBatchNumber=false) |
| | Make a file listing all the events passing the specified cut. More...
|
| |
| void | MakeEventListFile (const std::vector< std::string > &fnames, const Cut &cut, const std::string &output, bool includeSliceIndex=false, bool includeSliceTime=false, bool includeCycleNumber=false, const SpillCut *spillCut=0, bool includeBatchNumber=false) |
| | Make a set of files listing all the events passing cuts One output file is created for each cut in the cuts vector. More...
|
| |
| void | MakeEventTTreeFile (const std::string &wildcard, const std::string &output, const std::vector< std::pair< std::string, Cut >> &cuts, const std::vector< std::pair< std::string, Var >> &floatVars, const std::vector< std::pair< std::string, Var >> &intVars={}, const SpillCut *spillCut=0) |
| | Make a ROOT file listing all the events passing the specified cut. More...
|
| |
| void | MakeTextListFile (const std::string &wildcard, const std::vector< Cut > &cut, const std::vector< std::string > &output, const std::vector< const Var * > &floatVars, const SpillCut *spillCut=0) |
| |
| void | MakeTextListFile (const std::vector< std::string > &fnames, const std::vector< Cut > &cut, const std::vector< std::string > &output, const std::vector< const Var * > &floatVars, const SpillCut *spillCut=0) |
| |
| void | POTPlusPercent (std::ostream &os, double pot, double denom) |
| |
| void | ClearMultiNuInfo (caf::StandardRecord *sr) |
| |
| void | ClearPrimaryInfo (caf::StandardRecord *sr) |
| |
| void | ClearMichelTruthInfo (caf::StandardRecord *sr) |
| |
| void | ReduceForNueDecaf (caf::StandardRecord *sr) |
| |
| void | ReduceForNusDecaf (caf::StandardRecord *sr) |
| |
| void | ReduceForNumuDecaf (caf::StandardRecord *sr) |
| |
| void | ClearReweightInfo (caf::StandardRecord *sr) |
| |
| void | ClearKalmanInfo (caf::StandardRecord *sr) |
| |
| void | ClearCosmicTrackInfo (caf::StandardRecord *sr) |
| |
| void | ClearWindowTrackInfo (caf::StandardRecord *sr) |
| |
| void | ClearDiscreteTrackInfo (caf::StandardRecord *sr) |
| |
| void | ClearTrackInfo (caf::StandardRecord *sr) |
| |
| void | ClearSecondaryTrackInfo (caf::StandardRecord *sr) |
| |
| void | ClearElasticArmsInfo (caf::StandardRecord *sr) |
| |
| void | ClearProngInfo (caf::StandardRecord *sr) |
| | 2D and 3D More...
|
| |
| void | Clear2DProngInfo (caf::StandardRecord *sr) |
| |
| void | ClearHoughVertexInfo (caf::StandardRecord *sr) |
| |
| void | ResetBeamInfo (caf::StandardRecord *sr) |
| |
| void | ResetNumuEnergy (caf::StandardRecord *sr) |
| |
| void | ResetBPFEnergy (caf::StandardRecord *sr) |
| |
| void | ResetLEMInfo (caf::StandardRecord *sr) |
| |
| void | ResetLIDInfo (caf::StandardRecord *sr) |
| |
| void | ResetRVPInfo (caf::StandardRecord *sr) |
| |
| void | ResetCosRejInfo (caf::StandardRecord *sr) |
| |
| void | ResetNueCosRejInfo (caf::StandardRecord *sr) |
| |
| void | ResetContainInfo (caf::StandardRecord *sr) |
| |
| void | ResetNueEnergyInfo (caf::StandardRecord *sr) |
| |
| void | ClearKalman2DInfo (caf::StandardRecord *sr) |
| |
| void | ClearShowerLIDRecoInfo (caf::StandardRecord *sr) |
| |
| void | ClearShowerLIDPIDInfo (caf::StandardRecord *sr) |
| |
| TGraph * | MakeGraph (const std::string &wildcard, const Cut &cut, const Var &VarX, const Var &VarY, const SpillCut *spillCut=0) |
| | Get a graph with two variables when a histogram is not the best choice. More...
|
| |
| HistAxis | HistAxisFromNuTruthHistAxis (NuTruthHistAxis ntha, double _default) |
| |
| stan::math::var | StanExp (const stan::math::var &x) |
| |
| stan::math::var | StanLog (const stan::math::var &x) |
| |
| template<> |
| std::unique_ptr< osc::IOscCalc > | LoadFrom< osc::IOscCalc > (TDirectory *dir, const std::string &name) |
| |
| template<> |
| std::unique_ptr< osc::IOscCalcAdjustable > | LoadFrom< osc::IOscCalcAdjustable > (TDirectory *topdir, const std::string &name) |
| |
| template<> |
| void | SaveTo (const osc::IOscCalc &x, TDirectory *dir, const std::string &name) |
| |
| template<class T > |
| std::unique_ptr< T > | LoadFrom (TDirectory *dir, const std::string &label) |
| |
| template<> |
| std::unique_ptr< IDecomp > | LoadFrom< IDecomp > (TDirectory *dir, const std::string &label) |
| |
| template<> |
| std::unique_ptr< IExtrap > | LoadFrom< IExtrap > (TDirectory *dir, const std::string &label) |
| |
| template<> |
| std::unique_ptr< IPrediction > | LoadFrom< IPrediction > (TDirectory *dir, const std::string &label) |
| |
| template<> |
| std::unique_ptr< IExperiment > | LoadFrom< IExperiment > (TDirectory *dir, const std::string &label) |
| |
| template<> |
| std::unique_ptr< ModularExtrapComponent > | LoadFrom< ModularExtrapComponent > (TDirectory *dir, const std::string &label) |
| |
| template<> |
| std::unique_ptr< IBkgdEstimator > | LoadFrom< IBkgdEstimator > (TDirectory *dir, const std::string &label) |
| |
| template<class T > |
| void | SaveTo (const T &x, TDirectory *dir, const std::string &label) |
| |
| template<class T > |
| std::unique_ptr< T > | LoadFromFile (const std::string &fname, const std::string &label) |
| |
| template<class T > |
| void | SaveToFile (const T &x, const std::string &fname, const std::string &label) |
| |
| Eigen::ArrayXd | ToEigenSterile (osc::IOscCalc *calc, int from, int to) |
| | Helper for constructors. More...
|
| |
| template<class T > |
| Eigen::Array< T, Eigen::Dynamic, 1 > | ToEigen (osc::_IOscCalc< T > *calc, int from, int to) |
| | Helper for constructors. More...
|
| |
| unsigned int | PeriodFromRunFD (int run) |
| | : Helper function to compute the period given a run number for the FD. More...
|
| |
| unsigned int | PeriodFromRunND (int run) |
| | : Helper function to compute the period given a run number for the ND. More...
|
| |
| bool | CheckVal (double val, const char *detail) |
| |
| stan::math::var | LogLikelihood (const Eigen::ArrayXstan &exp, const Eigen::ArrayXd &obs) |
| | Variant that handles the prediction in the form of Stan vars. More...
|
| |
| std::vector< SystShifts > | GetSystShiftsMultiverse (const std::vector< std::pair< const ISyst *, SystMode > > &systConfigs, const int nUniverses, const int seed) |
| |
| std::string | UniqueName () |
| | Return a different string each time, for creating histograms. More...
|
| |
| std::unique_ptr< TMatrixD > | CalcCovMx (const std::vector< TArrayD * > &binSets, int firstBin=0, int lastBin=-1) |
| | Compute bin-to-bin covariance matrix from a collection of sets of bin contents. More...
|
| |
| double | LogLikelihood (const TH1 *exp, const TH1 *obs, bool useOverflow=false) |
| | The log-likelihood formula from the PDG. More...
|
| |
| TH2F * | ExpandedHistogram (const std::string &title, int nbinsx, double xmin, double xmax, bool xlog, int nbinsy, double ymin, double ymax, bool ylog) |
| | Internal helper for Surface and FCSurface. More...
|
| |
| std::string | FindPackageDir (std::string Dir) |
| |
| std::string | FindCAFAnaDir () |
| |
| std::vector< std::string > | LoadFileList (const std::string &listfile) |
| | Read list of input files from a text file, one per line. More...
|
| |
| std::map< std::string, std::string > | GetCAFMetadata (TDirectory *dir) |
| | Extract map of metadata parameters from a CAF file. More...
|
| |
| void | CombineMetadata (std::map< std::string, std::string > &base, const std::map< std::string, std::string > &add, std::set< std::string > &mask) |
| | base += add More...
|
| |
| void | WriteCAFMetadata (TDirectory *dir, const std::map< std::string, std::string > &meta) |
| | Write map of metadata parameters into a CAF file. More...
|
| |
| TVector3 | NuMIBeamDirection (caf::Det_t det) |
| | Average direction of NuMI neutrinos in a given detector This function is a copy of geo::GeometryBase::NuMIBeamDirection () Any changes made to that function must be propagated to here. More...
|
| |
| bool | RunningOnGrid () |
| | Is this a grid (condor) job? More...
|
| |
| size_t | Stride (bool allow_default=true) |
| | Value passed to –stride, or 1 if not specified. More...
|
| |
| size_t | Offset (bool allow_default=true) |
| | Value passed to –offset, or 0 if not specified. More...
|
| |
| int | Limit () |
| | Value passed to –limit, or -1 if not specified. More...
|
| |
| size_t | JobNumber () |
| | What's the process number for a grid job? More...
|
| |
| size_t | NumJobs () |
| |
| std::size_t | Hash (const std::vector< std::size_t > &vals) |
| | Generate a unique hash from a sequence of integers. More...
|
| |
| std::size_t | Hash (const caf::SRSpillProxy *sr) |
| | Generate a unique hash for a SRSpill (run/subrun/event combination) More...
|
| |
| std::size_t | Hash (const caf::SRProxy *sr) |
| | Generate a unique hash for a StandardRecord (run/subrun/cycle/event/slice combination) More...
|
| |
| template<typename T , typename U , typename std::enable_if_t< std::is_convertible_v< double, T > &&std::is_convertible_v< double, U >, int > = 0> |
| decltype(T(0)-U(0)) | LogLikelihood (T exp, U obs) |
| | The log-likelihood formula for a single bin. More...
|
| |
| bool | SAMDefinitionExists (const std::string &def) |
| |
| Var | VarFromNuTruthVar (const NuTruthVar &stv, double _default) |
| |
| Var | Constant (double c) |
| | Use to weight events up and down by some factor. More...
|
| |
| std::pair< int, int > | calcFirstLastLivePlane (int plane, std::bitset< 14 > binary, caf::Det_t det) |
| |
| bool | PassesPreselFunc (const caf::SRProxy *sr) |
| | Helper for kPassesPresel. More...
|
| |
| int | PeriodFromHeader (const caf::SRHeaderProxy &hdr) |
| |
| int | PeriodFromNeutrino (const caf::SRNeutrinoProxy *truth) |
| |
| const SpillCut | kStandardDQCuts_FD_Prod4Motivated (Prod4DQFailCheck{}) |
| |
| void | CleanSpillQualityInfo (caf::SRSpill *spill, const caf::SRSpillProxy *spillProxy) |
| |
| Cut | CVNVetoOverlapWindowCut (int tlo, int thi) |
| | Apply a time window plus additionally cut the 1usec at the start/end of CVNVeto windows, while correctly computing livetime. More...
|
| |
| Cut | WindowCut_FD_MR (int tlo, int thi) |
| |
| const Cut | kHasNu ([](const caf::SRProxy *sr){if(sr->mc.nnu==0) return false;assert(sr->mc.nnu==1);return true;}) |
| |
| const Cut | kIsSig (CCFlavSel(12, 14)) |
| | Select CC  . More...
|
| |
| const Cut | kIsNumuCC (CCFlavSel(14, 14)) |
| | Select CC  . More...
|
| |
| const Cut | kIsBeamNue (CCFlavSel(12, 12)) |
| | Select CC  . More...
|
| |
| const Cut | kIsNumuApp (CCFlavSel(14, 12)) |
| | Select CC  . More...
|
| |
| const Cut | kIsTauFromMu (CCFlavSel(16, 14)) |
| | Select CC  . More...
|
| |
| const Cut | kIsTauFromE (CCFlavSel(16, 12)) |
| | Select CC  . More...
|
| |
| | REGISTER_LOADFROM ("CheatDecomp", IDecomp, CheatDecomp) |
| |
| | REGISTER_LOADFROM ("FakeDecomp", IDecomp, FakeDecomp) |
| |
| | REGISTER_LOADFROM ("NCDecomp", IDecomp, NCDecomp) |
| |
| | REGISTER_LOADFROM ("ProportionalDecomp", IDecomp, ProportionalDecomp) |
| |
| | REGISTER_LOADFROM ("TwoSampleDecomp", IDecomp, TwoSampleDecomp) |
| |
| const AtmConstraint * | T2KAtmConstraint () |
| | Constraint from T2K's Oct 31, 2014 paper, arXiv 1410.1532v1. More...
|
| |
| const AtmConstraint * | MINOSAtmConstraint () |
| |
| | REGISTER_LOADFROM ("CountingExperiment", IExperiment, CountingExperiment) |
| |
| const Dmsq32Constraint | kDmsq32ConstraintPDG2015 (2.44e-3, 0.06e-3, 2.49e-3, 0.06e-3) |
| |
| const Dmsq32Constraint | kDmsq32ConstraintPDG2017 (2.45e-3, 0.05e-3, 2.52e-3, 0.05e-3) |
| |
| const Dmsq32Constraint | kDmsq32ConstraintPDG2019 (2.444e-3, 0.034e-3, 2.55e-3, 0.04e-3) |
| |
| | REGISTER_LOADFROM ("MultiExperiment", IExperiment, MultiExperiment) |
| |
| | REGISTER_LOADFROM ("ReactorExperiment", IExperiment, ReactorExperiment) |
| |
| const ReactorExperiment * | DayaBayConstraint2014 () |
| | A ReactorExperiment initialized with the Nu2014 Daya Bay constraints. More...
|
| |
| const ReactorExperiment * | WorldReactorConstraint2015 () |
| | Weighted average of all experiments as of first nue paper writing. More...
|
| |
| const ReactorExperiment * | WorldReactorConstraint2016 () |
| | Updated value for SecondAna based on the latest PDG. More...
|
| |
| const ReactorExperiment * | WorldReactorConstraint2017 () |
| | Reactor constraint from PDG 2017. More...
|
| |
| const ReactorExperiment * | ReactorConstraintNuFit2018nu () |
| | Reactor constraint from NuFit 4.0 2018 CPT nu. More...
|
| |
| const ReactorExperiment * | ReactorConstraintNuFit2018bar () |
| | Reactor constraint from NuFit 4.0 2018 CPT bar. More...
|
| |
| const ReactorExperiment * | WorldReactorConstraint2019 () |
| | Reactor constraint from PDG 2019. More...
|
| |
| | REGISTER_LOADFROM ("SingleSampleExperiment", IExperiment, SingleSampleExperiment) |
| |
| | REGISTER_LOADFROM ("SolarConstraints", IExperiment, SolarConstraints) |
| |
| const Ssth23Constraint | kSsth23ConstraintNumu2016 (0.406, 0.029, 0.022, 0.621, 0.022, 0.029) |
| |
| const Ssth23Constraint | kSsth23ConstraintPDG2015 (0.514, 0.055, 0.056) |
| |
| const Ssth23Constraint | kSsth23ConstraintMinos2014 (0.41, 0.26/1.64, 0.06/1.64) |
| |
| const Ssth23Constraint | kSsth23ConstraintPDG2017 (0.51, 0.04, 0.04) |
| |
| | REGISTER_LOADFROM ("ModularExtrap", IExtrap, ModularExtrap) |
| |
| | REGISTER_LOADFROM ("TrivialExtrap", IExtrap, TrivialExtrap) |
| |
| double | SimpleFOM (const Spectrum &obs, const Spectrum &unosc, double pot=0) |
| | Figure-of-merit with no systematics, for binned data. More...
|
| |
| TGraph * | Profile (const IExperiment *expt, osc::IOscCalcAdjustable *calc, const IFitVar *v, int nbinsx, double minx, double maxx, double minchi=-1, const std::vector< const IFitVar * > &profVars={}, const std::vector< const ISyst * > &profSysts={}, const SeedList &seedPts=SeedList(), const std::vector< SystShifts > &systsSeedPts={}, std::map< const IFitVar *, TGraph * > &profVarsMap=empty_vars_map, std::map< const ISyst *, TGraph * > &systsMap=empty_syst_map, MinuitFitter::FitOpts opts=MinuitFitter::kNormal) |
| |  scan in one variable, profiling over all others More...
|
| |
| TGraph * | SqrtProfile (const IExperiment *expt, osc::IOscCalcAdjustable *calc, const IFitVar *v, int nbinsx, double minx, double maxx, double minchi=-1, std::vector< const IFitVar * > profVars={}, std::vector< const ISyst * > profSysts={}, const SeedList &seedPts=SeedList(), const std::vector< SystShifts > &systsSeedPts={}, std::map< const IFitVar *, TGraph * > &profVarsMap=empty_vars_map, std::map< const ISyst *, TGraph * > &systsMap=empty_syst_map, MinuitFitter::FitOpts opts=MinuitFitter::kNormal) |
| | Forward to Profile but sqrt the result for a crude significance. More...
|
| |
| TGraph * | Slice (const IExperiment *expt, osc::IOscCalcAdjustable *calc, const IFitVar *v, int nbinsx, double minx, double maxx, double minchi=-1, MinuitFitter::FitOpts opts=MinuitFitter::kNormal) |
| | scan in one variable, holding all others constant More...
|
| |
| TGraph * | SqrtSlice (const IExperiment *expt, osc::IOscCalcAdjustable *calc, const IFitVar *v, int nbinsx, double minx, double maxx, double minchi=-1, MinuitFitter::FitOpts opts=MinuitFitter::kNormal) |
| | Forward to Slice but sqrt the result for a crude significance. More...
|
| |
| TGraph * | FindValley (const IExperiment *expt, osc::IOscCalcAdjustable *calc, const IFitVar &scanVar, const IFitVar &fitVar, int nbinsx, double xmin, double xmax, const std::vector< const IFitVar * > &profVars={}, const std::vector< const ISyst * > &profSysts={}, const SeedList &seedPts=SeedList(), const std::vector< SystShifts > &systsSeedPts={}, bool transpose=false, MinuitFitter::FitOpts opts=MinuitFitter::kNormal) |
| | Find the minimum in one variable as a function of another. More...
|
| |
| std::vector< double > | FindCurveCrossings (TGraph *g, double critVal) |
| | Intended for use on the output of Profile. More...
|
| |
| TH2 * | Gaussian68Percent2D (const FrequentistSurface &s) |
| | Up-value surface for 68% confidence in 2D in gaussian approximation. More...
|
| |
| TH2 * | Gaussian90Percent2D (const FrequentistSurface &s) |
| | Up-value surface for 90% confidence in 2D in gaussian approximation. More...
|
| |
| TH2 * | Gaussian95Percent2D (const FrequentistSurface &s) |
| | Up-value surface for 95% confidence in 2D in gaussian approximation. More...
|
| |
| TH2 * | Gaussian2Sigma2D (const FrequentistSurface &s) |
| | Up-value surface for 2 sigma confidence in 2D in gaussian approximation. More...
|
| |
| TH2 * | Gaussian99Percent2D (const FrequentistSurface &s) |
| | Up-value surface for 99% confidence in 2D in gaussian approximation. More...
|
| |
| TH2 * | Gaussian3Sigma2D (const FrequentistSurface &s) |
| | Up-value surface for 3 sigma confidence in 2D in gaussian approximation. More...
|
| |
| TH2 * | Gaussian68Percent1D (const FrequentistSurface &s) |
| | Up-value surface for 68% confidence in 1D in gaussian approximation. More...
|
| |
| TH2 * | Gaussian90Percent1D (const FrequentistSurface &s) |
| | Up-value surface for 90% confidence in 1D in gaussian approximation. More...
|
| |
| TH2 * | Gaussian95Percent1D (const FrequentistSurface &s) |
| | Up-value surface for 95% confidence in 1D in gaussian approximation. More...
|
| |
| TH2 * | Gaussian2Sigma1D (const FrequentistSurface &s) |
| | Up-value surface for 2 sigma confidence in 1D in gaussian approximation. More...
|
| |
| TH2 * | Gaussian99Percent1D (const FrequentistSurface &s) |
| | Up-value surface for 99% confidence in 1D in gaussian approximation. More...
|
| |
| TH2 * | Gaussian3Sigma1D (const FrequentistSurface &s) |
| | Up-value surface for 3 sigma confidence in 1D in gaussian approximation. More...
|
| |
| TH2 * | Flat (double level, const ISurface &s) |
| | Helper function for the gaussian approximation surfaces. More...
|
| |
| stan::math::var | PriorUniformInFitVar (const stan::math::var &, const osc::IOscCalcAdjustableStan *) |
| | Prior uniform in the variable that is being fitted. More...
|
| |
| std::function< stan::math::var(const stan::math::var &, const osc::IOscCalcAdjustableStan *)> | TopHatPriorInFitVar (double hatCenter, double hatWidth, double transitionFracWidth) |
| |
| stan::math::var | GaussianPriorDm32Scaled (const stan::math::var &dm32, const osc::IOscCalcAdjustableStan *) |
| |
| stan::math::var | UniformTh23Prior_FitSS2Th23 (const stan::math::var &ss2th23, const osc::IOscCalcAdjustableStan *) |
| | Prior uniform in theta_23 for use when fitting sin^2(2*theta_23). More...
|
| |
| stan::math::var | UniformTh23Prior_FitSSTh23 (const stan::math::var &ssth23, const osc::IOscCalcAdjustableStan *) |
| | Prior uniform in theta_23 for use when fitting sin^2(theta_23) More...
|
| |
| SeedList | RefineSeeds (const SeedList &seeds, const IExperiment *expt, const std::vector< const IFitVar * > &vars, const osc::IOscCalcAdjustable *calc, double dchisq_max=-1) |
| | Refine an initial list of seeds by exploring stats-only fits. More...
|
| |
| std::ostream & | operator<< (std::ostream &os, const Seed &seed) |
| |
| std::ostream & | operator<< (std::ostream &os, const SeedList &seeds) |
| |
| bool | operator< (StanConfig::Verbosity a, StanConfig::Verbosity b) |
| | Allow for comparing them, since kQuiet is definitely "less" verbose than kVerbose. More...
|
| |
| bool | operator> (StanConfig::Verbosity a, StanConfig::Verbosity b) |
| |
| | REGISTER_LOADFROM ("PredictionCombinePeriods", IPrediction, PredictionCombinePeriods) |
| |
| | REGISTER_LOADFROM ("PredictionExtrap", IPrediction, PredictionExtrap) |
| |
| std::string | getNue2018PredFile (std::string beam, bool IsRealNDData=true) |
| |
| std::string | getNumu2018PredFile (std::string beam, bool IsRealNDData=true) |
| |
| std::string | getNumu2018PredVar (std::string extrap, int quant) |
| |
| std::string | getNue2018PredVar (std::string extrap, int sigma=0) |
| |
| | REGISTER_LOADFROM ("PredictionInterp", IPrediction, PredictionInterp) |
| |
| | REGISTER_LOADFROM ("PredictionNoExtrap", IPrediction, PredictionNoExtrap) |
| |
| | REGISTER_LOADFROM ("PredictionNoOsc", IPrediction, PredictionNoOsc) |
| |
| | REGISTER_LOADFROM ("PredictionXSecTuning", IPrediction, PredictionXSecTuning) |
| |
| NuTruthVar & | GetPPFXFluxUnivWgtSmooth_NT (int UnivIdx) |
| |
| BeamSyst * | GetPPFXUnivSyst (int UnivIdx) |
| |
| BeamSyst * | GetPPFXPrincipals (int PCIdx) |
| |
| BeamSyst * | GetFluxPrincipals2018 (int PCIdx) |
| |
| BeamSyst * | GetFluxPrincipals2020 (int PCIdx) |
| |
| BeamSyst * | GetPPFXPrincipalsSBAna (int PCIdx) |
| |
| BeamSyst * | GetFluxPrincipalsND2018 (int PCIdx) |
| |
| BeamSyst * | GetFluxPrincipalsND2020 (int PCIdx) |
| |
| const NuTruthVar | kPPFXFluxCVWgtSmooth_NT (BeamWeightFunc(FindCAFAnaDir()+"/data/beam/ppfx_smooth_multiverse_weights_2020.root","ppfx_cv")) |
| |
| double | CalcMECDoubleGaussEnh (const double q0, const double q3, const double Q2, const MECDoubleGaussEnhParam shift_param, const double shift_sigma, const GaussParams initialParams) |
| |
| const Var | kMECDoubleGaussEnh (const GaussParams initial_params) |
| |
| double | CalcMECDoubleGaussEnhShiftedParam (std::string shift_param, double shift_sigma, const GaussParams initialParams) |
| |
| std::ostream & | operator<< (std::ostream &os, const GaussParams &gp) |
| | utility function for writing GaussParameters out in debug streams or whatever More...
|
| |
| std::vector< const ISyst * > | systs_params_double_gauss_extra (const GaussParams init, std::string suffix) |
| |
| double | Interpolate (double knobval, double knob_weights[6]) |
| |
| void | CheckSystsMatchWithNOvARwgt (const std::vector< const ISyst * > &systsHere, const novarwgt::Tune &novaRwgtTune) |
| | Compare the list of systs made here to what is expected for a given NOvARwgt tune. More...
|
| |
| std::vector< const ISyst * > | getAllXsecNuTruthSysts_2020 () |
| | Get master XSec syst list for 2020 analyses. More...
|
| |
| std::vector< const ISyst * > | getAllXsecSysts_2020 () |
| |
| std::vector< const ISyst * > | getAllXsecNuTruthSysts_2018_base () |
| | Get master XSec syst list for 2018 analyses. More...
|
| |
| std::vector< const ISyst * > | getAllXsecNuTruthSysts_2018 () |
| |
| std::vector< const ISyst * > | getAllXsecNuTruthSysts_2018_RPAFix () |
| |
| std::vector< const ISyst * > | getAllXsecSysts_2018_RPAFix () |
| |
| std::vector< const ISyst * > | getAllXsecSysts_2018 () |
| | Get master XSec syst list for 2018 analyses. More...
|
| |
| std::vector< const ISyst * > | getAllXsecNuTruthSysts_2017 () |
| | Get master XSec syst list for 2017 analyses (NuTruthSyst variant) More...
|
| |
| std::vector< const ISyst * > | getAllXsecSysts_2017 () |
| | Get master XSec syst list for 2017 analyses. More...
|
| |
| const NOvARwgtSyst * | GetGenieKnobSyst (rwgt::ReweightLabel_t knobIdx, std::string altShortName="", std::string altLatexName="") |
| | Convenience function to get a GENIE knob syst. (Allows using the GENIE knob name & description as the default.) More...
|
| |
| const TSpline3 | ND_mu_BPFE_p1 ("ND_mu_BPFE_p1", xknot_ND_mu_BPFE_p1, yknot_ND_mu_BPFE_p1, N_ND_mu_BPFE_p1,"b1,e1", m1_ND_mu_BPFE_p1, m2_ND_mu_BPFE_p1) |
| |
| const TSpline3 | ND_mu_BPFE_p2 ("ND_mu_BPFE_p2", xknot_ND_mu_BPFE_p2, yknot_ND_mu_BPFE_p2, N_ND_mu_BPFE_p2,"b1,e1", m1_ND_mu_BPFE_p2, m2_ND_mu_BPFE_p2) |
| |
| const TSpline3 | ND_mu_BPFE_p3 ("ND_mu_BPFE_p3", xknot_ND_mu_BPFE_p3, yknot_ND_mu_BPFE_p3, N_ND_mu_BPFE_p3,"b1,e1", m1_ND_mu_BPFE_p3, m2_ND_mu_BPFE_p3) |
| |
| const TSpline3 | ND_mu_BPFE_p4 ("ND_mu_BPFE_p4", xknot_ND_mu_BPFE_p4, yknot_ND_mu_BPFE_p4, N_ND_mu_BPFE_p4,"b1,e1", m1_ND_mu_BPFE_p4, m2_ND_mu_BPFE_p4) |
| |
| const TSpline3 | ND_mu_BPFE_p5 ("ND_mu_BPFE_p5", xknot_ND_mu_BPFE_p5, yknot_ND_mu_BPFE_p5, N_ND_mu_BPFE_p5,"b1,e1", m1_ND_mu_BPFE_p5, m2_ND_mu_BPFE_p5) |
| |
| const TSpline3 | ND_mu_BPFE_p6 ("ND_mu_BPFE_p6", xknot_ND_mu_BPFE_p6, yknot_ND_mu_BPFE_p6, N_ND_mu_BPFE_p6,"b1,e1", m1_ND_mu_BPFE_p6, m2_ND_mu_BPFE_p6) |
| |
| const TSpline3 | FD_mu_BPFE_p1 ("FD_mu_BPFE_p1", xknot_FD_mu_BPFE_p1, yknot_FD_mu_BPFE_p1, N_FD_mu_BPFE_p1,"b1,e1", m1_FD_mu_BPFE_p1, m2_FD_mu_BPFE_p1) |
| |
| const TSpline3 | FD_mu_BPFE_p2 ("FD_mu_BPFE_p2", xknot_FD_mu_BPFE_p2, yknot_FD_mu_BPFE_p2, N_FD_mu_BPFE_p2,"b1,e1", m1_FD_mu_BPFE_p2, m2_FD_mu_BPFE_p2) |
| |
| const TSpline3 | FD_mu_BPFE_p3 ("FD_mu_BPFE_p3", xknot_FD_mu_BPFE_p3, yknot_FD_mu_BPFE_p3, N_FD_mu_BPFE_p3,"b1,e1", m1_FD_mu_BPFE_p3, m2_FD_mu_BPFE_p3) |
| |
| const TSpline3 | FD_mu_BPFE_p4 ("FD_mu_BPFE_p4", xknot_FD_mu_BPFE_p4, yknot_FD_mu_BPFE_p4, N_FD_mu_BPFE_p4,"b1,e1", m1_FD_mu_BPFE_p4, m2_FD_mu_BPFE_p4) |
| |
| const TSpline3 | FD_mu_BPFE_p5 ("FD_mu_BPFE_p5", xknot_FD_mu_BPFE_p5, yknot_FD_mu_BPFE_p5, N_FD_mu_BPFE_p5,"b1,e1", m1_FD_mu_BPFE_p5, m2_FD_mu_BPFE_p5) |
| |
| const TSpline3 | FD_mu_BPFE_p6 ("FD_mu_BPFE_p6", xknot_FD_mu_BPFE_p6, yknot_FD_mu_BPFE_p6, N_FD_mu_BPFE_p6,"b1,e1", m1_FD_mu_BPFE_p6, m2_FD_mu_BPFE_p6) |
| |
| const TSpline3 | ND_mu_calE_p1 ("ND_mu_calE_p1", xknot_ND_mu_calE_p1, yknot_ND_mu_calE_p1, N_ND_mu_calE_p1,"b1,e1", m1_ND_mu_calE_p1, m2_ND_mu_calE_p1) |
| |
| const TSpline3 | ND_mu_calE_p2 ("ND_mu_calE_p2", xknot_ND_mu_calE_p2, yknot_ND_mu_calE_p2, N_ND_mu_calE_p2,"b1,e1", m1_ND_mu_calE_p2, m2_ND_mu_calE_p2) |
| |
| const TSpline3 | ND_mu_calE_p3 ("ND_mu_calE_p3", xknot_ND_mu_calE_p3, yknot_ND_mu_calE_p3, N_ND_mu_calE_p3,"b1,e1", m1_ND_mu_calE_p3, m2_ND_mu_calE_p3) |
| |
| const TSpline3 | ND_mu_calE_p4 ("ND_mu_calE_p4", xknot_ND_mu_calE_p4, yknot_ND_mu_calE_p4, N_ND_mu_calE_p4,"b1,e1", m1_ND_mu_calE_p4, m2_ND_mu_calE_p4) |
| |
| const TSpline3 | ND_mu_calE_p5 ("ND_mu_calE_p5", xknot_ND_mu_calE_p5, yknot_ND_mu_calE_p5, N_ND_mu_calE_p5,"b1,e1", m1_ND_mu_calE_p5, m2_ND_mu_calE_p5) |
| |
| const TSpline3 | ND_mu_calE_p6 ("ND_mu_calE_p6", xknot_ND_mu_calE_p6, yknot_ND_mu_calE_p6, N_ND_mu_calE_p6,"b1,e1", m1_ND_mu_calE_p6, m2_ND_mu_calE_p6) |
| |
| const TSpline3 | FD_mu_calE_p1 ("FD_mu_calE_p1", xknot_FD_mu_calE_p1, yknot_FD_mu_calE_p1, N_FD_mu_calE_p1,"b1,e1", m1_FD_mu_calE_p1, m2_FD_mu_calE_p1) |
| |
| const TSpline3 | FD_mu_calE_p2 ("FD_mu_calE_p2", xknot_FD_mu_calE_p2, yknot_FD_mu_calE_p2, N_FD_mu_calE_p2,"b1,e1", m1_FD_mu_calE_p2, m2_FD_mu_calE_p2) |
| |
| const TSpline3 | FD_mu_calE_p3 ("FD_mu_calE_p3", xknot_FD_mu_calE_p3, yknot_FD_mu_calE_p3, N_FD_mu_calE_p3,"b1,e1", m1_FD_mu_calE_p3, m2_FD_mu_calE_p3) |
| |
| const TSpline3 | FD_mu_calE_p4 ("FD_mu_calE_p4", xknot_FD_mu_calE_p4, yknot_FD_mu_calE_p4, N_FD_mu_calE_p4,"b1,e1", m1_FD_mu_calE_p4, m2_FD_mu_calE_p4) |
| |
| const TSpline3 | FD_mu_calE_p5 ("FD_mu_calE_p5", xknot_FD_mu_calE_p5, yknot_FD_mu_calE_p5, N_FD_mu_calE_p5,"b1,e1", m1_FD_mu_calE_p5, m2_FD_mu_calE_p5) |
| |
| const TSpline3 | FD_mu_calE_p6 ("FD_mu_calE_p6", xknot_FD_mu_calE_p6, yknot_FD_mu_calE_p6, N_FD_mu_calE_p6,"b1,e1", m1_FD_mu_calE_p6, m2_FD_mu_calE_p6) |
| |
| const TSpline3 | ND_had_calE_p1 ("ND_had_calE_p1", xknot_ND_had_calE_p1, yknot_ND_had_calE_p1, N_ND_had_calE_p1,"b1,e1", m1_ND_had_calE_p1, m2_ND_had_calE_p1) |
| |
| const TSpline3 | ND_had_calE_p2 ("ND_had_calE_p2", xknot_ND_had_calE_p2, yknot_ND_had_calE_p2, N_ND_had_calE_p2,"b1,e1", m1_ND_had_calE_p2, m2_ND_had_calE_p2) |
| |
| const TSpline3 | ND_had_calE_p3 ("ND_had_calE_p3", xknot_ND_had_calE_p3, yknot_ND_had_calE_p3, N_ND_had_calE_p3,"b1,e1", m1_ND_had_calE_p3, m2_ND_had_calE_p3) |
| |
| const TSpline3 | ND_had_calE_p4 ("ND_had_calE_p4", xknot_ND_had_calE_p4, yknot_ND_had_calE_p4, N_ND_had_calE_p4,"b1,e1", m1_ND_had_calE_p4, m2_ND_had_calE_p4) |
| |
| const TSpline3 | ND_had_calE_p5 ("ND_had_calE_p5", xknot_ND_had_calE_p5, yknot_ND_had_calE_p5, N_ND_had_calE_p5,"b1,e1", m1_ND_had_calE_p5, m2_ND_had_calE_p5) |
| |
| const TSpline3 | ND_had_calE_p6 ("ND_had_calE_p6", xknot_ND_had_calE_p6, yknot_ND_had_calE_p6, N_ND_had_calE_p6,"b1,e1", m1_ND_had_calE_p6, m2_ND_had_calE_p6) |
| |
| const TSpline3 | FD_had_calE_p1 ("FD_had_calE_p1", xknot_FD_had_calE_p1, yknot_FD_had_calE_p1, N_FD_had_calE_p1,"b1,e1", m1_FD_had_calE_p1, m2_FD_had_calE_p1) |
| |
| const TSpline3 | FD_had_calE_p2 ("FD_had_calE_p2", xknot_FD_had_calE_p2, yknot_FD_had_calE_p2, N_FD_had_calE_p2,"b1,e1", m1_FD_had_calE_p2, m2_FD_had_calE_p2) |
| |
| const TSpline3 | FD_had_calE_p3 ("FD_had_calE_p3", xknot_FD_had_calE_p3, yknot_FD_had_calE_p3, N_FD_had_calE_p3,"b1,e1", m1_FD_had_calE_p3, m2_FD_had_calE_p3) |
| |
| const TSpline3 | FD_had_calE_p4 ("FD_had_calE_p4", xknot_FD_had_calE_p4, yknot_FD_had_calE_p4, N_FD_had_calE_p4,"b1,e1", m1_FD_had_calE_p4, m2_FD_had_calE_p4) |
| |
| const TSpline3 | FD_had_calE_p5 ("FD_had_calE_p5", xknot_FD_had_calE_p5, yknot_FD_had_calE_p5, N_FD_had_calE_p5,"b1,e1", m1_FD_had_calE_p5, m2_FD_had_calE_p5) |
| |
| const TSpline3 | FD_had_calE_p6 ("FD_had_calE_p6", xknot_FD_had_calE_p6, yknot_FD_had_calE_p6, N_FD_had_calE_p6,"b1,e1", m1_FD_had_calE_p6, m2_FD_had_calE_p6) |
| |
| const TSpline3 | ND_EM_calE_p1 ("ND_EM_calE_p1", xknot_ND_EM_calE_p1, yknot_ND_EM_calE_p1, N_ND_EM_calE_p1,"b1,e1", m1_ND_EM_calE_p1, m2_ND_EM_calE_p1) |
| |
| const TSpline3 | ND_EM_calE_p2 ("ND_EM_calE_p2", xknot_ND_EM_calE_p2, yknot_ND_EM_calE_p2, N_ND_EM_calE_p2,"b1,e1", m1_ND_EM_calE_p2, m2_ND_EM_calE_p2) |
| |
| const TSpline3 | ND_EM_calE_p3 ("ND_EM_calE_p3", xknot_ND_EM_calE_p3, yknot_ND_EM_calE_p3, N_ND_EM_calE_p3,"b1,e1", m1_ND_EM_calE_p3, m2_ND_EM_calE_p3) |
| |
| const TSpline3 | ND_EM_calE_p4 ("ND_EM_calE_p4", xknot_ND_EM_calE_p4, yknot_ND_EM_calE_p4, N_ND_EM_calE_p4,"b1,e1", m1_ND_EM_calE_p4, m2_ND_EM_calE_p4) |
| |
| const TSpline3 | ND_EM_calE_p5 ("ND_EM_calE_p5", xknot_ND_EM_calE_p5, yknot_ND_EM_calE_p5, N_ND_EM_calE_p5,"b1,e1", m1_ND_EM_calE_p5, m2_ND_EM_calE_p5) |
| |
| const TSpline3 | ND_EM_calE_p6 ("ND_EM_calE_p6", xknot_ND_EM_calE_p6, yknot_ND_EM_calE_p6, N_ND_EM_calE_p6,"b1,e1", m1_ND_EM_calE_p6, m2_ND_EM_calE_p6) |
| |
| const TSpline3 | FD_EM_calE_p1 ("FD_EM_calE_p1", xknot_FD_EM_calE_p1, yknot_FD_EM_calE_p1, N_FD_EM_calE_p1,"b1,e1", m1_FD_EM_calE_p1, m2_FD_EM_calE_p1) |
| |
| const TSpline3 | FD_EM_calE_p2 ("FD_EM_calE_p2", xknot_FD_EM_calE_p2, yknot_FD_EM_calE_p2, N_FD_EM_calE_p2,"b1,e1", m1_FD_EM_calE_p2, m2_FD_EM_calE_p2) |
| |
| const TSpline3 | FD_EM_calE_p3 ("FD_EM_calE_p3", xknot_FD_EM_calE_p3, yknot_FD_EM_calE_p3, N_FD_EM_calE_p3,"b1,e1", m1_FD_EM_calE_p3, m2_FD_EM_calE_p3) |
| |
| const TSpline3 | FD_EM_calE_p4 ("FD_EM_calE_p4", xknot_FD_EM_calE_p4, yknot_FD_EM_calE_p4, N_FD_EM_calE_p4,"b1,e1", m1_FD_EM_calE_p4, m2_FD_EM_calE_p4) |
| |
| const TSpline3 | FD_EM_calE_p5 ("FD_EM_calE_p5", xknot_FD_EM_calE_p5, yknot_FD_EM_calE_p5, N_FD_EM_calE_p5,"b1,e1", m1_FD_EM_calE_p5, m2_FD_EM_calE_p5) |
| |
| const TSpline3 | FD_EM_calE_p6 ("FD_EM_calE_p6", xknot_FD_EM_calE_p6, yknot_FD_EM_calE_p6, N_FD_EM_calE_p6,"b1,e1", m1_FD_EM_calE_p6, m2_FD_EM_calE_p6) |
| |
| const TSpline3 | ND_garbage_calE_p1 ("ND_garbage_calE_p1", xknot_ND_garbage_calE_p1, yknot_ND_garbage_calE_p1, N_ND_garbage_calE_p1,"b1,e1", m1_ND_garbage_calE_p1, m2_ND_garbage_calE_p1) |
| |
| const TSpline3 | ND_garbage_calE_p2 ("ND_garbage_calE_p2", xknot_ND_garbage_calE_p2, yknot_ND_garbage_calE_p2, N_ND_garbage_calE_p2,"b1,e1", m1_ND_garbage_calE_p2, m2_ND_garbage_calE_p2) |
| |
| const TSpline3 | ND_garbage_calE_p3 ("ND_garbage_calE_p3", xknot_ND_garbage_calE_p3, yknot_ND_garbage_calE_p3, N_ND_garbage_calE_p3,"b1,e1", m1_ND_garbage_calE_p3, m2_ND_garbage_calE_p3) |
| |
| const TSpline3 | ND_garbage_calE_p4 ("ND_garbage_calE_p4", xknot_ND_garbage_calE_p4, yknot_ND_garbage_calE_p4, N_ND_garbage_calE_p4,"b1,e1", m1_ND_garbage_calE_p4, m2_ND_garbage_calE_p4) |
| |
| const TSpline3 | ND_garbage_calE_p5 ("ND_garbage_calE_p5", xknot_ND_garbage_calE_p5, yknot_ND_garbage_calE_p5, N_ND_garbage_calE_p5,"b1,e1", m1_ND_garbage_calE_p5, m2_ND_garbage_calE_p5) |
| |
| const TSpline3 | ND_garbage_calE_p6 ("ND_garbage_calE_p6", xknot_ND_garbage_calE_p6, yknot_ND_garbage_calE_p6, N_ND_garbage_calE_p6,"b1,e1", m1_ND_garbage_calE_p6, m2_ND_garbage_calE_p6) |
| |
| const TSpline3 | FD_garbage_calE_p1 ("FD_garbage_calE_p1", xknot_FD_garbage_calE_p1, yknot_FD_garbage_calE_p1, N_FD_garbage_calE_p1,"b1,e1", m1_FD_garbage_calE_p1, m2_FD_garbage_calE_p1) |
| |
| const TSpline3 | FD_garbage_calE_p2 ("FD_garbage_calE_p2", xknot_FD_garbage_calE_p2, yknot_FD_garbage_calE_p2, N_FD_garbage_calE_p2,"b1,e1", m1_FD_garbage_calE_p2, m2_FD_garbage_calE_p2) |
| |
| const TSpline3 | FD_garbage_calE_p3 ("FD_garbage_calE_p3", xknot_FD_garbage_calE_p3, yknot_FD_garbage_calE_p3, N_FD_garbage_calE_p3,"b1,e1", m1_FD_garbage_calE_p3, m2_FD_garbage_calE_p3) |
| |
| const TSpline3 | FD_garbage_calE_p4 ("FD_garbage_calE_p4", xknot_FD_garbage_calE_p4, yknot_FD_garbage_calE_p4, N_FD_garbage_calE_p4,"b1,e1", m1_FD_garbage_calE_p4, m2_FD_garbage_calE_p4) |
| |
| const TSpline3 | FD_garbage_calE_p5 ("FD_garbage_calE_p5", xknot_FD_garbage_calE_p5, yknot_FD_garbage_calE_p5, N_FD_garbage_calE_p5,"b1,e1", m1_FD_garbage_calE_p5, m2_FD_garbage_calE_p5) |
| |
| const TSpline3 | FD_garbage_calE_p6 ("FD_garbage_calE_p6", xknot_FD_garbage_calE_p6, yknot_FD_garbage_calE_p6, N_FD_garbage_calE_p6,"b1,e1", m1_FD_garbage_calE_p6, m2_FD_garbage_calE_p6) |
| |
| double | getMuonEnergy (const TSpline3 &spline_calE, const TSpline3 &spline_BPFE, const caf::SRProxy *sr) |
| | : function to compute the muon energy More...
|
| |
| double | getEMShowerEnergy (const TSpline3 &spline_calE, const caf::SRProxy *sr) |
| | : function to compute the EM shower energy More...
|
| |
| double | getHadronEnergy (const TSpline3 &spline_calE, const caf::SRProxy *sr) |
| | : function to compute the hadron energy More...
|
| |
| double | takeOutTrash (const TSpline3 &spline_calE, const caf::SRProxy *sr) |
| | : function to compute v3 of the garbage bin. this takes out muons, EM showers, and general hadrons, everything else in the garbage bin More...
|
| |
| float | CVNFinalStateScore2018 (const caf::SRProxy *sr, int target) |
| |
| double | GetCVNProngMuonScore (unsigned int ProngIdx, caf::SRProxy *sr) |
| | Function to return "adjusted" CVN-prong muon score: More...
|
| |
| double | EMScore (unsigned int ProngIdx, const caf::SRProxy *sr) |
| |
| double | HadScore (unsigned int ProngIdx, const caf::SRProxy *sr) |
| |
| double | HadScoreWithMuon (unsigned int ProngIdx, const caf::SRProxy *sr) |
| |
| bool | IsNumuCCPionByCVN (unsigned int ProngIdx, const caf::SRProxy *sr) |
| | : Returns a bool if prong passes NumuCC event pion selection criteria More...
|
| |
| bool | IsNumuCCProtonByCVN (unsigned int ProngIdx, const caf::SRProxy *sr) |
| | : Returns a bool if prong passes NumuCC event proton selection criteria More...
|
| |
| bool | IsNumuCCHadronByCVN (unsigned int ProngIdx, const caf::SRProxy *sr) |
| | : Returns a bool if prong passes NumuCC event hadron selection criteria More...
|
| |
| bool | IsNumuCCEMShowerByCVN (unsigned int ProngIdx, const caf::SRProxy *sr) |
| | : Returns a bool if prong passes NumuCC event EM selection criteria More...
|
| |
| FitVarsProduct | FitVarSinSqTheta23SinSq2Theta13 () |
| | Return a FitVarsProduct for  . More...
|
| |
| FitVarsProductMarg | FitSinSqTheta23SinSq2Theta13Marg () |
| |
| Fit2SinSqTheta23SinSq2Theta13 | FitVar2SinSqTheta23SinSq2Theta13 () |
| | Return a Fit2SinSqTheta23SinSq2Theta13 for  . More...
|
| |
| FitVarsProductMarg | FitVarSinSqTheta23SinSq2Theta13Marg () |
| | Return a FitVarsProductMarg to marginalize over this if using kFitSinSqTheta23SinSq2Theta13. More...
|
| |
| NuTruthVar | VarFromNOvARwgt (const novarwgt::IWeightGenerator *wgtr) |
| |
| template<typename T , typename... Args> |
| NuTruthVar | VarFromNOvARwgt (Args &&...args) |
| |
| float | TAKEPol6_biasHM (float kepol6_biasHM) |
| |
| int | PDG_cvnmax (std::map< int, double > ScorePDGmap) |
| |
| const MultiVar | kPcvn_el (CVNPng(kElectronPDG)) |
| |
| const MultiVar | kPcvn_mu (CVNPng(kMuonPDG )) |
| |
| const MultiVar | kPcvn_pr (CVNPng(kProtonPDG)) |
| |
| const MultiVar | kPcvn_pi (CVNPng(kPionPDG )) |
| |
| const MultiVar | kPcvn_ga (CVNPng(kGammaPDG )) |
| |
| const MultiVar | kPcvn_ot (CVNPng(0 )) |
| |
| const MultiVar | kPcvn_el_mc_el (CVNPngTruthSel(kElectronPDG, kElectronPDG)) |
| |
| const MultiVar | kPcvn_mu_mc_el (CVNPngTruthSel(kElectronPDG, kMuonPDG )) |
| |
| const MultiVar | kPcvn_pr_mc_el (CVNPngTruthSel(kElectronPDG, kProtonPDG)) |
| |
| const MultiVar | kPcvn_pi_mc_el (CVNPngTruthSel(kElectronPDG, kPionPDG )) |
| |
| const MultiVar | kPcvn_ga_mc_el (CVNPngTruthSel(kElectronPDG, kGammaPDG )) |
| |
| const MultiVar | kPcvn_ot_mc_el (CVNPngTruthSel(kElectronPDG, 0 )) |
| |
| const MultiVar | kPcvn_el_mc_mu (CVNPngTruthSel(kMuonPDG, kElectronPDG)) |
| |
| const MultiVar | kPcvn_mu_mc_mu (CVNPngTruthSel(kMuonPDG, kMuonPDG )) |
| |
| const MultiVar | kPcvn_pr_mc_mu (CVNPngTruthSel(kMuonPDG, kProtonPDG)) |
| |
| const MultiVar | kPcvn_pi_mc_mu (CVNPngTruthSel(kMuonPDG, kPionPDG )) |
| |
| const MultiVar | kPcvn_ga_mc_mu (CVNPngTruthSel(kMuonPDG, kGammaPDG )) |
| |
| const MultiVar | kPcvn_ot_mc_mu (CVNPngTruthSel(kMuonPDG, 0 )) |
| |
| const MultiVar | kPcvn_el_mc_pr (CVNPngTruthSel(kProtonPDG, kElectronPDG)) |
| |
| const MultiVar | kPcvn_mu_mc_pr (CVNPngTruthSel(kProtonPDG, kMuonPDG )) |
| |
| const MultiVar | kPcvn_pr_mc_pr (CVNPngTruthSel(kProtonPDG, kProtonPDG)) |
| |
| const MultiVar | kPcvn_pi_mc_pr (CVNPngTruthSel(kProtonPDG, kPionPDG )) |
| |
| const MultiVar | kPcvn_ga_mc_pr (CVNPngTruthSel(kProtonPDG, kGammaPDG )) |
| |
| const MultiVar | kPcvn_ot_mc_pr (CVNPngTruthSel(kProtonPDG, 0 )) |
| |
| const MultiVar | kPcvn_el_mc_pi (CVNPngTruthSel(kPionPDG, kElectronPDG)) |
| |
| const MultiVar | kPcvn_mu_mc_pi (CVNPngTruthSel(kPionPDG, kMuonPDG )) |
| |
| const MultiVar | kPcvn_pr_mc_pi (CVNPngTruthSel(kPionPDG, kProtonPDG)) |
| |
| const MultiVar | kPcvn_pi_mc_pi (CVNPngTruthSel(kPionPDG, kPionPDG )) |
| |
| const MultiVar | kPcvn_ga_mc_pi (CVNPngTruthSel(kPionPDG, kGammaPDG )) |
| |
| const MultiVar | kPcvn_ot_mc_pi (CVNPngTruthSel(kPionPDG, 0 )) |
| |
| const MultiVar | kPcvn_el_mc_ga (CVNPngTruthSel(kGammaPDG, kElectronPDG)) |
| |
| const MultiVar | kPcvn_mu_mc_ga (CVNPngTruthSel(kGammaPDG, kMuonPDG )) |
| |
| const MultiVar | kPcvn_pr_mc_ga (CVNPngTruthSel(kGammaPDG, kProtonPDG)) |
| |
| const MultiVar | kPcvn_pi_mc_ga (CVNPngTruthSel(kGammaPDG, kPionPDG )) |
| |
| const MultiVar | kPcvn_ga_mc_ga (CVNPngTruthSel(kGammaPDG, kGammaPDG )) |
| |
| const MultiVar | kPcvn_ot_mc_ga (CVNPngTruthSel(kGammaPDG, 0 )) |
| |
| const MultiVar | kPcvn_el_mc_ot (CVNPngTruthSel(0, kElectronPDG)) |
| |
| const MultiVar | kPcvn_mu_mc_ot (CVNPngTruthSel(0, kMuonPDG )) |
| |
| const MultiVar | kPcvn_pr_mc_ot (CVNPngTruthSel(0, kProtonPDG)) |
| |
| const MultiVar | kPcvn_pi_mc_ot (CVNPngTruthSel(0, kPionPDG )) |
| |
| const MultiVar | kPcvn_ga_mc_ot (CVNPngTruthSel(0, kGammaPDG )) |
| |
| const MultiVar | kPcvn_ot_mc_ot (CVNPngTruthSel(0, 0 )) |
| |
| int | GetPPFXNuniverses () |
| |
| std::vector< NuTruthVar > | GetkPPFXFluxUnivWgtST () |
| |
| std::vector< Var > | GetkPPFXFluxUnivWgt () |
| |
| static void | best_spline_seeds (unsigned int m, double *xknot, double *yknot) |
| |
| static double | best_spline_mode_fcn (double x, const TH1 *h) |
| |
| static void | best_spline_fcn0 (int &, double *, double &chi2, double *par, int) |
| |
| static void | best_spline_fcn1 (int &, double *, double &chi2, double *par, int) |
| |
| static TGraphErrors * | best_spline_make_mode_graph (TH2 *h) |
| |
| double | best_spline_find_mode (TH1 *h, double *sig=0) |
| | Given a 1D histogram, find an estimate of the mode following the method of Bickel, Journal of Statistical Computation and Simulation; 73 (2003), 899-912. More...
|
| |
| void | best_spline_set_objective (char obj) |
| | Allow switching between the two objective functions (minimum overall chi^2 or minimum approach to the modes of the distributions. More...
|
| |
| TGraphErrors * | best_spline_get_mode_graph () |
| | If we've chosen to fit to modes, get access to the graph of the modes vs. x. More...
|
| |
| static void | best_spline_set_histo (TH2 *h) |
| |
| TSpline3 | best_spline (TH2 *histo, unsigned int m, double *xknot, double *yknot, double *b1rtn, double *e1rtn, double *chi2=0, double *sigxknot=0, double *sigyknot=0, double *sigb1rtn=0, double *sige1rtn=0, const char *title=0) |
| | Find the best spline that passes through a set of data. More...
|
| |
| TH1F * | make_simple_res_plot (TH2 *h, const TSpline3 &spl) |
| | : do as the function name says... More...
|
| |
| static TH2 * | make_test_th2 () |
| |
| void | test_best_spline_seeds () |
| |
| void | test_best_spline (int m) |
| |
| void | test_best_spline_mode_graph () |
| |
| void | test_best_spline_find_mode () |
| |
| bool | ProngTruthCut (unsigned int pIdx, const caf::SRProxy *sr, std::vector< int > pdgCodes, double eff=0.0, double pur=0.0) |
| | : Returns true if the prong matches the truth criteria. More...
|
| |
| bool | hasBPFE (unsigned int pIdx, const caf::SRProxy *sr) |
| |
| double | getMuonEnergyByTruth (TSpline3 spline_calE, TSpline3 spline_BPFE, const caf::SRProxy *sr) |
| | : function to compute the muon energy More...
|
| |
| double | getEMShowerEnergyByTruth (TSpline3 spline_calE, const caf::SRProxy *sr) |
| | : function to compute the EM shower energy More...
|
| |
| double | getHadronEnergyByTruth (TSpline3 spline_calE, const caf::SRProxy *sr) |
| | : function to compute the hadron energy More...
|
| |
| double | takeOutTrashByTruth (TSpline3 spline_calE, const caf::SRProxy *sr) |
| | : function to compute v3 of the garbage bin. this takes out muons, EM showers, and general hadrons, everything else in the garbage bin More...
|
| |
| double |
CC and NC components, assigns remainder of data to 
More...
More...
More...
More...
More...
More...
More...
More...
More...
More...
More...
More...
More...
More...
More...
More...
More...
More...
More...
More...
More...
More...
More...
More...
More...
More...
