NuDSTAna Class Reference

#include <NuDSTAna.h>

Inheritance diagram for NuDSTAna:

List of all members.

Public Member Functions
	NuDSTAna ()
	~NuDSTAna ()
void	StdCCAna ()
void	StdNMBAna (TString xmlFileName="")
void	MMAna (std::string sOutputFileName="")
virtual void	DoSystematicShifts (NuEvent &event, const NuXMLConfig *xmlConfig) const
void	MMRereco (std::string sOutputFileName="", TString xmlFileName="")
void	MMTransition (std::string sOutputFileName="", TString xmlFileName="")
void	MakeMicroDST (const TString anaVersion, const TString xmlfile="")
	Make a microDST, optionally processing from the XML file.
void	MakeMicroDstForCSSSystematics ()
void	MakeMicroDstWithStdCCRecoAndCuts ()
void	MakeMicroDstJJEPresel (int run=-1)
void	MakeMicroDst2010 ()
void	MakeMicroDstHe (bool forceRHC=false)
void	MakeFCTree (TString xmlFileName)
void	MakeSelMicroDST (Int_t Selector)
void	MakeMicroDstFakeData (bool presel=true)
void	MakeDstPQ ()
void	ConcatenateDSTs ()
void	DPSystematic ()
void	FluxComponents (TString xmlFileName)
void	Contamination ()
void	NewFieldAna (std::string sOutputFileName="")
void	NDOsc ()
void	RHCTest ()
void	SelectorTable ()
void	QPStudy ()
void	NDQPRB (bool cedar)
void	BRevAna ()
void	CoilHoleAna ()
void	CSSAna ()
void	CSSAnaRashid ()
void	FDTestAna ()
void	JeffsTestAna ()
void	NDTestAna ()
void	NMBAna ()
void	VsTime ()
void	TestNuSyst ()
Protected Member Functions
const Float_t	Baseline () const
void	CopyAcrossHistos (TDirectory *dirInput, TDirectory *dirOutput) const
void	UpdatePotSinceLastEvt (NuEvent &nu, Bool_t newEvt) const
NuConfig	GetNuConfig (const NuEvent &nu) const
Bool_t	IsGoodPreSelectionCuts (const NuPlots *plots, const NuEvent &nu) const
Bool_t	IsGoodStdCuts (const NuPlots *plots, const NuEvent &nu) const
void	MakeFinalPlots (const NuPlots *plots, const NuEvent &nu) const
void	MakePostPreSelectionPlots (const NuPlots *plots, const NuEvent &nu) const
void	Oscillate (NuEvent &nu, const NuXMLConfig *xmlConfig) const
void	Oscillate (NuMCEvent &nu, const NuXMLConfig *xmlConfig) const
void	OscillateOrTransition (NuEvent &nu, const NuXMLConfig *xmlConfig, NuTransition *transition) const
const Float_t	OscillationWeight (const Float_t energy, const Int_t inu, const NuXMLConfig *xmlConfig) const
void	OverwriteSntpBeamDataInNtuple (NuEvent &nu)
void	OverwriteCoilDataInNtuple (NuEvent &nu)
void	SanityCheckAnaVersionSameAsPrevious (Int_t anaVersion) const
Int_t	SanityCheckedAnaVersion (Int_t anaVersion, Int_t overrideAnaVersion) const
const NuEvent *	GetEvent (const NuEvent &nu)
const NuEvent *	GetEventND (const NuEvent &nu)
NuInputEvents &	DoIO (NuOutputWriter *poutput=0, std::string sFilePrefix="", std::string sFullFileName="")
NuInputEvents &	DoIOSimple (std::string sFilePrefix="")

---

Constructor & Destructor Documentation

NuDSTAna::NuDSTAna (   )

Definition at line 63 of file NuDSTAna.cxx. References MSG. { MSG("NuDSTAna",Msg::kDebug) <<"Running NuDSTAna Constructor..."<<endl; MSG("NuDSTAna",Msg::kDebug) <<"Finished NuDSTAna Constructor"<<endl; }

NuDSTAna::~NuDSTAna (   )

Definition at line 75 of file NuDSTAna.cxx. References MSG. { MSG("NuDSTAna",Msg::kDebug) <<"Running NuDSTAna Destructor..."<<endl; MSG("NuDSTAna",Msg::kDebug) <<"Finished NuDSTAna Destructor"<<endl; }

---

Member Function Documentation

const Float_t NuDSTAna::Baseline (   )  const [inline, protected]

Definition at line 80 of file NuDSTAna.h. {return 735.0;};

void NuDSTAna::BRevAna (   )

Definition at line 7288 of file NuDSTAna.cxx. References NuEvent::anaVersion, NuEvent::applyBeamWeight, NuReco::ApplyReweights(), NuEvent::beamWeight, NuEvent::beamWeightRunII, NuEvent::charge, NuLibrary::cnt, NuLibrary::cuts, NuConfig::detector, NuEvent::detectorWeightNM, NuEvent::detectorWeightNMB, NuEvent::detectorWeightNMBRunII, NuEvent::detectorWeightNMRunII, DoIO(), NuCounter::evtCounter, NuPlots::FillBRev(), NuInputEvents::GetEntriesNuEvent(), NuReco::GetEvtEnergy(), NuInputEvents::GetNextNuEvent(), NuEvent::iaction, NuLibrary::Instance(), NuEvent::inu, IsGoodPreSelectionCuts(), IsGoodStdCuts(), NuCuts::IsInFidVolTrueEvt(), MSG, NuCounter::nuNQCounter, NuCounter::nuPQCounter, plots(), NuBase::PrintLoopProgress(), NuCounter::PrintMicroDST(), NuLibrary::reco, NuInputEvents::ResetNuEventLoopPositionToStart(), NuConfig::run, SanityCheckedAnaVersion(), NuEvent::shwEnWeight, NuEvent::shwEnWeightRunII, NuEvent::simFlag, NuEvent::trkEnWeight, and NuEvent::trkEnWeightRunII. { NuInputEvents& input=this->DoIO(0,"",""); //use config object to store info NuConfig config; config.detector=Detector::kFar; config.run=100; TString post; //get an instance of the code library NuLibrary& lib=NuLibrary::Instance(); //get an object to fill plots const NuPlots* plots=0; //version to do reco/cuts with NuCuts::NuAnaVersion_t overrideAnaVersion=NuCuts::kNMB0325Bravo; //NuCuts::NuAnaVersion_t overrideAnaVersion=NuCuts::kRM2; input.ResetNuEventLoopPositionToStart(); TH1::AddDirectory(true); cout<<endl <<"************************************************"<<endl <<"*** Starting main loop over snarls ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuEvent();++i) { lib.cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuEvent(),1); NuEvent &nu=const_cast<NuEvent&>(input.GetNextNuEvent(Msg::kDebug)); //OVERRIDE //Selection nu.anaVersion=this->SanityCheckedAnaVersion(nu.anaVersion,overrideAnaVersion); // Set RunII Weighting nu.applyBeamWeight = true; nu.beamWeight = nu.beamWeightRunII; nu.trkEnWeight = nu.trkEnWeightRunII; nu.shwEnWeight = nu.shwEnWeightRunII; nu.detectorWeightNMB = nu.detectorWeightNMBRunII; nu.detectorWeightNM = nu.detectorWeightNMRunII; //RE-RECONSTRUCT the neutrino energy lib.reco.GetEvtEnergy(nu, false); lib.reco.ApplyReweights(nu); // Fill Truth Histos before cuts if (!this->IsGoodPreSelectionCuts(plots,nu)) continue; if (nu.simFlag == SimFlag::kMC) { if (nu.iaction != 1) { post = "NC"; } else { if (lib.cuts.IsInFidVolTrueEvt(nu)) { plots->FillBRev(nu,"True",true); } if ( (nu.charge > 0 && nu.inu != -14) || (nu.charge < 0 && nu.inu != 14) ) { post = "WrSn"; } else { post = "Sig"; } } } else { post = "Data"; } //make all the std cuts if (!this->IsGoodStdCuts(plots,nu)) continue; //END OF STD CUTS if (nu.charge==-1) lib.cnt.nuNQCounter++; else if (nu.charge==+1) lib.cnt.nuPQCounter++; else cout<<"ahhh, bad charge(12)"<<endl; plots->FillBRev(nu,post); if (nu.simFlag == SimFlag::kMC) { plots->FillBRev(nu,"All"); } }//end of loop over summary tree MSG("NuAnalysis",Msg::kInfo)<<"Finished main loop"<<endl; //print out the numbers of events lib.cnt.PrintMicroDST(); MSG("NuAnalysis",Msg::kInfo) <<" ** Finished BRevAna method **"<<endl; }

void NuDSTAna::CoilHoleAna (   )

Definition at line 7403 of file NuDSTAna.cxx. References NuEvent::anaVersion, NuConfig::detector, DoIO(), NuPlots::FillCoilHole(), NuInputEvents::GetEntriesNuEvent(), NuInputEvents::GetNextNuEvent(), MSG, plots(), NuBase::PrintLoopProgress(), NuInputEvents::ResetNuEventLoopPositionToStart(), and NuConfig::run. { NuInputEvents& input=this->DoIO(0,"","null"); //use config object to store info NuConfig config; config.detector=Detector::kFar; config.run=100; //get an object to fill plots const NuPlots* plots=0; //version to do reco/cuts with //NuCuts::NuAnaVersion_t overrideAnaVersion=NuCuts::kNMB0325Bravo; input.ResetNuEventLoopPositionToStart(); cout<<endl <<"************************************************"<<endl <<"*** Starting main loop over snarls ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuEvent();++i) { this->PrintLoopProgress(i,input.GetEntriesNuEvent(),1); NuEvent& nu=const_cast<NuEvent&>(input.GetNextNuEvent(Msg::kDebug)); nu.anaVersion=NuCuts::kCC0250Std; //make the preselection cuts //if (!this->IsGoodPreSelectionCuts(plots,nu)) continue; plots->FillCoilHole(nu); } //end of loop over summary tree MSG("NuDSTAna",Msg::kInfo)<<"Finished main loop"<<endl; MSG("NuDSTAna",Msg::kInfo) <<" ** Finished BRevAna method **"<<endl; }

void NuDSTAna::ConcatenateDSTs (   )

This function concatenates DSTs no cuts are made whatsoever, although the anaVersion is checked to ensure all input files use the same version Use with care! Definition at line 3413 of file NuDSTAna.cxx. References NuMCEvent::anaVersion, NuEvent::anaVersion, NuEvent::charge, NuLibrary::cnt, DoIO(), NuMCEvent::energyMC, NuCounter::evtCounter, NuOutputWriter::FillNuEventTree(), NuOutputWriter::FillNuMCEventTree(), NuOutputWriter::Finish(), NuInputEvents::GetEntriesNuEvent(), NuInputEvents::GetEntriesNuMCEvent(), NuInputEvents::GetNextNuEvent(), NuInputEvents::GetNextNuMCEvent(), NuOutputWriter::GetNuEventToFill(), NuOutputWriter::GetNuMCEventToFill(), NuInputEvents::InitialiseNuMCEventBranch(), NuLibrary::Instance(), MAXMSG, NuCounter::nuNQCounter, NuCounter::nuPQCounter, NuCounter::PrintFullDST(), NuBase::PrintLoopProgress(), NuInputEvents::ResetNuEventLoopPositionToStart(), NuInputEvents::ResetNuMCEventLoopPositionToStart(), and SanityCheckAnaVersionSameAsPrevious(). { //do the histogram IO NuOutputWriter* poutput=new NuOutputWriter(); NuInputEvents& input=this->DoIO(poutput,"NuDSTConcat"); //get a reference NuOutputWriter& output=(*poutput); //get an instance of the code library NuLibrary& lib=NuLibrary::Instance(); // This can be put back in as necessary. At the moment all it does // Is throw up an annoying compiler warning. // static const NuPlots* plots; //prepare for next loop input.ResetNuEventLoopPositionToStart(); cout<<endl <<"************************************************"<<endl <<"*** Starting main loop over snarls ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuEvent();++i) { lib.cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuEvent(),1); NuEvent& nu=const_cast<NuEvent&>(input.GetNextNuEvent(Msg::kDebug)); //make sanity check to avoid erroneous use this->SanityCheckAnaVersionSameAsPrevious(nu.anaVersion); //NO CUTS WHATSOEVER //count the events to print to screen after loop if (nu.charge==-1) lib.cnt.nuNQCounter++; else if (nu.charge==+1) lib.cnt.nuPQCounter++; //get the output nu to fill, copy nu to the output nu, fill tree NuEvent& nuOutput=output.GetNuEventToFill(); nuOutput=nu; output.FillNuEventTree(); } input.InitialiseNuMCEventBranch(); input.ResetNuMCEventLoopPositionToStart(); cout<<endl <<"************************************************"<<endl <<"*** Starting loop over truth info ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuMCEvent();++i) { lib.cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuMCEvent(),1); NuMCEvent& mc=const_cast<NuMCEvent&>(input.GetNextNuMCEvent (Msg::kDebug)); //make sanity check to avoid erroneous use this->SanityCheckAnaVersionSameAsPrevious(mc.anaVersion); MAXMSG("NuDSTAna",Msg::kInfo,5) <<"energyMC="<<mc.energyMC<<endl; //NO CUTS WHATSOEVER //get the output nu to fill,copy mc to the output mc, fill tree NuMCEvent& mcOutput=output.GetNuMCEventToFill(); mcOutput=mc; output.FillNuMCEventTree(); } //print out the numbers of events lib.cnt.PrintFullDST(); //close the file and write out everything output.Finish(); }

void NuDSTAna::Contamination (   )

Definition at line 6129 of file NuDSTAna.cxx. References NuEvent::anaVersion, NuEvent::applyBeamWeight, NuReco::ApplyReweights(), NuEvent::beamWeight, NuEvent::beamWeightRunI, NuEvent::charge, NuLibrary::cnt, NuLibrary::cuts, NuEvent::detectorWeightNM, NuEvent::detectorWeightNMB, NuEvent::detectorWeightNMBRunI, NuEvent::detectorWeightNMRunI, DoIO(), NuEvent::energy, NuCounter::evtCounter, NuInputEvents::GetEntriesNuEvent(), NuReco::GetEvtEnergy(), NuInputEvents::GetNextNuEvent(), NuEvent::iaction, NuInputEvents::InitialiseNuEventBranch(), NuLibrary::Instance(), NuEvent::inu, NuCuts::IsGoodNumberOfTracks(), IsGoodPreSelectionCuts(), IsGoodStdCuts(), NuCuts::IsInFidVolTrk(), MSG, NuCounter::nuNQCounter, NuCounter::nuPQCounter, NuBase::PrintLoopProgress(), NuCounter::PrintMicroDST(), NuLibrary::reco, NuUtilities::RecoBins(), NuInputEvents::ResetNuEventLoopPositionToStart(), NuEvent::rw, SanityCheckedAnaVersion(), NuEvent::shwEnWeight, NuEvent::shwEnWeightRunI, NuEvent::trkEnWeight, and NuEvent::trkEnWeightRunI. { NuInputEvents& input=this->DoIO(0,"","null"); //get an instance of the code library NuLibrary& lib = NuLibrary::Instance(); //version to do reco/cuts with NuCuts::NuAnaVersion_t overrideAnaVersion = static_cast<NuCuts::NuAnaVersion_t>(NuCuts::kNMB0325Bravo); //Binning scheme const NuUtilities cuts; NuBinningScheme::NuBinningScheme_t binningScheme = static_cast<NuBinningScheme::NuBinningScheme_t>(2); std::vector<Double_t> vReco = cuts.RecoBins(binningScheme); int numRecoBins = vReco.size() - 1; TH1::AddDirectory(true); TH1D * hEffDenom = new TH1D("hEffDenom","True NuBars in fid with a track",numRecoBins,&(vReco[0])); TH1D * hSignal = new TH1D("hSignal","PQ Signal before Selection",numRecoBins,&(vReco[0])); TH1D * hNC = new TH1D("hNC","PQ NC Events before Selection",numRecoBins,&(vReco[0])); TH1D * hWS = new TH1D("hWS","PQ Wrong Sign Events before Selection",numRecoBins,&(vReco[0])); TH1D * hTau = new TH1D("hTau","PQ Tau Events before Selection",numRecoBins,&(vReco[0])); TH1D * hBkgd = new TH1D("hBkgd","All PQ Background before Selection",numRecoBins,&(vReco[0])); TH1D * hAllEvents = new TH1D("hAllEvents","All PQ Events before Selection",numRecoBins,&(vReco[0])); TH1D * hSignal_sel = new TH1D("hSignal_sel","PQ Signal after Selection",numRecoBins,&(vReco[0])); TH1D * hNC_sel = new TH1D("hNC_sel","PQ NC Events after Selection",numRecoBins,&(vReco[0])); TH1D * hWS_sel = new TH1D("hWS_sel","PQ Wrong Sign Events after Selection",numRecoBins,&(vReco[0])); TH1D * hTau_sel = new TH1D("hTau_sel","PQ Tau Events before Selection",numRecoBins,&(vReco[0])); TH1D * hBkgd_sel = new TH1D("hBkgd_sel","All PQ Background after Selection",numRecoBins,&(vReco[0])); TH1D * hAllEvents_sel = new TH1D("hAllEvents_sel","All PQ Events after Selection",numRecoBins,&(vReco[0])); input.InitialiseNuEventBranch(); input.ResetNuEventLoopPositionToStart(); cout<<endl <<"************************************************"<<endl <<"*** Starting main loop over snarls ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuEvent();++i) { //for (Int_t i=0;i<0;++i) { lib.cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuEvent(),1); NuEvent &nu=const_cast<NuEvent&>(input.GetNextNuEvent(Msg::kDebug)); //OVERRIDE //Selection nu.anaVersion=this->SanityCheckedAnaVersion (nu.anaVersion,overrideAnaVersion); //Reweighting nu.applyBeamWeight = true; nu.beamWeight = nu.beamWeightRunI; nu.trkEnWeight = nu.trkEnWeightRunI; nu.shwEnWeight = nu.shwEnWeightRunI; nu.detectorWeightNMB = nu.detectorWeightNMBRunI; nu.detectorWeightNM = nu.detectorWeightNMRunI; //RE-RECONSTRUCT the neutrino energy lib.reco.GetEvtEnergy(nu, false); lib.reco.ApplyReweights(nu); if (nu.charge==-1) lib.cnt.nuNQCounter++; else if (nu.charge==+1) lib.cnt.nuPQCounter++; else cout<<"ahhh, bad charge (9)"<<endl; // Pre-pre selection (Ntracks and fid vol) if (!lib.cuts.IsGoodNumberOfTracks(nu)) continue; if (!lib.cuts.IsInFidVolTrk(nu)) continue; if (nu.inu == -14 && nu.iaction != 0) hEffDenom->Fill(nu.energy, nu.rw); if (nu.charge == -1) continue; // Only interested in PQ events if (!this->IsGoodPreSelectionCuts(0,nu)) continue; hAllEvents->Fill(nu.energy, nu.rw); if (nu.inu == 16 || nu.inu == -16) { // Taus if (nu.iaction == 1) { hTau->Fill(nu.energy, nu.rw); hBkgd->Fill(nu.energy, nu.rw); } } else if (nu.iaction == 0) { // NC Background hNC->Fill(nu.energy, nu.rw); hBkgd->Fill(nu.energy, nu.rw); } else if (nu.inu == 14) { // Wrong Sign Background hWS->Fill(nu.energy, nu.rw); hBkgd->Fill(nu.energy, nu.rw); } else if (nu.inu == -14) { // Signal hSignal->Fill(nu.energy, nu.rw); } else { // Other? hBkgd->Fill(nu.energy, nu.rw); } if (!this->IsGoodStdCuts(0,nu)) continue; hAllEvents_sel->Fill(nu.energy, nu.rw); if (nu.inu == 16 || nu.inu == -16) { // Taus if (nu.iaction == 1) { hTau_sel->Fill(nu.energy, nu.rw); hBkgd_sel->Fill(nu.energy, nu.rw); } } else if (nu.iaction == 0) { // NC Background hNC_sel->Fill(nu.energy, nu.rw); hBkgd_sel->Fill(nu.energy, nu.rw); } else if (nu.inu == 14) { // Wrong Sign Background hWS_sel->Fill(nu.energy, nu.rw); hBkgd_sel->Fill(nu.energy, nu.rw); } else if (nu.inu == -14) { // Signal hSignal_sel->Fill(nu.energy, nu.rw); } else { // Other? hBkgd_sel->Fill(nu.energy, nu.rw); } } cout<<endl; MSG("NuAnalysis",Msg::kInfo)<<"Finished main loop"<<endl; //print out the numbers of events lib.cnt.PrintMicroDST(); MSG("NuAnalysis",Msg::kInfo) <<" ** Finished NewFieldAna method **"<<endl; }

void NuDSTAna::CopyAcrossHistos (  TDirectory *  dirInput, TDirectory *  dirOutput )  const [protected]

Definition at line 928 of file NuDSTAna.cxx. References NuGeneral::CopyAcrossObjects(). Referenced by DoIOSimple(), FDTestAna(), and NMBAna(). { //vector to store the names of the histograms to copy across vector<string> vObjectNames; vObjectNames.push_back("hDetector"); vObjectNames.push_back("hSimFlag"); vObjectNames.push_back("hTrigSrc"); vObjectNames.push_back("hSpillsPerFile"); //these were commented out vObjectNames.push_back("hRun"); vObjectNames.push_back("hPottortgt"); vObjectNames.push_back("hPotBadtortgt"); vObjectNames.push_back("hPottrtgtd"); vObjectNames.push_back("hPotBadtrtgtd"); vObjectNames.push_back("hPottor101"); vObjectNames.push_back("hPotBadtor101"); vObjectNames.push_back("hPottr101d"); vObjectNames.push_back("hPotBadtr101d"); //these are new vObjectNames.push_back("hTotalPot"); vObjectNames.push_back("hNtupleEarliestTime"); vObjectNames.push_back("hNtupleLatestTime"); NuGeneral general; general.CopyAcrossObjects(dirInput,dirOutput,vObjectNames); }

void NuDSTAna::CSSAna (   )

Definition at line 7522 of file NuDSTAna.cxx. References NuEvent::charge, DoIO(), NuPlots::FillEffPur(), NuInputEvents::GetEntriesNuEvent(), NuInputEvents::GetNextNuEvent(), MSG, plots(), NuBase::PrintLoopProgress(), NuEvent::prob, and NuInputEvents::ResetNuEventLoopPositionToStart(). { NuInputEvents& input=this->DoIO(); //get an object to fill plots const NuPlots* plots=0; input.ResetNuEventLoopPositionToStart(); cout<<endl <<"************************************************"<<endl <<"*** Starting main loop over snarls ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuEvent();++i) { this->PrintLoopProgress(i,input.GetEntriesNuEvent(),1); NuEvent& nu=const_cast<NuEvent&>(input.GetNextNuEvent(Msg::kDebug)); //speed up cut for looking at nmb only if (nu.charge==-1) continue; plots->FillEffPur(nu, nu.prob > 0.1); }//end of loop over summary tree MSG("NuAnalysis",Msg::kInfo)<<"Finished main loop"<<endl; MSG("NuAnalysis",Msg::kInfo) <<" ** Finished CSSAna method **"<<endl; }

void NuDSTAna::CSSAnaRashid (   )

Definition at line 7455 of file NuDSTAna.cxx. References NuEvent::charge, DoIO(), NuEvent::dpID, NuInputEvents::GetEntriesNuEvent(), NuInputEvents::GetNextNuEvent(), MakeFinalPlots(), MakePostPreSelectionPlots(), MSG, plots(), NuBase::PrintLoopProgress(), and NuInputEvents::ResetNuEventLoopPositionToStart(). { NuInputEvents& input=this->DoIO(); //get an object to fill plots const NuPlots* plots=0; input.ResetNuEventLoopPositionToStart(); cout<<endl <<"************************************************"<<endl <<"*** Starting main loop over snarls ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuEvent();++i) { this->PrintLoopProgress(i,input.GetEntriesNuEvent(),1); NuEvent& nu=const_cast<NuEvent&>(input.GetNextNuEvent(Msg::kDebug)); //make the post-preselection plots (do this first) this->MakePostPreSelectionPlots(plots,nu); //NOW MAKE THE CUTS THAT YOU ARE INVESTIGATING THE EFFECT OF //THE SYSTEMATICS ON //speed up cut for looking at nmb only if (nu.charge==-1) { //neutrino-like event if (nu.dpID<-0.1) continue; } else if (nu.charge==+1) { //anti-neutrino-like event //EXAMPLE CUTS: if (nu.dpID<+0.4) continue; //if (nu.prob<0.1) continue; //if (roID<0.3) continue;//WHAT VALUE TO USE??? //OTHER CUTS INVESTIGATED HERE... } //now fill the plots after the selection has been applied this->MakeFinalPlots(plots,nu); }//end of loop over summary tree MSG("NuAnalysis",Msg::kInfo)<<"Finished main loop"<<endl; MSG("NuAnalysis",Msg::kInfo) <<" ** Finished CSSAnaRashid method **"<<endl; }

NuInputEvents & NuDSTAna::DoIO (  NuOutputWriter *  poutput = 0, std::string  sFilePrefix = "", std::string  sFullFileName = "" )  [protected]

Definition at line 989 of file NuDSTAna.cxx. References NuHistos::CalcPOTsFromHistos(), det, NuInputEvents::GetFirstRunNumberNuEvent(), NuBase::GetInputFileName(), NuInputEvents::GetNextNuEvent(), GetNuConfig(), NuLibrary::hist, NuInputEvents::InitialiseChains(), NuInputEvents::InitialiseNuEventBranch(), NuInputEvents::InputFileName(), NuLibrary::Instance(), MAXMSG, MSG, NuBase::OpenFile(), NuBase::OpenFileRECREATE(), NuInputEvents::OpenNextInputFile(), and NuOutputWriter::SetupFile(). Referenced by BRevAna(), CoilHoleAna(), ConcatenateDSTs(), Contamination(), CSSAna(), CSSAnaRashid(), DPSystematic(), FluxComponents(), JeffsTestAna(), MakeDstPQ(), MakeFCTree(), MakeMicroDST(), MakeMicroDst2010(), MakeMicroDstFakeData(), MakeMicroDstForCSSSystematics(), MakeMicroDstHe(), MakeMicroDstJJEPresel(), MakeMicroDstWithStdCCRecoAndCuts(), MakeSelMicroDST(), MMAna(), MMRereco(), MMTransition(), NDOsc(), NDQPRB(), NDTestAna(), NewFieldAna(), QPStudy(), RHCTest(), SelectorTable(), StdCCAna(), StdNMBAna(), TestNuSyst(), and VsTime(). { //open the input file with the tree in it string inputFileName=this->GetInputFileName(); NuInputEvents* fpInput=new NuInputEvents(); NuInputEvents& input=*fpInput; input.InputFileName(inputFileName); input.InitialiseChains(); input.InitialiseNuEventBranch(); TDirectory* dirInput=0; //formatting string for times MsgFormat ffmt("%9.f"); NuXMLConfig *xmlConfigClone=0; TH1F* hDetectorClone=0; TH1F* hSimFlagClone=0; TH1F* hTrigSrcClone=0; TH1F* hSpillsPerFileClone=0; TH1F* hTotalPotClone=0; TH1F* hPottortgtClone=0; TH1F* hPotBadtortgtClone=0; TH1F* hPottrtgtdClone=0; TH1F* hPotBadtrtgtdClone=0; TH1F* hPottor101Clone=0; TH1F* hPotBadtor101Clone=0; TH1F* hPottr101dClone=0; TH1F* hPotBadtr101dClone=0; TH1F* hRunClone=0; TH1F* hNtupleEarliestTimeClone=0; TH1F* hNtupleLatestTimeClone=0; //Matrix method histograms (numu CC): TH2D *hRecoVsTrueEnergy_NDClone = 0; TH2D *hRecoVsTrueEnergy_FDClone = 0; TH1D *hEfficiency_NDClone = 0; TH1D *hEfficiency_FDClone = 0; TH1D *hPurity_NDClone = 0; TH1D *hPurity_FDClone = 0; TH1D *hRecoEnergyAllEvents_NDClone = 0; TH1D *hRecoEnergyCCOnlyEvents_NDClone = 0; TH1D *hTrueEnergyCCOnlyEvents_NDClone = 0; TH1D *hTrueEnergyTrueCCFidEvents_NDClone = 0; TH1D *hTrueEnergyTrueCCFidEvents_FDClone = 0; TH1D *hTrueEnergyCCOnlyEvents_FDClone = 0; TH1D *hRecoEnergyCCOnlyEvents_FDClone = 0; TH1D *hRecoEnergyAllEvents_FDClone = 0; TH1D* hRecoEnergy_NDClone = 0; TH1D* hRecoEnergy_FDClone = 0; TH1D* hRecoEnergy_ND_NCClone = 0; TH1D* hRecoEnergy_FD_NCClone = 0; TH2D* hRecoVsTrueEnergy_ND_NCClone = 0; TH2D* hRecoVsTrueEnergy_FD_NCClone = 0; TH2D* hRecoVsTrueEnergy_NCClone_truly[ENCTruth::kNumTruths][2] = {{0,},}; TH1D* hCCContamination_FDClone = 0; TH1D* hCCContamination_NDClone = 0; TH2D* hCCContaminationRecoVsTrue_FDClone = 0; TH1D* hNCContamination_FDClone = 0; TH1D* hNCContamination_NDClone = 0; //Matrix method histograms (numubar CC): TH2D *hRecoVsTrueEnergyPQ_NDClone = 0; TH2D *hRecoVsTrueEnergyPQ_FDClone = 0; TH1D *hEfficiencyPQ_NDClone = 0; TH1D *hEfficiencyPQ_FDClone = 0; TH1D *hPurityPQ_NDClone = 0; TH1D *hPurityPQ_FDClone = 0; TH1D *hRecoEnergyAllEventsPQ_NDClone = 0; TH1D *hRecoEnergyCCOnlyEventsPQ_NDClone = 0; TH1D *hTrueEnergyCCOnlyEventsPQ_NDClone = 0; TH1D *hTrueEnergyTrueCCFidEventsPQ_NDClone = 0; TH1D *hTrueEnergyTrueCCFidEventsPQ_FDClone = 0; TH1D *hTrueEnergyCCOnlyEventsPQ_FDClone = 0; TH1D *hRecoEnergyCCOnlyEventsPQ_FDClone = 0; TH1D *hRecoEnergyAllEventsPQ_FDClone = 0; TH1D* hRecoEnergyPQ_NDClone = 0; TH1D* hRecoEnergyPQ_FDClone = 0; TH1D* hCCContaminationPQ_FDClone = 0; TH1D* hCCContaminationPQ_NDClone = 0; TH2D* hCCContaminationRecoVsTruePQ_FDClone = 0; TH1D* hNCContaminationPQ_FDClone = 0; TH1D* hNCContaminationPQ_NDClone = 0; //Matrix method Decay Pipe histograms TH1D* hTrueEnergyAllEventsPQ_NDClone = 0; TH1D* hTrueEnergyAllEventsPQ_FDClone = 0; TH1D* hTrueEnergyDecayPipePQ_NDClone = 0; TH1D* hTrueEnergyDecayPipePQ_FDClone = 0; //Matrix method histograms (numu + numubar CC): TH2D *hRecoVsTrueEnergyAll_NDClone = 0; TH2D *hRecoVsTrueEnergyAll_FDClone = 0; TH1D *hEfficiencyAll_NDClone = 0; TH1D *hEfficiencyAll_FDClone = 0; TH1D *hPurityAll_NDClone = 0; TH1D *hPurityAll_FDClone = 0; TH1D *hRecoEnergyAllEventsAll_NDClone = 0; TH1D *hRecoEnergyCCOnlyEventsAll_NDClone = 0; TH1D *hTrueEnergyCCOnlyEventsAll_NDClone = 0; TH1D *hTrueEnergyTrueCCFidEventsAll_NDClone = 0; TH1D *hTrueEnergyTrueCCFidEventsAll_FDClone = 0; TH1D *hTrueEnergyCCOnlyEventsAll_FDClone = 0; TH1D *hRecoEnergyCCOnlyEventsAll_FDClone = 0; TH1D *hRecoEnergyAllEventsAll_FDClone = 0; TH1D* hRecoEnergyAll_NDClone = 0; TH1D* hRecoEnergyAll_FDClone = 0; //Matrix method histograms (nutau CC): TH2D* hRecoVsTrueEnergyTau_FDClone = 0; TH1D* hEfficiencyTau_FDClone = 0; TH1D* hTrueEnergyTrueCCFidEventsTau_FDClone = 0; TH1D* hTrueEnergyCCOnlyEventsTau_FDClone = 0; //Matrix method histograms (nutaubar CC): TH2D* hRecoVsTrueEnergyTauPQ_FDClone = 0; TH1D* hEfficiencyTauPQ_FDClone = 0; TH1D* hTrueEnergyTrueCCFidEventsTauPQ_FDClone = 0; TH1D* hTrueEnergyCCOnlyEventsTauPQ_FDClone = 0; //Matrix method histograms (nutau + nutaubar CC): TH2D* hRecoVsTrueEnergyTauAll_FDClone = 0; TH1D* hEfficiencyTauAll_FDClone = 0; TH1D* hTrueEnergyTrueCCFidEventsTauAll_FDClone = 0; TH1D* hTrueEnergyCCOnlyEventsTauAll_FDClone = 0; for (Int_t i=0;i<10000;i++){ //get the next file TDirectory* tmpDirInput=input.OpenNextInputFile(); //check file exists if (!tmpDirInput) continue; //store input file directory dirInput=tmpDirInput; gDirectory=dirInput; dirInput->Print(); NuXMLConfig *xmlConfig = (NuXMLConfig*)gROOT->FindObject("NuXMLConfig"); //get the histograms TH1F* hDetector=(TH1F*)gROOT->FindObject("hDetector"); TH1F* hSimFlag=(TH1F*)gROOT->FindObject("hSimFlag"); TH1F* hTrigSrc=(TH1F*)gROOT->FindObject("hTrigSrc"); TH1F* hSpillsPerFile=(TH1F*)gROOT->FindObject("hSpillsPerFile"); TH1F* hTotalPot=(TH1F*)gROOT->FindObject("hTotalPot"); TH1F* hPottortgt=(TH1F*)gROOT->FindObject("hPottortgt"); TH1F* hPotBadtortgt=(TH1F*)gROOT->FindObject("hPotBadtortgt"); TH1F* hPottrtgtd=(TH1F*)gROOT->FindObject("hPottrtgtd"); TH1F* hPotBadtrtgtd=(TH1F*)gROOT->FindObject("hPotBadtrtgtd"); TH1F* hPottor101=(TH1F*)gROOT->FindObject("hPottor101"); TH1F* hPotBadtor101=(TH1F*)gROOT->FindObject("hPotBadtor101"); TH1F* hPottr101d=(TH1F*)gROOT->FindObject("hPottr101d"); TH1F* hPotBadtr101d=(TH1F*)gROOT->FindObject("hPotBadtr101d"); TH1F* hRun=(TH1F*)gROOT->FindObject("hRun"); TH1F* hNtupleEarliestTime=(TH1F*)gROOT->FindObject("hNtupleEarliestTime"); TH1F* hNtupleLatestTime=(TH1F*)gROOT->FindObject("hNtupleLatestTime"); //get Matrix Method histograms (numu CC): TH2D *hRecoVsTrueEnergy_ND = (TH2D*) gROOT->FindObject("RecoVsTrueEnergy_ND"); TH2D *hRecoVsTrueEnergy_FD = (TH2D*) gROOT->FindObject("RecoVsTrueEnergy_FD"); TH1D *hEfficiency_ND = (TH1D*) gROOT->FindObject("Efficiency_ND"); TH1D *hEfficiency_FD = (TH1D*) gROOT->FindObject("Efficiency_FD"); TH1D *hPurity_ND = (TH1D*) gROOT->FindObject("Purity_ND"); TH1D *hPurity_FD = (TH1D*) gROOT->FindObject("Purity_FD"); TH1D *hRecoEnergyAllEvents_ND = (TH1D*) gROOT->FindObject("RecoEnergyAllEvents_ND"); TH1D *hRecoEnergyCCOnlyEvents_ND = (TH1D*) gROOT->FindObject("RecoEnergyCCOnlyEvents_ND"); TH1D *hTrueEnergyCCOnlyEvents_ND = (TH1D*) gROOT->FindObject("TrueEnergyCCOnlyEvents_ND"); TH1D *hTrueEnergyTrueCCFidEvents_ND = (TH1D*) gROOT->FindObject("TrueEnergyTrueCCFidEvents_ND"); TH1D *hTrueEnergyTrueCCFidEvents_FD = (TH1D*) gROOT->FindObject("TrueEnergyTrueCCFidEvents_FD"); TH1D *hTrueEnergyCCOnlyEvents_FD = (TH1D*) gROOT->FindObject("TrueEnergyCCOnlyEvents_FD"); TH1D *hRecoEnergyCCOnlyEvents_FD = (TH1D*) gROOT->FindObject("RecoEnergyCCOnlyEvents_FD"); TH1D *hRecoEnergyAllEvents_FD = (TH1D*) gROOT->FindObject("RecoEnergyAllEvents_FD"); TH1D *hRecoEnergy_ND = (TH1D*) gROOT->FindObject("RecoEnergy_ND"); TH1D *hRecoEnergy_FD = (TH1D*) gROOT->FindObject("RecoEnergy_FD"); TH1D *hRecoEnergy_ND_NC = (TH1D*) gROOT->FindObject("RecoEnergy_ND_NC"); TH1D *hRecoEnergy_FD_NC = (TH1D*) gROOT->FindObject("RecoEnergy_FD_NC"); TH2D *hRecoVsTrueEnergy_ND_NC = (TH2D*) gROOT->FindObject("RecoVsTrueEnergy_ND_NC"); TH2D *hRecoVsTrueEnergy_FD_NC = (TH2D*) gROOT->FindObject("RecoVsTrueEnergy_FD_NC"); TH2D* RecoVsTrueEnergy_NC_truly[ENCTruth::kNumTruths][2]; for(int truth = 0; truth < ENCTruth::kNumTruths; ++truth){ for(int det = 0; det <= 1; ++det){ const TString detstr = det ? "FD" : "ND"; const TString name = "RecoVsTrueEnergy_truly"+ENCTruth::truthNames[truth]+"_"+detstr+"_NC"; RecoVsTrueEnergy_NC_truly[truth][det] = (TH2D*)gROOT->FindObject(name); } } TH1D* hCCContamination_FD =(TH1D*) gROOT->FindObject("CCContamination_FD"); TH1D* hCCContamination_ND =(TH1D*) gROOT->FindObject("CCContamination_ND"); TH2D* hCCContaminationRecoVsTrue_FD =(TH2D*) gROOT->FindObject("CCContaminationRecoVsTrue_FD"); TH1D* hNCContamination_FD =(TH1D*) gROOT->FindObject("NCContamination_FD"); TH1D* hNCContamination_ND =(TH1D*) gROOT->FindObject("NCContamination_ND"); //get Matrix Method histograms (numubar CC): TH2D *hRecoVsTrueEnergyPQ_ND = (TH2D*) gROOT->FindObject("RecoVsTrueEnergyPQ_ND"); TH2D *hRecoVsTrueEnergyPQ_FD = (TH2D*) gROOT->FindObject("RecoVsTrueEnergyPQ_FD"); TH1D *hEfficiencyPQ_ND = (TH1D*) gROOT->FindObject("EfficiencyPQ_ND"); TH1D *hEfficiencyPQ_FD = (TH1D*) gROOT->FindObject("EfficiencyPQ_FD"); TH1D *hPurityPQ_ND = (TH1D*) gROOT->FindObject("PurityPQ_ND"); TH1D *hPurityPQ_FD = (TH1D*) gROOT->FindObject("PurityPQ_FD"); TH1D *hRecoEnergyAllEventsPQ_ND = (TH1D*) gROOT->FindObject("RecoEnergyAllEventsPQ_ND"); TH1D *hRecoEnergyCCOnlyEventsPQ_ND = (TH1D*) gROOT->FindObject("RecoEnergyCCOnlyEventsPQ_ND"); TH1D *hTrueEnergyCCOnlyEventsPQ_ND = (TH1D*) gROOT->FindObject("TrueEnergyCCOnlyEventsPQ_ND"); TH1D *hTrueEnergyTrueCCFidEventsPQ_ND = (TH1D*) gROOT->FindObject("TrueEnergyTrueCCFidEventsPQ_ND"); TH1D *hTrueEnergyTrueCCFidEventsPQ_FD = (TH1D*) gROOT->FindObject("TrueEnergyTrueCCFidEventsPQ_FD"); TH1D *hTrueEnergyCCOnlyEventsPQ_FD = (TH1D*) gROOT->FindObject("TrueEnergyCCOnlyEventsPQ_FD"); TH1D *hRecoEnergyCCOnlyEventsPQ_FD = (TH1D*) gROOT->FindObject("RecoEnergyCCOnlyEventsPQ_FD"); TH1D *hRecoEnergyAllEventsPQ_FD = (TH1D*) gROOT->FindObject("RecoEnergyAllEventsPQ_FD"); TH1D *hRecoEnergyPQ_ND = (TH1D*) gROOT->FindObject("RecoEnergyPQ_ND"); TH1D *hRecoEnergyPQ_FD = (TH1D*) gROOT->FindObject("RecoEnergyPQ_FD"); TH1D* hCCContaminationPQ_FD =(TH1D*) gROOT->FindObject("CCContaminationPQ_FD"); TH1D* hCCContaminationPQ_ND =(TH1D*) gROOT->FindObject("CCContaminationPQ_ND"); TH2D* hCCContaminationRecoVsTruePQ_FD =(TH2D*) gROOT->FindObject("CCContaminationRecoVsTruePQ_FD"); TH1D* hNCContaminationPQ_FD =(TH1D*) gROOT->FindObject("NCContaminationPQ_FD"); TH1D* hNCContaminationPQ_ND =(TH1D*) gROOT->FindObject("NCContaminationPQ_ND"); //get Matrix Method histograms (Decay Pipe) TH1D* hTrueEnergyAllEventsPQ_ND =(TH1D*) gROOT->FindObject("TrueEnergyAllEventsPQ_ND"); TH1D* hTrueEnergyAllEventsPQ_FD =(TH1D*) gROOT->FindObject("TrueEnergyAllEventsPQ_FD"); TH1D* hTrueEnergyDecayPipePQ_ND =(TH1D*) gROOT->FindObject("TrueEnergyDecayPipePQ_ND"); TH1D* hTrueEnergyDecayPipePQ_FD =(TH1D*) gROOT->FindObject("TrueEnergyDecayPipePQ_FD"); //get Matrix Method histograms (numu + numubar CC): TH2D *hRecoVsTrueEnergyAll_ND = (TH2D*) gROOT->FindObject("RecoVsTrueEnergyAll_ND"); TH2D *hRecoVsTrueEnergyAll_FD = (TH2D*) gROOT->FindObject("RecoVsTrueEnergyAll_FD"); TH1D *hEfficiencyAll_ND = (TH1D*) gROOT->FindObject("EfficiencyAll_ND"); TH1D *hEfficiencyAll_FD = (TH1D*) gROOT->FindObject("EfficiencyAll_FD"); TH1D *hPurityAll_ND = (TH1D*) gROOT->FindObject("PurityAll_ND"); TH1D *hPurityAll_FD = (TH1D*) gROOT->FindObject("PurityAll_FD"); TH1D *hRecoEnergyAllEventsAll_ND = (TH1D*) gROOT->FindObject("RecoEnergyAllEventsAll_ND"); TH1D *hRecoEnergyCCOnlyEventsAll_ND = (TH1D*) gROOT->FindObject("RecoEnergyCCOnlyEventsAll_ND"); TH1D *hTrueEnergyCCOnlyEventsAll_ND = (TH1D*) gROOT->FindObject("TrueEnergyCCOnlyEventsAll_ND"); TH1D *hTrueEnergyTrueCCFidEventsAll_ND = (TH1D*) gROOT->FindObject("TrueEnergyTrueCCFidEventsAll_ND"); TH1D *hTrueEnergyTrueCCFidEventsAll_FD = (TH1D*) gROOT->FindObject("TrueEnergyTrueCCFidEventsAll_FD"); TH1D *hTrueEnergyCCOnlyEventsAll_FD = (TH1D*) gROOT->FindObject("TrueEnergyCCOnlyEventsAll_FD"); TH1D *hRecoEnergyCCOnlyEventsAll_FD = (TH1D*) gROOT->FindObject("RecoEnergyCCOnlyEventsAll_FD"); TH1D *hRecoEnergyAllEventsAll_FD = (TH1D*) gROOT->FindObject("RecoEnergyAllEventsAll_FD"); TH1D *hRecoEnergyAll_ND = (TH1D*) gROOT->FindObject("RecoEnergyAll_ND"); TH1D *hRecoEnergyAll_FD = (TH1D*) gROOT->FindObject("RecoEnergyAll_FD"); //get Matrix Method histograms (nutau CC): TH2D* hRecoVsTrueEnergyTau_FD = (TH2D*) gROOT->FindObject("RecoVsTrueEnergyTau_FD"); TH1D* hEfficiencyTau_FD = (TH1D*) gROOT->FindObject("EfficiencyTau_FD"); TH1D* hTrueEnergyTrueCCFidEventsTau_FD = (TH1D*) gROOT->FindObject("TrueEnergyTrueCCFidEventsTau_FD"); TH1D* hTrueEnergyCCOnlyEventsTau_FD = (TH1D*) gROOT->FindObject("TrueEnergyCCOnlyEventsTau_FD"); //get Matrix Method histograms (nutaubar CC): TH2D* hRecoVsTrueEnergyTauPQ_FD = (TH2D*) gROOT->FindObject("RecoVsTrueEnergyTauPQ_FD"); TH1D* hEfficiencyTauPQ_FD = (TH1D*) gROOT->FindObject("EfficiencyTauPQ_FD"); TH1D* hTrueEnergyTrueCCFidEventsTauPQ_FD = (TH1D*) gROOT->FindObject("TrueEnergyTrueCCFidEventsTauPQ_FD"); TH1D* hTrueEnergyCCOnlyEventsTauPQ_FD = (TH1D*) gROOT->FindObject("TrueEnergyCCOnlyEventsTauPQ_FD"); //get Matrix Method histograms (nutau CC): TH2D* hRecoVsTrueEnergyTauAll_FD = (TH2D*) gROOT->FindObject("RecoVsTrueEnergyTauAll_FD"); TH1D* hEfficiencyTauAll_FD = (TH1D*) gROOT->FindObject("EfficiencyTauAll_FD"); TH1D* hTrueEnergyTrueCCFidEventsTauAll_FD = (TH1D*) gROOT->FindObject("TrueEnergyTrueCCFidEventsTauAll_FD"); TH1D* hTrueEnergyCCOnlyEventsTauAll_FD = (TH1D*) gROOT->FindObject("TrueEnergyCCOnlyEventsTauAll_FD"); //check if histo found if (!hPottortgt) { MSG("NuDSTAna",Msg::kWarning) <<"hPottortgt does not exist in file:"<<endl; dirInput->Print(); // There is not always an hPottortgt //continue; } //clone the histos for the first file if (!hPottortgtClone) { MSG("NuDSTAna",Msg::kInfo) << "Clone the histos for the first file" << endl; if (xmlConfig) { MSG("NuDSTAna",Msg::kInfo)<< "NuXMLConfig cloned from input file" << endl; xmlConfigClone = (NuXMLConfig*)xmlConfig->Clone("NuXMLConfigClone"); } else { MSG("NuDSTAna",Msg::kInfo) <<"No NuXMLConfig object found in input" <<" file (not necessarily unexpected)" << endl; } hDetectorClone=(TH1F*)hDetector->Clone("hDetectorClone"); hSimFlagClone=(TH1F*)hSimFlag->Clone("hSimFlagClone"); hTrigSrcClone=(TH1F*)hTrigSrc->Clone("hTrigSrcClone"); hSpillsPerFileClone=(TH1F*)hSpillsPerFile->Clone("hSpillsPerFileClone"); if (hTotalPot) { hTotalPotClone=(TH1F*)hTotalPot->Clone("hTotalPotClone"); } hPottortgtClone=(TH1F*)hPottortgt->Clone("hPottortgtClone"); hPotBadtortgtClone=(TH1F*)hPotBadtortgt->Clone("hPotBadtortgtClone"); hPottrtgtdClone=(TH1F*)hPottrtgtd->Clone("hPottrtgtdClone"); hPotBadtrtgtdClone=(TH1F*)hPotBadtrtgtd->Clone("hPotBadtrtgtdClone"); hPottor101Clone=(TH1F*)hPottor101->Clone("hPottor101Clone"); hPotBadtor101Clone=(TH1F*)hPotBadtor101->Clone("hPotBadtor101Clone"); hPottr101dClone=(TH1F*)hPottr101d->Clone("hPottr101dClone"); hPotBadtr101dClone=(TH1F*)hPotBadtr101d->Clone("hPotBadtr101dClone"); hRunClone=(TH1F*)hRun->Clone("hRunClone"); Double_t earliestTime=2000000000; Double_t latestTime=0; if (hNtupleLatestTime) { hNtupleLatestTimeClone=(TH1F*)hNtupleLatestTime->Clone("hNtupleLatestTimeClone"); hNtupleEarliestTimeClone=(TH1F*)hNtupleEarliestTime->Clone("hNtupleEarliestTimeClone"); //get the times earliestTime=hNtupleEarliestTimeClone->Integral(); latestTime=hNtupleLatestTimeClone->Integral(); MSG("NuDSTAna",Msg::kInfo) <<"First histo: earliestTime="<<ffmt(earliestTime) <<", latestTime="<<ffmt(latestTime)<<endl; } else {//only run once MSG("NuDSTAna",Msg::kInfo) <<"DoIO: hNtupleLatestTime not found"<<endl; } //after and before are the same for the first file Float_t potBefore=hPottortgtClone->GetMean()* hPottortgtClone->GetEntries(); Float_t potAfter=hPottortgtClone->GetMean()* hPottortgtClone->GetEntries(); Float_t runBefore=hRunClone->GetEntries(); Float_t runAfter=hRunClone->GetEntries(); MSG("NuDSTAna",Msg::kInfo) <<"First histo: potBefore="<<potBefore*1e12 <<", potAfter="<<potAfter*1e12<<endl; MSG("NuDSTAna",Msg::kInfo) <<"First histo: runBefore="<<runBefore <<", runAfter="<<runAfter<<endl; //check that MM histos exist if (!hRecoVsTrueEnergyPQ_FD) { MSG("NuDSTAna",Msg::kInfo) << "MM Histos not gettting cloned" << endl; } else { MSG("NuDSTAna",Msg::kInfo) << "Cloning MM histos" << endl; //clone the MM histograms (numu CC): hRecoVsTrueEnergy_NDClone = (TH2D*) hRecoVsTrueEnergy_ND->Clone("hRecoVsTrueEnergy_NDClone"); hRecoVsTrueEnergy_FDClone = (TH2D*) hRecoVsTrueEnergy_FD->Clone("hRecoVsTrueEnergy_FDClone"); hEfficiency_NDClone = (TH1D*) hEfficiency_ND->Clone("hEfficiency_NDClone"); hEfficiency_FDClone = (TH1D*) hEfficiency_FD->Clone("hEfficiency_FDClone"); hPurity_NDClone = (TH1D*) hPurity_ND->Clone("hPurity_NDClone"); hPurity_FDClone = (TH1D*) hPurity_FD->Clone("hPurity_FDClone"); hRecoEnergyAllEvents_NDClone = (TH1D*) hRecoEnergyAllEvents_ND->Clone("hRecoEnergyAllEvents_NDClone"); hRecoEnergyCCOnlyEvents_NDClone = (TH1D*) hRecoEnergyCCOnlyEvents_ND->Clone("hRecoEnergyCCOnlyEvents_NDClone"); hTrueEnergyCCOnlyEvents_NDClone = (TH1D*) hTrueEnergyCCOnlyEvents_ND->Clone("hTrueEnergyCCOnlyEvents_NDClone"); if (hTrueEnergyTrueCCFidEvents_ND){ hTrueEnergyTrueCCFidEvents_NDClone = (TH1D*) hTrueEnergyTrueCCFidEvents_ND-> Clone("hTrueEnergyTrueCCFidEvents_NDClone"); } if (hTrueEnergyTrueCCFidEvents_FD){ hTrueEnergyTrueCCFidEvents_FDClone = (TH1D*) hTrueEnergyTrueCCFidEvents_FD->Clone("hTrueEnergyTrueCCFidEvents_FDClone"); } hTrueEnergyCCOnlyEvents_FDClone = (TH1D*) hTrueEnergyCCOnlyEvents_FD->Clone("hTrueEnergyCCOnlyEvents_FDClone"); hRecoEnergyCCOnlyEvents_FDClone = (TH1D*) hRecoEnergyCCOnlyEvents_FD->Clone("hRecoEnergyCCOnlyEvents_FDClone"); hRecoEnergyAllEvents_FDClone = (TH1D*) hRecoEnergyAllEvents_FD->Clone("hRecoEnergyAllEvents_FDClone"); hRecoEnergy_NDClone = (TH1D*) hRecoEnergy_ND->Clone("hRecoEnergy_NDClone"); hRecoEnergy_FDClone = (TH1D*) hRecoEnergy_FD->Clone("hRecoEnergy_FDClone"); if (hRecoEnergy_ND_NC){ hRecoEnergy_ND_NCClone = (TH1D*) hRecoEnergy_ND_NC->Clone("hRecoEnergy_ND_NCClone"); } if (hRecoEnergy_FD_NC){ hRecoEnergy_FD_NCClone = (TH1D*) hRecoEnergy_FD_NC->Clone("hRecoEnergy_FD_NCClone"); } if (hRecoVsTrueEnergy_ND_NC){ hRecoVsTrueEnergy_ND_NCClone= (TH2D*) hRecoVsTrueEnergy_ND_NC->Clone("hRecoVsTrueEnergy_ND_NCClone"); } if (hRecoVsTrueEnergy_FD_NC){ hRecoVsTrueEnergy_FD_NCClone= (TH2D*) hRecoVsTrueEnergy_FD_NC->Clone("hRecoVsTrueEnergy_FD_NCClone"); } for(int truth = 0; truth < ENCTruth::kNumTruths; ++truth){ for(int det = 0; det <= 1; ++det){ const TString detstr = det ? "FD" : "ND"; if (RecoVsTrueEnergy_NC_truly[truth][det]){ hRecoVsTrueEnergy_NCClone_truly[truth][det] = (TH2D*)RecoVsTrueEnergy_NC_truly[truth][det]->Clone("RecoVsTrueEnergy_truly"+ENCTruth::truthNames[truth]+"_"+detstr+"_NC"); } } } if (hCCContamination_FD){ hCCContamination_FDClone = (TH1D*) hCCContamination_FD->Clone("hCCContamination_FDClone"); if (hCCContaminationRecoVsTrue_FD){ hCCContaminationRecoVsTrue_FDClone = (TH2D*) hCCContaminationRecoVsTrue_FD->Clone("hCCContaminationRecoVsTrue_FDClone"); } hNCContamination_FDClone = (TH1D*) hNCContamination_FD->Clone("hNCContamination_FDClone"); } if (hCCContamination_ND){ hCCContamination_NDClone = (TH1D*) hCCContamination_ND->Clone("hCCContamination_NDClone"); } if (hNCContamination_ND){ hNCContamination_NDClone = (TH1D*) hNCContamination_ND->Clone("hNCContamination_NDClone"); } //clone the MM histograms (numubar CC): hRecoVsTrueEnergyPQ_NDClone = (TH2D*) hRecoVsTrueEnergyPQ_ND->Clone("hRecoVsTrueEnergyPQ_NDClone"); hRecoVsTrueEnergyPQ_FDClone = (TH2D*) hRecoVsTrueEnergyPQ_FD->Clone("hRecoVsTrueEnergyPQ_FDClone"); hEfficiencyPQ_NDClone = (TH1D*) hEfficiencyPQ_ND->Clone("hEfficiencyPQ_NDClone"); hEfficiencyPQ_FDClone = (TH1D*) hEfficiencyPQ_FD->Clone("hEfficiencyPQ_FDClone"); hPurityPQ_NDClone = (TH1D*) hPurityPQ_ND->Clone("hPurityPQ_NDClone"); hPurityPQ_FDClone = (TH1D*) hPurityPQ_FD->Clone("hPurityPQ_FDClone"); hRecoEnergyAllEventsPQ_NDClone = (TH1D*) hRecoEnergyAllEventsPQ_ND->Clone("hRecoEnergyAllEventsPQ_NDClone"); hRecoEnergyCCOnlyEventsPQ_NDClone = (TH1D*) hRecoEnergyCCOnlyEventsPQ_ND->Clone("hRecoEnergyCCOnlyEventsPQ_NDClone"); hTrueEnergyCCOnlyEventsPQ_NDClone = (TH1D*) hTrueEnergyCCOnlyEventsPQ_ND->Clone("hTrueEnergyCCOnlyEventsPQ_NDClone"); if (hTrueEnergyTrueCCFidEventsPQ_ND){ hTrueEnergyTrueCCFidEventsPQ_NDClone = (TH1D*) hTrueEnergyTrueCCFidEventsPQ_ND->Clone("hTrueEnergyTrueCCFidEventsPQ_NDClone"); } if (hTrueEnergyTrueCCFidEventsPQ_FD){ hTrueEnergyTrueCCFidEventsPQ_FDClone = (TH1D*) hTrueEnergyTrueCCFidEventsPQ_FD->Clone("hTrueEnergyTrueCCFidEventsPQ_FDClone"); } hTrueEnergyCCOnlyEventsPQ_FDClone = (TH1D*) hTrueEnergyCCOnlyEventsPQ_FD->Clone("hTrueEnergyCCOnlyEventsPQ_FDClone"); hRecoEnergyCCOnlyEventsPQ_FDClone = (TH1D*) hRecoEnergyCCOnlyEventsPQ_FD->Clone("hRecoEnergyCCOnlyEventsPQ_FDClone"); hRecoEnergyAllEventsPQ_FDClone = (TH1D*) hRecoEnergyAllEventsPQ_FD->Clone("hRecoEnergyAllEventsPQ_FDClone"); hRecoEnergyPQ_NDClone = (TH1D*) hRecoEnergyPQ_ND->Clone("hRecoEnergyPQ_NDClone"); hRecoEnergyPQ_FDClone = (TH1D*) hRecoEnergyPQ_FD->Clone("hRecoEnergyPQ_FDClone"); if (hCCContaminationPQ_FD){ hCCContaminationPQ_FDClone = (TH1D*) hCCContaminationPQ_FD-> Clone("hCCContaminationPQ_FDClone"); if (hCCContaminationRecoVsTruePQ_FD){ hCCContaminationRecoVsTruePQ_FDClone = (TH2D*) hCCContaminationRecoVsTruePQ_FD->Clone("hCCContaminationRecoVsTruePQ_FDClone"); } hNCContaminationPQ_FDClone =(TH1D*) hNCContaminationPQ_FD->Clone("hNCContaminationPQ_FDClone"); } if (hCCContaminationPQ_ND){ hCCContaminationPQ_NDClone = (TH1D*) hCCContaminationPQ_ND->Clone("hCCContaminationPQ_NDClone"); } if (hNCContaminationPQ_ND){ hNCContaminationPQ_NDClone = (TH1D*) hNCContaminationPQ_ND->Clone("hNCContaminationPQ_NDClone"); } //clone the MM histograms (Decay Pipe) if (hTrueEnergyAllEventsPQ_ND){ hTrueEnergyAllEventsPQ_NDClone = (TH1D*) hTrueEnergyAllEventsPQ_ND->Clone("hTrueEnergyAllEventsPQ_NDClone"); } if (hTrueEnergyAllEventsPQ_FD){ hTrueEnergyAllEventsPQ_FDClone = (TH1D*) hTrueEnergyAllEventsPQ_FD->Clone("hTrueEnergyAllEventsPQ_FDClone"); } if (hTrueEnergyDecayPipePQ_ND){ hTrueEnergyDecayPipePQ_NDClone = (TH1D*) hTrueEnergyDecayPipePQ_ND->Clone("hTrueEnergyDecayPipePQ_NDClone"); } if (hTrueEnergyDecayPipePQ_FD){ hTrueEnergyDecayPipePQ_FDClone = (TH1D*) hTrueEnergyDecayPipePQ_FD->Clone("hTrueEnergyDecayPipePQ_FDClone"); } //clone the MM histograms (numu + numubar CC): hRecoVsTrueEnergyAll_NDClone = (TH2D*) hRecoVsTrueEnergyAll_ND->Clone("hRecoVsTrueEnergyAll_NDClone"); hRecoVsTrueEnergyAll_FDClone = (TH2D*) hRecoVsTrueEnergyAll_FD->Clone("hRecoVsTrueEnergyAll_FDClone"); hEfficiencyAll_NDClone = (TH1D*) hEfficiencyAll_ND->Clone("hEfficiencyAll_NDClone"); hEfficiencyAll_FDClone = (TH1D*) hEfficiencyAll_FD->Clone("hEfficiencyAll_FDClone"); hPurityAll_NDClone = (TH1D*) hPurityAll_ND->Clone("hPurityAll_NDClone"); hPurityAll_FDClone = (TH1D*) hPurityAll_FD->Clone("hPurityAll_FDClone"); hRecoEnergyAllEventsAll_NDClone = (TH1D*) hRecoEnergyAllEventsAll_ND->Clone("hRecoEnergyAllEventsAll_NDClone"); hRecoEnergyCCOnlyEventsAll_NDClone = (TH1D*) hRecoEnergyCCOnlyEventsAll_ND->Clone("hRecoEnergyCCOnlyEventsAll_NDClone"); hTrueEnergyCCOnlyEventsAll_NDClone = (TH1D*) hTrueEnergyCCOnlyEventsAll_ND->Clone("hTrueEnergyCCOnlyEventsAll_NDClone"); if (hTrueEnergyTrueCCFidEventsAll_ND){ hTrueEnergyTrueCCFidEventsAll_NDClone = (TH1D*) hTrueEnergyTrueCCFidEventsAll_ND->Clone("hTrueEnergyTrueCCFidEventsAll_NDClone"); } if (hTrueEnergyTrueCCFidEventsAll_FD){ hTrueEnergyTrueCCFidEventsAll_FDClone = (TH1D*) hTrueEnergyTrueCCFidEventsAll_FD->Clone("hTrueEnergyTrueCCFidEventsAll_FDClone"); } hTrueEnergyCCOnlyEventsAll_FDClone = (TH1D*) hTrueEnergyCCOnlyEventsAll_FD->Clone("hTrueEnergyCCOnlyEventsAll_FDClone"); hRecoEnergyCCOnlyEventsAll_FDClone = (TH1D*) hRecoEnergyCCOnlyEventsAll_FD->Clone("hRecoEnergyCCOnlyEventsAll_FDClone"); hRecoEnergyAllEventsAll_FDClone = (TH1D*) hRecoEnergyAllEventsAll_FD->Clone("hRecoEnergyAllEventsAll_FDClone"); hRecoEnergyAll_NDClone = (TH1D*) hRecoEnergyAll_ND->Clone("hRecoEnergyAll_NDClone"); hRecoEnergyAll_FDClone = (TH1D*) hRecoEnergyAll_FD->Clone("hRecoEnergyAll_FDClone"); //Clone the taus: if (hEfficiencyTau_FD){ hEfficiencyTau_FDClone = (TH1D*) hEfficiencyTau_FD->Clone("hEfficiencyTau_FDClone"); } if (hRecoVsTrueEnergyTau_FD){ hRecoVsTrueEnergyTau_FDClone = (TH2D*) hRecoVsTrueEnergyTau_FD->Clone("hRecoVsTrueEnergyTau_FDClone"); } if (hTrueEnergyTrueCCFidEventsTau_FD){ hTrueEnergyTrueCCFidEventsTau_FDClone = (TH1D*) hTrueEnergyTrueCCFidEventsTau_FD->Clone("hTrueEnergyTrueCCFidEventsTau_FDClone"); } if (hTrueEnergyCCOnlyEventsTau_FD){ hTrueEnergyCCOnlyEventsTau_FDClone = (TH1D*) hTrueEnergyCCOnlyEventsTau_FD->Clone("hTrueEnergyCCOnlyEventsTau_FDClone"); } //Clone the taubars: if (hEfficiencyTauPQ_FD){ hEfficiencyTauPQ_FDClone = (TH1D*) hEfficiencyTauPQ_FD->Clone("hEfficiencyTauPQ_FDClone"); } if (hRecoVsTrueEnergyTauPQ_FD){ hRecoVsTrueEnergyTauPQ_FDClone = (TH2D*) hRecoVsTrueEnergyTauPQ_FD->Clone("hRecoVsTrueEnergyTauPQ_FDClone"); } if (hTrueEnergyTrueCCFidEventsTauPQ_FD){ hTrueEnergyTrueCCFidEventsTauPQ_FDClone = (TH1D*) hTrueEnergyTrueCCFidEventsTauPQ_FD->Clone("hTrueEnergyTrueCCFidEventsTauPQ_FDClone"); } if (hTrueEnergyCCOnlyEventsTauPQ_FD){ hTrueEnergyCCOnlyEventsTauPQ_FDClone = (TH1D*) hTrueEnergyCCOnlyEventsTauPQ_FD->Clone("hTrueEnergyCCOnlyEventsTauPQ_FDClone"); } //Clone the taus + taubars: if (hEfficiencyTauAll_FD){ hEfficiencyTauAll_FDClone = (TH1D*) hEfficiencyTauAll_FD->Clone("hEfficiencyTauAll_FDClone"); } if (hRecoVsTrueEnergyTauAll_FD){ hRecoVsTrueEnergyTauAll_FDClone = (TH2D*) hRecoVsTrueEnergyTauAll_FD->Clone("hRecoVsTrueEnergyTauAll_FDClone"); } if (hTrueEnergyTrueCCFidEventsTauAll_FD){ hTrueEnergyTrueCCFidEventsTauAll_FDClone = (TH1D*) hTrueEnergyTrueCCFidEventsTauAll_FD->Clone("hTrueEnergyTrueCCFidEventsTauAll_FDClone"); } if (hTrueEnergyCCOnlyEventsTauAll_FD){ hTrueEnergyCCOnlyEventsTauAll_FDClone = (TH1D*) hTrueEnergyCCOnlyEventsTauAll_FD->Clone("hTrueEnergyCCOnlyEventsTauAll_FDClone"); } } } else {//for second file onwards add the new histo to the clone MSG("NuDSTAna",Msg::kInfo) << "Adding up pots for later files" << endl; Float_t potBefore=hPottortgtClone->GetMean()* hPottortgtClone->GetEntries(); Float_t potNew=hPottortgt->GetMean()*hPottortgt->GetEntries(); Float_t runBefore=hRunClone->GetEntries(); if (hNtupleLatestTime && hNtupleLatestTimeClone) { Double_t earliestTime=2000000000; Double_t latestTime=0; Double_t newEarliestTime=2000000000; Double_t newLatestTime=0; //get the times from clone earliestTime=hNtupleEarliestTimeClone->Integral(); latestTime=hNtupleLatestTimeClone->Integral(); //get the next set of times newEarliestTime=hNtupleEarliestTime->Integral(); newLatestTime=hNtupleLatestTime->Integral(); MAXMSG("NuDSTAna",Msg::kInfo,5) <<"Previous file(s): earliestTime="<<ffmt(earliestTime) <<", latestTime="<<ffmt(latestTime)<<endl <<"This file: earliestTime="<<ffmt(newEarliestTime) <<", latestTime="<<ffmt(newLatestTime)<<endl; //work out which time is the earliest/latest if (newEarliestTime<earliestTime) { Float_t oldT=earliestTime; earliestTime=newEarliestTime; hNtupleEarliestTimeClone->Reset("ICE"); hNtupleEarliestTimeClone->Fill(1,earliestTime); MSG("NuDSTAna",Msg::kInfo) <<"Using new earliestTime="<<ffmt(earliestTime) <<" (was "<<ffmt(oldT)<<")"<<endl; } if (newLatestTime>latestTime) { Float_t oldT=latestTime; latestTime=newLatestTime; hNtupleLatestTimeClone->Reset("ICE"); hNtupleLatestTimeClone->Fill(1,latestTime); MSG("NuDSTAna",Msg::kInfo) <<"Using new latestTime="<<ffmt(latestTime) <<" (was "<<ffmt(oldT)<<")"<<endl; } } else { MAXMSG("NuDSTAna",Msg::kInfo,3) <<"DoIO: Next file hNtupleLatestTime not found"<<endl; } //add the histos up //don't need to do this for //hDetectorClone //hSimFlagClone //hTrigSrcClone //hSpillsPerFileClone if (hTotalPotClone) hTotalPotClone->Add(hTotalPot); hPottortgtClone->Add(hPottortgt); hPotBadtortgtClone->Add(hPotBadtortgt); hPottrtgtdClone->Add(hPottrtgtd); hPotBadtrtgtdClone->Add(hPotBadtrtgtd); hPottor101Clone->Add(hPottor101); hPotBadtor101Clone->Add(hPotBadtor101); hPottr101dClone->Add(hPottr101d); hPotBadtr101dClone->Add(hPotBadtr101d); hRunClone->Add(hRun); Float_t potAfter=hPottortgtClone->GetMean()* hPottortgtClone->GetEntries(); Float_t runAfter=hRunClone->GetEntries(); MSG("NuDSTAna",Msg::kInfo) <<"Adding histos: potBefore="<<potBefore*1e12 <<", potAfter="<<potAfter*1e12 <<", potNew="<<potNew*1e12<<endl; MSG("NuDSTAna",Msg::kInfo) <<"Adding histos: runsBefore="<<runBefore <<", runsAfter="<<runAfter<<endl; //Add the MM histograms up (if they exist) (numu CC): if (hRecoVsTrueEnergyPQ_FDClone) { MSG("NuDSTAna",Msg::kInfo) << "Adding to MM histos" << endl; hRecoVsTrueEnergy_NDClone->Add(hRecoVsTrueEnergy_ND); hRecoVsTrueEnergy_FDClone->Add(hRecoVsTrueEnergy_FD); hEfficiency_NDClone->Add(hEfficiency_ND); hEfficiency_FDClone->Add(hEfficiency_FD); hPurity_NDClone->Add(hPurity_ND); hPurity_FDClone->Add(hPurity_FD); hRecoEnergyAllEvents_NDClone->Add(hRecoEnergyAllEvents_ND); hRecoEnergyCCOnlyEvents_NDClone->Add(hRecoEnergyCCOnlyEvents_ND); hTrueEnergyCCOnlyEvents_NDClone->Add(hTrueEnergyCCOnlyEvents_ND); if (hTrueEnergyTrueCCFidEvents_NDClone){ hTrueEnergyTrueCCFidEvents_NDClone->Add(hTrueEnergyTrueCCFidEvents_ND); } if (hTrueEnergyTrueCCFidEvents_FDClone){ hTrueEnergyTrueCCFidEvents_FDClone->Add(hTrueEnergyTrueCCFidEvents_FD); } hTrueEnergyCCOnlyEvents_FDClone->Add(hTrueEnergyCCOnlyEvents_FD); hRecoEnergyCCOnlyEvents_FDClone->Add(hRecoEnergyCCOnlyEvents_FD); hRecoEnergyAllEvents_FDClone->Add(hRecoEnergyAllEvents_FD); hRecoEnergy_NDClone->Add(hRecoEnergy_ND); hRecoEnergy_FDClone->Add(hRecoEnergy_FD); if (hRecoEnergy_ND_NCClone){ hRecoEnergy_ND_NCClone->Add(hRecoEnergy_ND_NC); } if (hRecoEnergy_FD_NCClone){ hRecoEnergy_FD_NCClone->Add(hRecoEnergy_FD_NC); } if (hRecoVsTrueEnergy_ND_NCClone){ hRecoVsTrueEnergy_ND_NCClone->Add(hRecoVsTrueEnergy_ND_NC); } if (hRecoVsTrueEnergy_ND_NCClone){ hRecoVsTrueEnergy_FD_NCClone->Add(hRecoVsTrueEnergy_FD_NC); } for(int truth = 0; truth < ENCTruth::kNumTruths; ++truth){ for(int det = 0; det <= 1; ++det){ if (hRecoVsTrueEnergy_NCClone_truly[truth][det]){ hRecoVsTrueEnergy_NCClone_truly[truth][det]-> Add(RecoVsTrueEnergy_NC_truly[truth][det]); } } } if (hCCContamination_FDClone){ hCCContamination_FDClone->Add(hCCContamination_FD); if (hCCContaminationRecoVsTrue_FDClone){ hCCContaminationRecoVsTrue_FDClone->Add(hCCContaminationRecoVsTrue_FD); } hNCContamination_FDClone->Add(hNCContamination_FD); if (hCCContamination_NDClone){ hCCContamination_NDClone->Add(hCCContamination_ND); } if (hNCContamination_NDClone){ hNCContamination_NDClone->Add(hNCContamination_ND); } } //Add the MM histograms up (Decay Pipe): if(hTrueEnergyAllEventsPQ_NDClone) { hTrueEnergyAllEventsPQ_NDClone->Add(hTrueEnergyAllEventsPQ_ND); } if(hTrueEnergyAllEventsPQ_FDClone) { hTrueEnergyAllEventsPQ_FDClone->Add(hTrueEnergyAllEventsPQ_FD); } if(hTrueEnergyDecayPipePQ_NDClone) { hTrueEnergyDecayPipePQ_NDClone->Add(hTrueEnergyDecayPipePQ_ND); } if(hTrueEnergyDecayPipePQ_FDClone) { hTrueEnergyDecayPipePQ_FDClone->Add(hTrueEnergyDecayPipePQ_FD); } //Add the MM histograms up (numubar CC): hRecoVsTrueEnergyPQ_NDClone->Add(hRecoVsTrueEnergyPQ_ND); hRecoVsTrueEnergyPQ_FDClone->Add(hRecoVsTrueEnergyPQ_FD); hEfficiencyPQ_NDClone->Add(hEfficiencyPQ_ND); hEfficiencyPQ_FDClone->Add(hEfficiencyPQ_FD); hPurityPQ_NDClone->Add(hPurityPQ_ND); hPurityPQ_FDClone->Add(hPurityPQ_FD); hRecoEnergyAllEventsPQ_NDClone->Add(hRecoEnergyAllEventsPQ_ND); hRecoEnergyCCOnlyEventsPQ_NDClone->Add(hRecoEnergyCCOnlyEventsPQ_ND); hTrueEnergyCCOnlyEventsPQ_NDClone->Add(hTrueEnergyCCOnlyEventsPQ_ND); if (hTrueEnergyTrueCCFidEventsPQ_NDClone){ hTrueEnergyTrueCCFidEventsPQ_NDClone->Add(hTrueEnergyTrueCCFidEventsPQ_ND); } if (hTrueEnergyTrueCCFidEventsPQ_FDClone){ hTrueEnergyTrueCCFidEventsPQ_FDClone->Add(hTrueEnergyTrueCCFidEventsPQ_FD); } hTrueEnergyCCOnlyEventsPQ_FDClone->Add(hTrueEnergyCCOnlyEventsPQ_FD); hRecoEnergyCCOnlyEventsPQ_FDClone->Add(hRecoEnergyCCOnlyEventsPQ_FD); hRecoEnergyAllEventsPQ_FDClone->Add(hRecoEnergyAllEventsPQ_FD); hRecoEnergyPQ_NDClone->Add(hRecoEnergyPQ_ND); hRecoEnergyPQ_FDClone->Add(hRecoEnergyPQ_FD); if (hCCContaminationPQ_FDClone){ hCCContaminationPQ_FDClone->Add(hCCContaminationPQ_FD); if (hCCContaminationRecoVsTruePQ_FDClone){ hCCContaminationRecoVsTruePQ_FDClone->Add(hCCContaminationRecoVsTruePQ_FD); } hNCContaminationPQ_FDClone->Add(hNCContaminationPQ_FD); if (hCCContaminationPQ_NDClone){ hCCContaminationPQ_NDClone-> Add(hCCContaminationPQ_ND); } if (hNCContaminationPQ_NDClone){ hNCContaminationPQ_NDClone-> Add(hNCContaminationPQ_ND); } } //Add the MM histograms up (numu + numubar CC): hRecoVsTrueEnergyAll_NDClone->Add(hRecoVsTrueEnergyAll_ND); hRecoVsTrueEnergyAll_FDClone->Add(hRecoVsTrueEnergyAll_FD); hEfficiencyAll_NDClone->Add(hEfficiencyAll_ND); hEfficiencyAll_FDClone->Add(hEfficiencyAll_FD); hPurityAll_NDClone->Add(hPurityAll_ND); hPurityAll_FDClone->Add(hPurityAll_FD); hRecoEnergyAllEventsAll_NDClone->Add(hRecoEnergyAllEventsAll_ND); hRecoEnergyCCOnlyEventsAll_NDClone->Add(hRecoEnergyCCOnlyEventsAll_ND); hTrueEnergyCCOnlyEventsAll_NDClone->Add(hTrueEnergyCCOnlyEventsAll_ND); if (hTrueEnergyTrueCCFidEventsAll_NDClone){ hTrueEnergyTrueCCFidEventsAll_NDClone->Add(hTrueEnergyTrueCCFidEventsAll_ND); } if (hTrueEnergyTrueCCFidEventsAll_FDClone){ hTrueEnergyTrueCCFidEventsAll_FDClone->Add(hTrueEnergyTrueCCFidEventsAll_FD); } hTrueEnergyCCOnlyEventsAll_FDClone->Add(hTrueEnergyCCOnlyEventsAll_FD); hRecoEnergyCCOnlyEventsAll_FDClone->Add(hRecoEnergyCCOnlyEventsAll_FD); hRecoEnergyAllEventsAll_FDClone->Add(hRecoEnergyAllEventsAll_FD); hRecoEnergyAll_NDClone->Add(hRecoEnergyAll_ND); hRecoEnergyAll_FDClone->Add(hRecoEnergyAll_FD); //Add the MM histograms up (nutau CC): if (hRecoVsTrueEnergyTau_FDClone){ hRecoVsTrueEnergyTau_FDClone->Add(hRecoVsTrueEnergyTau_FD); } if (hEfficiencyTau_FDClone){ hEfficiencyTau_FDClone->Add(hEfficiencyTau_FD); } if (hTrueEnergyTrueCCFidEventsTau_FDClone){ hTrueEnergyTrueCCFidEventsTau_FDClone->Add(hTrueEnergyTrueCCFidEventsTau_FD); } if (hTrueEnergyCCOnlyEventsTau_FDClone){ hTrueEnergyCCOnlyEventsTau_FDClone->Add(hTrueEnergyCCOnlyEventsTau_FD); } //Add the MM histograms up (nutaubar CC): if (hRecoVsTrueEnergyTauPQ_FDClone){ hRecoVsTrueEnergyTauPQ_FDClone->Add(hRecoVsTrueEnergyTauPQ_FD); } if (hEfficiencyTauPQ_FDClone){ hEfficiencyTauPQ_FDClone->Add(hEfficiencyTauPQ_FD); } if (hTrueEnergyTrueCCFidEventsTauPQ_FDClone){ hTrueEnergyTrueCCFidEventsTauPQ_FDClone->Add(hTrueEnergyTrueCCFidEventsTauPQ_FD); } if (hTrueEnergyCCOnlyEventsTauPQ_FDClone){ hTrueEnergyCCOnlyEventsTauPQ_FDClone->Add(hTrueEnergyCCOnlyEventsTauPQ_FD); } //Add the MM histograms up (nutau + nutaubar CC): if (hRecoVsTrueEnergyTauAll_FDClone){ hRecoVsTrueEnergyTauAll_FDClone->Add(hRecoVsTrueEnergyTauAll_FD); } if (hEfficiencyTauAll_FDClone){ hEfficiencyTauAll_FDClone->Add(hEfficiencyTauAll_FD); } if (hTrueEnergyTrueCCFidEventsTauAll_FDClone){ hTrueEnergyTrueCCFidEventsTauAll_FDClone->Add(hTrueEnergyTrueCCFidEventsTauAll_FD); } if (hTrueEnergyCCOnlyEventsTauAll_FDClone){ hTrueEnergyCCOnlyEventsTauAll_FDClone->Add(hTrueEnergyCCOnlyEventsTauAll_FD); } } } } //Normalise the ND reco v. true CC matrix (if exists) if (hRecoVsTrueEnergyPQ_FDClone) { MSG("NuDSTAna",Msg::kInfo) << "Doing MM Normalization" << endl; for(int i=1;i<=hRecoVsTrueEnergy_NDClone->GetNbinsX();i++){ //loop over true bins for(int j=1;j<=hRecoVsTrueEnergy_NDClone->GetNbinsY()+1;j++){ //loop over reco bins if(hRecoEnergyCCOnlyEvents_NDClone->GetBinContent(j)>0 && hRecoVsTrueEnergy_NDClone->GetBinContent(i,j)>0) { Float_t error=(hRecoVsTrueEnergy_NDClone->GetBinError(i,j)/ hRecoVsTrueEnergy_NDClone->GetBinContent(i,j)); hRecoVsTrueEnergy_NDClone->SetBinContent (i,j,hRecoVsTrueEnergy_NDClone->GetBinContent(i,j)/ hRecoEnergyCCOnlyEvents_NDClone->GetBinContent(j)); hRecoVsTrueEnergy_NDClone->SetBinError (i,j,error*hRecoVsTrueEnergy_NDClone->GetBinContent(i,j)); } else { hRecoVsTrueEnergy_NDClone->SetBinContent(i,j,0); hRecoVsTrueEnergy_NDClone->SetBinError(i,j,0); } } } //(numubar CC): for(int i=1;i<=hRecoVsTrueEnergyPQ_NDClone->GetNbinsX();i++){ //loop over true bins for(int j=1;j<=hRecoVsTrueEnergyPQ_NDClone->GetNbinsY()+1;j++){ //loop over reco bins if(hRecoEnergyCCOnlyEventsPQ_NDClone->GetBinContent(j)>0 && hRecoVsTrueEnergyPQ_NDClone->GetBinContent(i,j)>0) { Float_t error=(hRecoVsTrueEnergyPQ_NDClone->GetBinError(i,j)/ hRecoVsTrueEnergyPQ_NDClone->GetBinContent(i,j)); hRecoVsTrueEnergyPQ_NDClone->SetBinContent (i,j,hRecoVsTrueEnergyPQ_NDClone->GetBinContent(i,j)/ hRecoEnergyCCOnlyEventsPQ_NDClone->GetBinContent(j)); hRecoVsTrueEnergyPQ_NDClone->SetBinError (i,j,error*hRecoVsTrueEnergyPQ_NDClone->GetBinContent(i,j)); } else { hRecoVsTrueEnergyPQ_NDClone->SetBinContent(i,j,0); hRecoVsTrueEnergyPQ_NDClone->SetBinError(i,j,0); } } } //(numu + numubar CC): for(int i=1;i<=hRecoVsTrueEnergyAll_NDClone->GetNbinsX();i++){ //loop over true bins for(int j=1;j<=hRecoVsTrueEnergyAll_NDClone->GetNbinsY()+1;j++){ //loop over reco bins if(hRecoEnergyCCOnlyEventsAll_NDClone->GetBinContent(j)>0 && hRecoVsTrueEnergyAll_NDClone->GetBinContent(i,j)>0) { Float_t error=(hRecoVsTrueEnergyAll_NDClone->GetBinError(i,j)/ hRecoVsTrueEnergyAll_NDClone->GetBinContent(i,j)); hRecoVsTrueEnergyAll_NDClone->SetBinContent (i,j,hRecoVsTrueEnergyAll_NDClone->GetBinContent(i,j)/ hRecoEnergyCCOnlyEventsAll_NDClone->GetBinContent(j)); hRecoVsTrueEnergyAll_NDClone->SetBinError (i,j,error*hRecoVsTrueEnergyAll_NDClone->GetBinContent(i,j)); } else { hRecoVsTrueEnergyAll_NDClone->SetBinContent(i,j,0); hRecoVsTrueEnergyAll_NDClone->SetBinError(i,j,0); } } } //Normalise the FD reco v. true CC matrix (numu CC): for(int i=1;i<=hRecoVsTrueEnergy_FDClone->GetNbinsX();i++){ //loop over true bins for(int j=1;j<=hRecoVsTrueEnergy_FDClone->GetNbinsY()+1;j++){ //loop over reco bins if( hTrueEnergyCCOnlyEvents_FDClone->GetBinContent(i)>0 && hRecoVsTrueEnergy_FDClone->GetBinContent(i,j)>0 ) { Float_t error=(hRecoVsTrueEnergy_FDClone->GetBinError(i,j)/ hRecoVsTrueEnergy_FDClone->GetBinContent(i,j)); hRecoVsTrueEnergy_FDClone->SetBinContent (i,j,hRecoVsTrueEnergy_FDClone->GetBinContent(i,j)/ hTrueEnergyCCOnlyEvents_FDClone->GetBinContent(i)); hRecoVsTrueEnergy_FDClone->SetBinError (i,j,error*hRecoVsTrueEnergy_FDClone->GetBinContent(i,j)); } else { hRecoVsTrueEnergy_FDClone->SetBinContent(i,j,0); hRecoVsTrueEnergy_FDClone->SetBinError(i,j,0); } } } // The NC histograms are normalized (to 1 POT) in CombineMMHelpers.C //Normalise the FD reco v. true CC matrix (numubar CC): for(int i=1;i<=hRecoVsTrueEnergyPQ_FDClone->GetNbinsX();i++){ //loop over true bins for(int j=1;j<=hRecoVsTrueEnergyPQ_FDClone->GetNbinsY()+1;j++){ //loop over reco bins if( hTrueEnergyCCOnlyEventsPQ_FDClone->GetBinContent(i)>0 && hRecoVsTrueEnergyPQ_FDClone->GetBinContent(i,j)>0 ) { Float_t error=(hRecoVsTrueEnergyPQ_FDClone->GetBinError(i,j)/ hRecoVsTrueEnergyPQ_FDClone->GetBinContent(i,j)); hRecoVsTrueEnergyPQ_FDClone->SetBinContent (i,j,hRecoVsTrueEnergyPQ_FDClone->GetBinContent(i,j)/ hTrueEnergyCCOnlyEventsPQ_FDClone->GetBinContent(i)); hRecoVsTrueEnergyPQ_FDClone->SetBinError (i,j,error*hRecoVsTrueEnergyPQ_FDClone->GetBinContent(i,j)); } else { hRecoVsTrueEnergyPQ_FDClone->SetBinContent(i,j,0); hRecoVsTrueEnergyPQ_FDClone->SetBinError(i,j,0); } } } //Normalise the FD reco v. true CC matrix (numu + numubar CC): for(int i=1;i<=hRecoVsTrueEnergyAll_FDClone->GetNbinsX();i++){ //loop over true bins for(int j=1;j<=hRecoVsTrueEnergyAll_FDClone->GetNbinsY()+1;j++){ //loop over reco bins if( hTrueEnergyCCOnlyEventsAll_FDClone->GetBinContent(i)>0 && hRecoVsTrueEnergyAll_FDClone->GetBinContent(i,j)>0 ) { Float_t error=(hRecoVsTrueEnergyAll_FDClone->GetBinError(i,j)/ hRecoVsTrueEnergyAll_FDClone->GetBinContent(i,j)); hRecoVsTrueEnergyAll_FDClone->SetBinContent (i,j,hRecoVsTrueEnergyAll_FDClone->GetBinContent(i,j)/ hTrueEnergyCCOnlyEventsAll_FDClone->GetBinContent(i)); hRecoVsTrueEnergyAll_FDClone->SetBinError (i,j,error*hRecoVsTrueEnergyAll_FDClone->GetBinContent(i,j)); } else { hRecoVsTrueEnergyAll_FDClone->SetBinContent(i,j,0); hRecoVsTrueEnergyAll_FDClone->SetBinError(i,j,0); } } } //Normalise the FD reco v. true CC matrix (nutau CC): for(int i=1;i<=hRecoVsTrueEnergyTau_FDClone->GetNbinsX();i++){ //loop over true bins for(int j=1;j<=hRecoVsTrueEnergyTau_FDClone->GetNbinsY()+1;j++){ //loop over reco bins if( hTrueEnergyCCOnlyEventsTau_FDClone->GetBinContent(i)>0 && hRecoVsTrueEnergyTau_FDClone->GetBinContent(i,j)>0 ) { Float_t error=(hRecoVsTrueEnergyTau_FDClone->GetBinError(i,j)/ hRecoVsTrueEnergyTau_FDClone->GetBinContent(i,j)); hRecoVsTrueEnergyTau_FDClone->SetBinContent (i,j,hRecoVsTrueEnergyTau_FDClone->GetBinContent(i,j)/ hTrueEnergyCCOnlyEventsTau_FDClone->GetBinContent(i)); hRecoVsTrueEnergyTau_FDClone->SetBinError (i,j,error*hRecoVsTrueEnergyTau_FDClone->GetBinContent(i,j)); } else { hRecoVsTrueEnergyTau_FDClone->SetBinContent(i,j,0); hRecoVsTrueEnergyTau_FDClone->SetBinError(i,j,0); } } } //Normalise the FD reco v. true CC matrix (nutaubar CC): for(int i=1;i<=hRecoVsTrueEnergyTauPQ_FDClone->GetNbinsX();i++){ //loop over true bins for(int j=1;j<=hRecoVsTrueEnergyTauPQ_FDClone->GetNbinsY()+1;j++){ //loop over reco bins if( hTrueEnergyCCOnlyEventsTauPQ_FDClone->GetBinContent(i)>0 && hRecoVsTrueEnergyTauPQ_FDClone->GetBinContent(i,j)>0 ) { Float_t error=(hRecoVsTrueEnergyTauPQ_FDClone->GetBinError(i,j)/ hRecoVsTrueEnergyTauPQ_FDClone->GetBinContent(i,j)); hRecoVsTrueEnergyTauPQ_FDClone->SetBinContent (i,j,hRecoVsTrueEnergyTauPQ_FDClone->GetBinContent(i,j)/ hTrueEnergyCCOnlyEventsTauPQ_FDClone->GetBinContent(i)); hRecoVsTrueEnergyTauPQ_FDClone->SetBinError (i,j,error*hRecoVsTrueEnergyTauPQ_FDClone->GetBinContent(i,j)); } else { hRecoVsTrueEnergyTauPQ_FDClone->SetBinContent(i,j,0); hRecoVsTrueEnergyTauPQ_FDClone->SetBinError(i,j,0); } } } //Normalise the FD reco v. true CC matrix (nutau + nutaubar CC): for(int i=1;i<=hRecoVsTrueEnergyTauAll_FDClone->GetNbinsX();i++){ //loop over true bins for(int j=1;j<=hRecoVsTrueEnergyTauAll_FDClone->GetNbinsY()+1;j++){ //loop over reco bins if( hTrueEnergyCCOnlyEventsTauAll_FDClone->GetBinContent(i)>0 && hRecoVsTrueEnergyTauAll_FDClone->GetBinContent(i,j)>0 ) { Float_t error=(hRecoVsTrueEnergyTauAll_FDClone->GetBinError(i,j)/ hRecoVsTrueEnergyTauAll_FDClone->GetBinContent(i,j)); hRecoVsTrueEnergyTauAll_FDClone->SetBinContent (i,j,hRecoVsTrueEnergyTauAll_FDClone->GetBinContent(i,j)/ hTrueEnergyCCOnlyEventsTauAll_FDClone->GetBinContent(i)); hRecoVsTrueEnergyTauAll_FDClone->SetBinError (i,j,error*hRecoVsTrueEnergyTauAll_FDClone->GetBinContent(i,j)); } else { hRecoVsTrueEnergyTauAll_FDClone->SetBinContent(i,j,0); hRecoVsTrueEnergyTauAll_FDClone->SetBinError(i,j,0); } } } } //POT section if (!hTotalPotClone) { MSG("NuDSTAna",Msg::kInfo) <<"No hTotalPot histo so recalculating..."<<endl; //get an instance of the code library const NuLibrary& lib=NuLibrary::Instance(); //calc pot histograms (hPotTotal gets written by default) lib.hist.CalcPOTsFromHistos("Clone"); //set the clone pointer to the newly created histo //it will then get written out below hTotalPotClone=(TH1F*)gROOT->FindObject("hTotalPot"); } else { MAXMSG("NuDSTAna",Msg::kInfo,1) <<"hTotalPot histo(s) exist(s) so they were summed"<<endl; MAXMSG("NuDSTAna",Msg::kInfo,1) <<"Total POT (from hTotalPot)="<<hTotalPotClone->Integral()<<endl; } //section to open output file //variable to store the output directory TDirectory* dirOutput=0; //open the output file for histos if not given etc if (poutput==0) { if (sFullFileName!="" && sFullFileName != "null") { fOutFile=this->OpenFileRECREATE(sFullFileName); } else if (fOutFile) { if (fOutFile->IsOpen()) fOutFile->cd(); else { MSG("NuDSTAna",Msg::kError) << "fOutFile was closed somehow." << endl; MSG("NuDSTAna",Msg::kFatal) << "fOutFile was closed somehow." << endl; } } else { Int_t firstRunNumber=input.GetFirstRunNumberNuEvent(); if (sFilePrefix=="") sFilePrefix="NMBSumAna"; fOutFile=this->OpenFile(firstRunNumber,sFilePrefix); } dirOutput=gDirectory; MSG("NuDSTAna",Msg::kInfo)<<"After opening output file:"<<endl; dirOutput->Print(); } else { //get config object NuConfig config=this->GetNuConfig(input.GetNextNuEvent(Msg::kDebug)); if (sFilePrefix=="") string sFilePrefix="NuDSTMicro"; poutput->SetupFile(config,sFilePrefix); //get the directory of the new file dirOutput=gDirectory; MSG("NuDSTAna",Msg::kInfo)<<"Set up tree for NuOutputWriter"<<endl; //dirOutput->Print();//too verbose } //get rid of Clone in the name hDetectorClone->SetName("hDetector"); hSimFlagClone->SetName("hSimFlag"); hTrigSrcClone->SetName("hTrigSrc"); hSpillsPerFileClone->SetName("hSpillsPerFile"); if (hTotalPotClone) hTotalPotClone->SetName("hTotalPot"); hPottortgtClone->SetName("hPottortgt"); hPotBadtortgtClone->SetName("hPotBadtortgt"); hPottrtgtdClone->SetName("hPottrtgtd"); hPotBadtrtgtdClone->SetName("hPotBadtrtgtd"); hPottor101Clone->SetName("hPottor101"); hPotBadtor101Clone->SetName("hPotBadtor101"); hPottr101dClone->SetName("hPottr101d"); hPotBadtr101dClone->SetName("hPotBadtr101d"); hRunClone->SetName("hRun"); if (hNtupleEarliestTimeClone) { hNtupleEarliestTimeClone->SetName("hNtupleEarliestTime"); hNtupleLatestTimeClone->SetName("hNtupleLatestTime"); } //Rename MM histograms if (hRecoVsTrueEnergyPQ_FDClone) { MSG("NuDSTAna",Msg::kInfo) << "Renaming MM histos" << endl; //Numu CC: hRecoVsTrueEnergy_NDClone->SetName("RecoVsTrueEnergy_ND"); hRecoVsTrueEnergy_FDClone->SetName("RecoVsTrueEnergy_FD"); hEfficiency_NDClone->SetName("Efficiency_ND"); hEfficiency_FDClone->SetName("Efficiency_FD"); hPurity_NDClone->SetName("Purity_ND"); hPurity_FDClone->SetName("Purity_FD"); hRecoEnergyAllEvents_NDClone->SetName("RecoEnergyAllEvents_ND"); hRecoEnergyCCOnlyEvents_NDClone->SetName("RecoEnergyCCOnlyEvents_ND"); hTrueEnergyCCOnlyEvents_NDClone->SetName("TrueEnergyCCOnlyEvents_ND"); if (hTrueEnergyTrueCCFidEvents_NDClone){ hTrueEnergyTrueCCFidEvents_NDClone->SetName("TrueEnergyTrueCCFidEvents_ND"); } if (hTrueEnergyTrueCCFidEvents_FDClone){ hTrueEnergyTrueCCFidEvents_FDClone->SetName("TrueEnergyTrueCCFidEvents_FD"); } hTrueEnergyCCOnlyEvents_FDClone->SetName("TrueEnergyCCOnlyEvents_FD"); hRecoEnergyCCOnlyEvents_FDClone->SetName("RecoEnergyCCOnlyEvents_FD"); hRecoEnergyAllEvents_FDClone->SetName("RecoEnergyAllEvents_FD"); hRecoEnergy_NDClone->SetName("RecoEnergy_ND"); hRecoEnergy_FDClone->SetName("RecoEnergy_FD"); if (hRecoEnergy_ND_NCClone){ hRecoEnergy_ND_NCClone->SetName("RecoEnergy_ND_NC"); } if (hRecoEnergy_FD_NCClone){ hRecoEnergy_FD_NCClone->SetName("RecoEnergy_FD_NC"); } if (hRecoVsTrueEnergy_ND_NCClone){ hRecoVsTrueEnergy_ND_NCClone->SetName("RecoVsTrueEnergy_ND_NC"); } if (hRecoVsTrueEnergy_FD_NCClone){ hRecoVsTrueEnergy_FD_NCClone->SetName("RecoVsTrueEnergy_FD_NC"); } for(int truth = 0; truth < ENCTruth::kNumTruths; ++truth){ for(int det = 0; det <= 1; ++det){ const TString detstr = det ? "FD" : "ND"; const TString name = "RecoVsTrueEnergy_truly"+ENCTruth::truthNames[truth]+"_"+detstr+"_NC"; if (hRecoVsTrueEnergy_NCClone_truly[truth][det]){ hRecoVsTrueEnergy_NCClone_truly[truth][det]->SetName(name); } } } if (hCCContamination_FDClone){ hCCContamination_FDClone->SetName("CCContamination_FD"); if (hCCContaminationRecoVsTrue_FDClone){ hCCContaminationRecoVsTrue_FDClone->SetName("CCContaminationRecoVsTrue_FD"); } hNCContamination_FDClone->SetName("NCContamination_FD"); } if (hCCContamination_NDClone){ hCCContamination_NDClone->SetName("CCContamination_ND"); } if (hNCContamination_NDClone){ hNCContamination_NDClone->SetName("NCContamination_ND"); } //Decay Pipe: if(hTrueEnergyAllEventsPQ_NDClone) { hTrueEnergyAllEventsPQ_NDClone->SetName("TrueEnergyAllEventsPQ_ND"); } if(hTrueEnergyAllEventsPQ_FDClone) { hTrueEnergyAllEventsPQ_FDClone->SetName("TrueEnergyAllEventsPQ_FD"); } if(hTrueEnergyDecayPipePQ_NDClone) { hTrueEnergyDecayPipePQ_NDClone->SetName("TrueEnergyDecayPipePQ_ND"); } if(hTrueEnergyDecayPipePQ_FDClone) { hTrueEnergyDecayPipePQ_FDClone->SetName("TrueEnergyDecayPipePQ_FD"); } //Numubar CC: hRecoVsTrueEnergyPQ_NDClone->SetName("RecoVsTrueEnergyPQ_ND"); hRecoVsTrueEnergyPQ_FDClone->SetName("RecoVsTrueEnergyPQ_FD"); hEfficiencyPQ_NDClone->SetName("EfficiencyPQ_ND"); hEfficiencyPQ_FDClone->SetName("EfficiencyPQ_FD"); hPurityPQ_NDClone->SetName("PurityPQ_ND"); hPurityPQ_FDClone->SetName("PurityPQ_FD"); hRecoEnergyAllEventsPQ_NDClone->SetName("RecoEnergyAllEventsPQ_ND"); hRecoEnergyCCOnlyEventsPQ_NDClone->SetName("RecoEnergyCCOnlyEventsPQ_ND"); hTrueEnergyCCOnlyEventsPQ_NDClone->SetName("TrueEnergyCCOnlyEventsPQ_ND"); if (hTrueEnergyTrueCCFidEventsPQ_NDClone){ hTrueEnergyTrueCCFidEventsPQ_NDClone->SetName("TrueEnergyTrueCCFidEventsPQ_ND"); } if (hTrueEnergyTrueCCFidEventsPQ_FDClone){ hTrueEnergyTrueCCFidEventsPQ_FDClone->SetName("TrueEnergyTrueCCFidEventsPQ_FD"); } hTrueEnergyCCOnlyEventsPQ_FDClone->SetName("TrueEnergyCCOnlyEventsPQ_FD"); hRecoEnergyCCOnlyEventsPQ_FDClone->SetName("RecoEnergyCCOnlyEventsPQ_FD"); hRecoEnergyAllEventsPQ_FDClone->SetName("RecoEnergyAllEventsPQ_FD"); hRecoEnergyPQ_NDClone->SetName("RecoEnergyPQ_ND"); hRecoEnergyPQ_FDClone->SetName("RecoEnergyPQ_FD"); if (hCCContaminationPQ_FDClone){ hCCContaminationPQ_FDClone->SetName("CCContaminationPQ_FD"); if (hCCContaminationRecoVsTruePQ_FDClone){ hCCContaminationRecoVsTruePQ_FDClone->SetName("CCContaminationRecoVsTruePQ_FD"); } hNCContaminationPQ_FDClone->SetName("NCContaminationPQ_FD"); } if (hCCContaminationPQ_NDClone){ hCCContaminationPQ_NDClone->SetName("CCContaminationPQ_ND"); } if (hNCContaminationPQ_NDClone){ hNCContaminationPQ_NDClone->SetName("NCContaminationPQ_ND"); } //Numu + numubar CC: hRecoVsTrueEnergyAll_NDClone->SetName("RecoVsTrueEnergyAll_ND"); hRecoVsTrueEnergyAll_FDClone->SetName("RecoVsTrueEnergyAll_FD"); hEfficiencyAll_NDClone->SetName("EfficiencyAll_ND"); hEfficiencyAll_FDClone->SetName("EfficiencyAll_FD"); hPurityAll_NDClone->SetName("PurityAll_ND"); hPurityAll_FDClone->SetName("PurityAll_FD"); hRecoEnergyAllEventsAll_NDClone->SetName("RecoEnergyAllEventsAll_ND"); hRecoEnergyCCOnlyEventsAll_NDClone->SetName("RecoEnergyCCOnlyEventsAll_ND"); hTrueEnergyCCOnlyEventsAll_NDClone->SetName("TrueEnergyCCOnlyEventsAll_ND"); if (hTrueEnergyTrueCCFidEventsAll_NDClone){ hTrueEnergyTrueCCFidEventsAll_NDClone->SetName("TrueEnergyTrueCCFidEventsAll_ND"); hTrueEnergyTrueCCFidEventsAll_FDClone->SetName("TrueEnergyTrueCCFidEventsAll_FD"); } hTrueEnergyCCOnlyEventsAll_FDClone->SetName("TrueEnergyCCOnlyEventsAll_FD"); hRecoEnergyCCOnlyEventsAll_FDClone->SetName("RecoEnergyCCOnlyEventsAll_FD"); hRecoEnergyAllEventsAll_FDClone->SetName("RecoEnergyAllEventsAll_FD"); hRecoEnergyAll_NDClone->SetName("RecoEnergyAll_ND"); hRecoEnergyAll_FDClone->SetName("RecoEnergyAll_FD"); } //nutau CC: if (hRecoVsTrueEnergyTau_FDClone){ hRecoVsTrueEnergyTau_FDClone->SetName("RecoVsTrueEnergyTau_FD"); } if (hEfficiencyTau_FDClone){ hEfficiencyTau_FDClone->SetName("EfficiencyTau_FD"); } if (hTrueEnergyTrueCCFidEventsTau_FDClone){ hTrueEnergyTrueCCFidEventsTau_FDClone->SetName("TrueEnergyTrueCCFidEventsTau_FD"); } if (hTrueEnergyTrueCCFidEventsTau_FDClone){ hTrueEnergyCCOnlyEventsTau_FDClone->SetName("TrueEnergyCCOnlyEventsTau_FD"); } //nutaubar CC: if (hRecoVsTrueEnergyTauPQ_FDClone){ hRecoVsTrueEnergyTauPQ_FDClone->SetName("RecoVsTrueEnergyTauPQ_FD"); } if (hEfficiencyTauPQ_FDClone){ hEfficiencyTauPQ_FDClone->SetName("EfficiencyTauPQ_FD"); } if (hTrueEnergyTrueCCFidEventsTauPQ_FDClone){ hTrueEnergyTrueCCFidEventsTauPQ_FDClone->SetName("TrueEnergyTrueCCFidEventsTauPQ_FD"); } if (hTrueEnergyTrueCCFidEventsTauPQ_FDClone){ hTrueEnergyCCOnlyEventsTauPQ_FDClone->SetName("TrueEnergyCCOnlyEventsTauPQ_FD"); } //nutau + nutaubar CC: if (hRecoVsTrueEnergyTauAll_FDClone){ hRecoVsTrueEnergyTauAll_FDClone->SetName("RecoVsTrueEnergyTauAll_FD"); } if (hEfficiencyTauAll_FDClone){ hEfficiencyTauAll_FDClone->SetName("EfficiencyTauAll_FD"); } if (hTrueEnergyTrueCCFidEventsTauAll_FDClone){ hTrueEnergyTrueCCFidEventsTauAll_FDClone->SetName("TrueEnergyTrueCCFidEventsTauAll_FD"); } if (hTrueEnergyTrueCCFidEventsTauAll_FDClone){ hTrueEnergyCCOnlyEventsTauAll_FDClone->SetName("TrueEnergyCCOnlyEventsTauAll_FD"); } //now write to file hDetectorClone->Write(); hSimFlagClone->Write(); hTrigSrcClone->Write(); hSpillsPerFileClone->Write(); if (hTotalPotClone) { if (hTotalPotClone->Integral() < 0) { MSG("NuDSTAna",Msg::kWarning) << "Warning: Negative total POT = " << hTotalPotClone->Integral() << endl; if (hDetectorClone->GetMean() == 2 && hSimFlagClone->GetMean() == 4) { double pot = hTotalPotClone->Integral(); pot /= hPottortgtClone->GetMean(); pot *= 6.5; // 6.5 (e20) should replace whatever negative value of spills per file was used. All else is unchanged MSG("NuDSTAna",Msg::kWarning) << "This appears to be FD MC. Setting POTs to default dogwood value, which for this file is " << pot << endl; hTotalPotClone->SetBinContent(1, pot); } } hTotalPotClone->Write(); } if (xmlConfigClone) { cout << "NuXMLConfig Transfered" << endl; xmlConfigClone->Write("NuXMLConfig"); } hPottortgtClone->Write(); hPotBadtortgtClone->Write(); hPottrtgtdClone->Write(); hPotBadtrtgtdClone->Write(); hPottor101Clone->Write(); hPotBadtor101Clone->Write(); hPottr101dClone->Write(); hPotBadtr101dClone->Write(); hRunClone->Write(); if (hNtupleEarliestTimeClone) hNtupleEarliestTimeClone->Write(); if (hNtupleLatestTimeClone) hNtupleLatestTimeClone->Write(); //Write the MM histograms if (hRecoVsTrueEnergyPQ_FDClone) { MSG("NuDSTAna",Msg::kInfo) << "Writing MM histos to File" << endl; //Numu CC: hRecoVsTrueEnergy_NDClone->Write(); hRecoVsTrueEnergy_FDClone->Write(); hEfficiency_NDClone->Write(); hEfficiency_FDClone->Write(); hPurity_NDClone->Write(); hPurity_FDClone->Write(); hRecoEnergyAllEvents_NDClone->Write(); hRecoEnergyCCOnlyEvents_NDClone->Write(); hTrueEnergyCCOnlyEvents_NDClone->Write(); if (hTrueEnergyTrueCCFidEvents_NDClone){ hTrueEnergyTrueCCFidEvents_NDClone->Write(); } if (hTrueEnergyTrueCCFidEvents_FDClone){ hTrueEnergyTrueCCFidEvents_FDClone->Write(); } hTrueEnergyCCOnlyEvents_FDClone->Write(); hRecoEnergyCCOnlyEvents_FDClone->Write(); hRecoEnergyAllEvents_FDClone->Write(); hRecoEnergy_NDClone->Write(); hRecoEnergy_FDClone->Write(); if (hRecoEnergy_ND_NCClone){ hRecoEnergy_ND_NCClone->Write(); } if (hRecoEnergy_FD_NCClone){ hRecoEnergy_FD_NCClone->Write(); } if (hRecoVsTrueEnergy_ND_NCClone){ hRecoVsTrueEnergy_ND_NCClone->Write(); } if (hRecoVsTrueEnergy_FD_NCClone){ hRecoVsTrueEnergy_FD_NCClone->Write(); } for(int truth = 0; truth < ENCTruth::kNumTruths; ++truth){ for(int det = 0; det <= 1; ++det){ if (hRecoVsTrueEnergy_NCClone_truly[truth][det]){ hRecoVsTrueEnergy_NCClone_truly[truth][det]->Write(); } } } if (hCCContamination_FDClone){ hCCContamination_FDClone->Write(); if (hCCContaminationRecoVsTrue_FDClone){ hCCContaminationRecoVsTrue_FDClone->Write(); } hNCContamination_FDClone->Write(); } if (hCCContamination_NDClone){ hCCContamination_NDClone->Write(); } if (hNCContamination_NDClone){ hNCContamination_NDClone->Write(); } //Decay Pipe: if(hTrueEnergyAllEventsPQ_NDClone) { hTrueEnergyAllEventsPQ_NDClone->Write(); } if(hTrueEnergyAllEventsPQ_FDClone) { hTrueEnergyAllEventsPQ_FDClone->Write(); } if(hTrueEnergyDecayPipePQ_NDClone) { hTrueEnergyDecayPipePQ_NDClone->Write(); } if(hTrueEnergyDecayPipePQ_FDClone) { hTrueEnergyDecayPipePQ_FDClone->Write(); } //Numubar CC: hRecoVsTrueEnergyPQ_NDClone->Write(); hRecoVsTrueEnergyPQ_FDClone->Write(); hEfficiencyPQ_NDClone->Write(); hEfficiencyPQ_FDClone->Write(); hPurityPQ_NDClone->Write(); hPurityPQ_FDClone->Write(); hRecoEnergyAllEventsPQ_NDClone->Write(); hRecoEnergyCCOnlyEventsPQ_NDClone->Write(); hTrueEnergyCCOnlyEventsPQ_NDClone->Write(); if (hTrueEnergyTrueCCFidEventsPQ_NDClone){ hTrueEnergyTrueCCFidEventsPQ_NDClone->Write(); } if (hTrueEnergyTrueCCFidEventsPQ_FDClone){ hTrueEnergyTrueCCFidEventsPQ_FDClone->Write(); } hTrueEnergyCCOnlyEventsPQ_FDClone->Write(); hRecoEnergyCCOnlyEventsPQ_FDClone->Write(); hRecoEnergyAllEventsPQ_FDClone->Write(); hRecoEnergyPQ_NDClone->Write(); hRecoEnergyPQ_FDClone->Write(); if (hCCContaminationPQ_FDClone){ hCCContaminationPQ_FDClone->Write(); if (hCCContaminationRecoVsTruePQ_FDClone){ hCCContaminationRecoVsTruePQ_FDClone->Write(); } hNCContaminationPQ_FDClone->Write(); } if (hCCContaminationPQ_NDClone){ hCCContaminationPQ_NDClone->Write(); } if (hNCContaminationPQ_NDClone){ hNCContaminationPQ_NDClone->Write(); } //Numu + numubar CC: hRecoVsTrueEnergyAll_NDClone->Write(); hRecoVsTrueEnergyAll_FDClone->Write(); hEfficiencyAll_NDClone->Write(); hEfficiencyAll_FDClone->Write(); hPurityAll_NDClone->Write(); hPurityAll_FDClone->Write(); hRecoEnergyAllEventsAll_NDClone->Write(); hRecoEnergyCCOnlyEventsAll_NDClone->Write(); hTrueEnergyCCOnlyEventsAll_NDClone->Write(); if (hTrueEnergyTrueCCFidEventsAll_NDClone){ hTrueEnergyTrueCCFidEventsAll_NDClone->Write(); } if (hTrueEnergyTrueCCFidEventsAll_FDClone){ hTrueEnergyTrueCCFidEventsAll_FDClone->Write(); } hTrueEnergyCCOnlyEventsAll_FDClone->Write(); hRecoEnergyCCOnlyEventsAll_FDClone->Write(); hRecoEnergyAllEventsAll_FDClone->Write(); hRecoEnergyAll_NDClone->Write(); hRecoEnergyAll_FDClone->Write(); //nutau CC: if (hRecoVsTrueEnergyTau_FDClone){ hRecoVsTrueEnergyTau_FDClone->Write(); } if (hEfficiencyTau_FDClone){ hEfficiencyTau_FDClone->Write(); } if (hTrueEnergyTrueCCFidEventsTau_FDClone){ hTrueEnergyTrueCCFidEventsTau_FDClone->Write(); } if (hTrueEnergyTrueCCFidEventsTau_FDClone){ hTrueEnergyCCOnlyEventsTau_FDClone->Write(); } //nutaubar CC: if (hRecoVsTrueEnergyTauPQ_FDClone){ hRecoVsTrueEnergyTauPQ_FDClone->Write(); } if (hEfficiencyTauPQ_FDClone){ hEfficiencyTauPQ_FDClone->Write(); } if (hTrueEnergyTrueCCFidEventsTauPQ_FDClone){ hTrueEnergyTrueCCFidEventsTauPQ_FDClone->Write(); } if (hTrueEnergyTrueCCFidEventsTauPQ_FDClone){ hTrueEnergyCCOnlyEventsTauPQ_FDClone->Write(); } //nutau _ nutaubar CC: if (hRecoVsTrueEnergyTauAll_FDClone){ hRecoVsTrueEnergyTauAll_FDClone->Write(); } if (hEfficiencyTauAll_FDClone){ hEfficiencyTauAll_FDClone->Write(); } if (hTrueEnergyTrueCCFidEventsTauAll_FDClone){ hTrueEnergyTrueCCFidEventsTauAll_FDClone->Write(); } if (hTrueEnergyTrueCCFidEventsTauAll_FDClone){ hTrueEnergyCCOnlyEventsTauAll_FDClone->Write(); } } //copy across histos such hDetector, hSimFlag, and POT ones //do this above now //this->CopyAcrossHistos(dirInput,dirOutput); return input; }

NuInputEvents & NuDSTAna::DoIOSimple (  std::string  sFilePrefix = ""  )  [protected]

Definition at line 960 of file NuDSTAna.cxx. References CopyAcrossHistos(), NuInputEvents::GetFirstRunNumberNuEvent(), NuBase::GetInputFileName(), NuInputEvents::InitialiseChains(), NuInputEvents::InitialiseNuEventBranch(), NuInputEvents::InputFileName(), NuBase::OpenFile(), and NuInputEvents::OpenInputFile(). { //open the input file with the tree in it string inputFileName=this->GetInputFileName(); NuInputEvents* fpInput=new NuInputEvents(); NuInputEvents& input=*fpInput; input.InputFileName(inputFileName); input.InitialiseChains(); input.InitialiseNuEventBranch(); TDirectory* dirInput=input.OpenInputFile(); Int_t firstRunNumber=input.GetFirstRunNumberNuEvent(); //open the output file for histos etc if (sFilePrefix!="") { fOutFile=this->OpenFile(firstRunNumber,sFilePrefix.c_str()); TDirectory* dirOutput=gDirectory; cout<<"After opening output file:"<<endl; dirOutput->Print(); //copy across histos such hDetector, hSimFlag, and POT ones this->CopyAcrossHistos(dirInput,dirOutput); } else cout<<"Not opening an output file"<<endl; return input; }

void NuDSTAna::DoSystematicShifts (  NuEvent &  event, const NuXMLConfig *  xmlConfig )  const [virtual]

Definition at line 5373 of file NuDSTAna.cxx. References NuXMLConfig::FullTitle(), MAXMSG, NuXMLConfig::Name(), and NuSystematic::Shift(). Referenced by FluxComponents(), MakeMicroDST(), and MMRereco(). { if (!xmlConfig){ MAXMSG("NuDSTAna",Msg::kInfo,5) << "No NuXMLConfig object supplied: " << "performing no systematic shifts." << endl; return; } else if (xmlConfig->Name().IsNull()) { MAXMSG("NuDSTAna",Msg::kInfo,5) << "No Shift supplied in XML. Not doing shifts." << endl; return; } else { MAXMSG("NuDSTAna",Msg::kInfo,5) << "Performing systematic shift " << xmlConfig->FullTitle() << endl; static NuSystematic nuSyst(*xmlConfig); nuSyst.Shift(event); return; } }

void NuDSTAna::DPSystematic (   )

Definition at line 5844 of file NuDSTAna.cxx. References NuEvent::anaVersion, NuEvent::applyBeamWeight, NuReco::ApplyReweights(), NuEvent::beamWeight, NuEvent::beamWeightRunI, NuEvent::beamWeightRunII, NuEvent::charge, NuLibrary::cnt, NuEvent::detectorWeightNM, NuEvent::detectorWeightNMB, NuEvent::detectorWeightNMBRunI, NuEvent::detectorWeightNMBRunII, NuEvent::detectorWeightNMRunI, NuEvent::detectorWeightNMRunII, DoIO(), NuEvent::energy, NuCounter::evtCounter, NuZBeamReweight::ExtractZBeamReweightCustom(), NuInputEvents::GetEntriesNuEvent(), NuReco::GetEvtEnergy(), NuInputEvents::GetNextNuEvent(), NuInputEvents::InitialiseNuEventBranch(), NuLibrary::Instance(), IsGoodStdCuts(), MSG, NuEvent::ppvz, NuBase::PrintLoopProgress(), NuCounter::PrintMicroDST(), NuEvent::ptype, NuLibrary::reco, NuUtilities::RecoBins(), NuInputEvents::ResetNuEventLoopPositionToStart(), NuEvent::reweightVersion, NuEvent::rw, SanityCheckedAnaVersion(), NuEvent::shwEnWeight, NuEvent::shwEnWeightRunI, NuEvent::shwEnWeightRunII, NuEvent::trkEnWeight, NuEvent::trkEnWeightRunI, NuEvent::trkEnWeightRunII, and NuLibrary::zBeamReweight. { NuInputEvents& input=this->DoIO(0,"","null"); //get an instance of the code library NuLibrary& lib = NuLibrary::Instance(); //version to do reco/cuts with NuCuts::NuAnaVersion_t overrideAnaVersion = static_cast<NuCuts::NuAnaVersion_t>(NuCuts::kNMB0325Bravo); //Binning scheme const NuUtilities cuts; NuBinningScheme::NuBinningScheme_t binningScheme = static_cast<NuBinningScheme::NuBinningScheme_t>(4); std::vector<Double_t> vReco = cuts.RecoBins(binningScheme); int numRecoBins = vReco.size() - 1; TH1::AddDirectory(true); TH1D *hUpI = new TH1D("hUpI", "Upstream #bar{#nu} Run I", numRecoBins, &(vReco[0])); TH1D *hUpII = new TH1D("hUpII", "Upstream #bar{#nu} Run II", numRecoBins, &(vReco[0])); TH1D *hDnI = new TH1D("hDnI", "Downstream #bar{#nu} Run I", numRecoBins, &(vReco[0])); TH1D *hDnII = new TH1D("hDnII", "Downstream #bar{#nu} Run II", numRecoBins, &(vReco[0])); bool dp; input.InitialiseNuEventBranch(); input.ResetNuEventLoopPositionToStart(); cout<<endl <<"************************************************"<<endl <<"*** Starting main loop over snarls ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuEvent();++i) { //for (Int_t i=0;i<0;++i) { lib.cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuEvent(),1); NuEvent &nu=const_cast<NuEvent&>(input.GetNextNuEvent(Msg::kDebug)); //OVERRIDE //Selection nu.anaVersion=this->SanityCheckedAnaVersion (nu.anaVersion,overrideAnaVersion); if (nu.charge < 0) continue; // Only care about numubars if (!this->IsGoodStdCuts(0,nu)) continue; dp = nu.ppvz > 4500 && nu.ptype != 13 && nu.ptype != -13; nu.applyBeamWeight = true; nu.reweightVersion = 1; // Force numu-only SKZP //lib.zBeamReweight.ExtractZBeamReweight(nu); // Use custom set of weights (no NuMuBar spectrum in fit) lib.zBeamReweight.ExtractZBeamReweightCustom(nu); nu.beamWeight = nu.beamWeightRunI; nu.trkEnWeight = nu.trkEnWeightRunI; nu.shwEnWeight = nu.shwEnWeightRunI; nu.detectorWeightNMB = nu.detectorWeightNMBRunI; nu.detectorWeightNM = nu.detectorWeightNMRunI; //RE-RECONSTRUCT the neutrino energy lib.reco.GetEvtEnergy(nu, false); lib.reco.ApplyReweights(nu); if (dp) { hDnI->Fill(nu.energy, nu.rw); } else { hUpI->Fill(nu.energy, nu.rw); } nu.beamWeight = nu.beamWeightRunII; nu.trkEnWeight = nu.trkEnWeightRunII; nu.shwEnWeight = nu.shwEnWeightRunII; nu.detectorWeightNMB = nu.detectorWeightNMBRunII; nu.detectorWeightNM = nu.detectorWeightNMRunII; //RE-RECONSTRUCT the neutrino energy lib.reco.GetEvtEnergy(nu, false); lib.reco.ApplyReweights(nu); if (dp) { hDnII->Fill(nu.energy, nu.rw); } else { hUpII->Fill(nu.energy, nu.rw); } } MSG("NuAnalysis",Msg::kInfo)<<"Finished main loop"<<endl; //print out the numbers of events lib.cnt.PrintMicroDST(); MSG("NuAnalysis",Msg::kInfo) <<" ** Finished DPSystematic method **"<<endl; }

void NuDSTAna::FDTestAna (   )

Definition at line 300 of file NuDSTAna.cxx. References NuEvent::anaVersion, NuReco::ApplyReweights(), NuEvent::charge, NuEvent::containmentFlag, CopyAcrossHistos(), NuConfig::detector, NuEvent::energy, NuEvent::energyMC, NuEvent::entry, NuEvent::evt, NuCounter::evtCounter, NuInputEvents::GetEntriesNuEvent(), GetEvent(), NuReco::GetEvtEnergy(), NuInputEvents::GetFirstRunNumberNuEvent(), NuBase::GetInputFileName(), NuInputEvents::GetNextNuEvent(), NuReco::GetShowerEnergyCC(), NuReco::GetShowerEnergyCor(), NuEvent::index, NuInputEvents::InitialiseChains(), NuInputEvents::InitialiseNuEventBranch(), NuInputEvents::InputFileName(), IsGoodStdCuts(), MakeFinalPlots(), MAXMSG, MSG, NuEvent::nevt, NuEvent::nshw, NuEvent::ntrk, NuCounter::nuNQCounter, NuCounter::nuPQCounter, NuBase::OpenFile(), NuInputEvents::OpenInputFile(), NuBase::OpenTxtFile(), NuEvent::planeEvtHdrBeg, NuEvent::planeEvtHdrEnd, plots(), NuEvent::primshw, NuPlots::PrintEventInfo(), NuBase::PrintLoopProgress(), NuCounter::PrintMicroDST(), NuEvent::qp, NuEvent::rawPhEvt, NuEvent::releaseType, NuInputEvents::ResetNuEventLoopPositionToStart(), NuEvent::run, NuConfig::run, SanityCheckedAnaVersion(), NuEvent::shwEn, NuEvent::shwEnCor, NuEvent::shwEnNoCor, NuEvent::shwEnNoCor1, NuEvent::shwEnNoCor2, NuEvent::shwEnNoCor3, NuEvent::shwEnNoCor4, NuEvent::snarl, NuEvent::trkEn, NuEvent::trkEnCorCurv1, NuEvent::trkEnCorCurv2, NuEvent::trkEnCorCurv3, NuEvent::trkEnCorRange1, NuEvent::trkEnCorRange2, NuEvent::trkEnCorRange3, NuEvent::trkEnCurv, NuEvent::trkEnRange, NuEvent::trkfitpass, NuEvent::trkMomentumRange, NuEvent::xShwVtx1, NuEvent::xShwVtx2, NuEvent::xShwVtx3, NuEvent::xShwVtx4, NuEvent::xTrkVtx, NuEvent::yShwVtx1, NuEvent::yShwVtx2, NuEvent::yShwVtx3, NuEvent::yShwVtx4, NuEvent::yTrkVtx, NuEvent::zShwVtx1, NuEvent::zShwVtx2, NuEvent::zShwVtx3, NuEvent::zShwVtx4, and NuEvent::zTrkVtx. { //open the input file with the tree in it string inputFileName=this->GetInputFileName(); NuInputEvents* fpInput=new NuInputEvents(); NuInputEvents& input=*fpInput; input.InputFileName(inputFileName); input.InitialiseChains(); input.InitialiseNuEventBranch(); TDirectory* dirInput=input.OpenInputFile(); Int_t firstRunNumber=input.GetFirstRunNumberNuEvent(); //open the output file for histos etc string sFilePrefix="NMBSumAna"; fOutFile=this->OpenFile(firstRunNumber,sFilePrefix.c_str()); TDirectory* dirOutput=gDirectory; cout<<"After opening output file:"<<endl; dirOutput->Print(); //copy across histos such hDetector, hSimFlag, and POT ones this->CopyAcrossHistos(dirInput,dirOutput); //use config object to store info NuConfig config; config.detector=Detector::kFar; config.run=100; string sTxt="nmb"; ofstream& nmbTxt=*(this->OpenTxtFile(config,sTxt.c_str())); string sTxtNM="nm"; ofstream& nmTxt=*(this->OpenTxtFile(config,sTxtNM.c_str())); //string sTxtLINM="nmLI"; //ofstream& nmLITxt=*(this->OpenTxtFile(config,sTxtLINM.c_str())); //object to count events NuCounter cnt; static NuGeneral general; static NuPlots* plots=0; static NuCuts cuts; static NuReco reco; TH1F* hRecoEnDiff=new TH1F("hRecoEnDiff","hRecoEnDiff", 200000,-100,100); hRecoEnDiff->SetTitle("Reconstructed Energy Difference (GeV)"); hRecoEnDiff->GetXaxis()-> SetTitle("Reconstructed Energy Difference (GeV)"); hRecoEnDiff->GetXaxis()->CenterTitle(); hRecoEnDiff->GetYaxis()->SetTitle(""); hRecoEnDiff->GetYaxis()->CenterTitle(); hRecoEnDiff->SetFillColor(0); hRecoEnDiff->SetLineColor(1); //hRecoEnDiff->SetBit(TH1::kCanRebin); TH1F* hRecoEnDiffCurv=new TH1F("hRecoEnDiffCurv","hRecoEnDiffCurv", 200000,-100,100); hRecoEnDiffCurv->SetTitle("Reconstructed Energy Difference (GeV)"); hRecoEnDiffCurv->GetXaxis()-> SetTitle("Reconstructed Energy Difference (GeV)"); hRecoEnDiffCurv->GetXaxis()->CenterTitle(); hRecoEnDiffCurv->GetYaxis()->SetTitle(""); hRecoEnDiffCurv->GetYaxis()->CenterTitle(); hRecoEnDiffCurv->SetFillColor(0); hRecoEnDiffCurv->SetLineColor(1); //hRecoEnDiffCurv->SetBit(TH1::kCanRebin); TH1F* hRecoEnDiffRange=new TH1F("hRecoEnDiffRange","hRecoEnDiffRange", 200000,-100,100); hRecoEnDiffRange->SetTitle("Reconstructed Energy Difference (GeV)"); hRecoEnDiffRange->GetXaxis()-> SetTitle("Reconstructed Energy Difference (GeV)"); hRecoEnDiffRange->GetXaxis()->CenterTitle(); hRecoEnDiffRange->GetYaxis()->SetTitle(""); hRecoEnDiffRange->GetYaxis()->CenterTitle(); hRecoEnDiffRange->SetFillColor(0); hRecoEnDiffRange->SetLineColor(1); //hRecoEnDiffRange->SetBit(TH1::kCanRebin); TH1F* hRecoTrkEnDiff=new TH1F("hRecoTrkEnDiff","hRecoTrkEnDiff", 200000,-100,100); hRecoTrkEnDiff->SetTitle("Reconstructed Trk Energy Difference (GeV)"); hRecoTrkEnDiff->GetXaxis()-> SetTitle("Reconstructed Trk Energy Difference (GeV)"); hRecoTrkEnDiff->GetXaxis()->CenterTitle(); hRecoTrkEnDiff->GetYaxis()->SetTitle(""); hRecoTrkEnDiff->GetYaxis()->CenterTitle(); hRecoTrkEnDiff->SetFillColor(0); hRecoTrkEnDiff->SetLineColor(1); //hRecoTrkEnDiff->SetBit(TH1::kCanRebin); TH1F* hRecoTrkEnDiffCurv=new TH1F("hRecoTrkEnDiffCurv","hRecoTrkEnDiffCurv", 200000,-100,100); hRecoTrkEnDiffCurv->SetTitle("Reconstructed Trk Energy Difference (GeV)"); hRecoTrkEnDiffCurv->GetXaxis()-> SetTitle("Reconstructed Trk Energy Difference (GeV)"); hRecoTrkEnDiffCurv->GetXaxis()->CenterTitle(); hRecoTrkEnDiffCurv->GetYaxis()->SetTitle(""); hRecoTrkEnDiffCurv->GetYaxis()->CenterTitle(); hRecoTrkEnDiffCurv->SetFillColor(0); hRecoTrkEnDiffCurv->SetLineColor(1); //hRecoTrkEnDiffCurv->SetBit(TH1::kCanRebin); TH1F* hRecoTrkEnDiffRange=new TH1F("hRecoTrkEnDiffRange","hRecoTrkEnDiffRange", 200000,-100,100); hRecoTrkEnDiffRange->SetTitle("Reconstructed Trk Energy Difference (GeV)"); hRecoTrkEnDiffRange->GetXaxis()-> SetTitle("Reconstructed Trk Energy Difference (GeV)"); hRecoTrkEnDiffRange->GetXaxis()->CenterTitle(); hRecoTrkEnDiffRange->GetYaxis()->SetTitle(""); hRecoTrkEnDiffRange->GetYaxis()->CenterTitle(); hRecoTrkEnDiffRange->SetFillColor(0); hRecoTrkEnDiffRange->SetLineColor(1); //hRecoTrkEnDiffRange->SetBit(TH1::kCanRebin); TH1F* hRecoShwEnDiff=new TH1F("hRecoShwEnDiff","hRecoShwEnDiff", 200000,-100,100); hRecoShwEnDiff->SetTitle("Reconstructed Shw Energy Difference (GeV)"); hRecoShwEnDiff->GetXaxis()-> SetTitle("Reconstructed Shw Energy Difference (GeV)"); hRecoShwEnDiff->GetXaxis()->CenterTitle(); hRecoShwEnDiff->GetYaxis()->SetTitle(""); hRecoShwEnDiff->GetYaxis()->CenterTitle(); hRecoShwEnDiff->SetFillColor(0); hRecoShwEnDiff->SetLineColor(1); //hRecoShwEnDiff->SetBit(TH1::kCanRebin); TH1F* hRecoShwEnDiffCurv=new TH1F("hRecoShwEnDiffCurv","hRecoShwEnDiffCurv", 200000,-100,100); hRecoShwEnDiffCurv->SetTitle("Reconstructed Shw Energy Difference (GeV)"); hRecoShwEnDiffCurv->GetXaxis()-> SetTitle("Reconstructed Shw Energy Difference (GeV)"); hRecoShwEnDiffCurv->GetXaxis()->CenterTitle(); hRecoShwEnDiffCurv->GetYaxis()->SetTitle(""); hRecoShwEnDiffCurv->GetYaxis()->CenterTitle(); hRecoShwEnDiffCurv->SetFillColor(0); hRecoShwEnDiffCurv->SetLineColor(1); //hRecoShwEnDiffCurv->SetBit(TH1::kCanRebin); TH1F* hRecoShwEnDiffRange=new TH1F("hRecoShwEnDiffRange","hRecoShwEnDiffRange", 200000,-100,100); hRecoShwEnDiffRange->SetTitle("Reconstructed Shw Energy Difference (GeV)"); hRecoShwEnDiffRange->GetXaxis()-> SetTitle("Reconstructed Shw Energy Difference (GeV)"); hRecoShwEnDiffRange->GetXaxis()->CenterTitle(); hRecoShwEnDiffRange->GetYaxis()->SetTitle(""); hRecoShwEnDiffRange->GetYaxis()->CenterTitle(); hRecoShwEnDiffRange->SetFillColor(0); hRecoShwEnDiffRange->SetLineColor(1); //hRecoShwEnDiffRange->SetBit(TH1::kCanRebin); TH1F* hRecoEnOfDiff=new TH1F("hRecoEnOfDiff","hRecoEnOfDiff", 400,-100,100); hRecoEnOfDiff->SetTitle("Reconstructed Energy (GeV)"); hRecoEnOfDiff->GetXaxis()-> SetTitle("Reconstructed Energy (GeV)"); hRecoEnOfDiff->GetXaxis()->CenterTitle(); hRecoEnOfDiff->GetYaxis()->SetTitle(""); hRecoEnOfDiff->GetYaxis()->CenterTitle(); hRecoEnOfDiff->SetFillColor(0); hRecoEnOfDiff->SetLineColor(1); //hRecoEnOfDiff->SetBit(TH1::kCanRebin); TH1F* hRecoTrkEnOfDiff=new TH1F("hRecoTrkEnOfDiff","hRecoTrkEnOfDiff", 400,-100,100); hRecoTrkEnOfDiff->SetTitle("Reconstructed Trk Energy (GeV)"); hRecoTrkEnOfDiff->GetXaxis()-> SetTitle("Reconstructed Trk Energy (GeV)"); hRecoTrkEnOfDiff->GetXaxis()->CenterTitle(); hRecoTrkEnOfDiff->GetYaxis()->SetTitle(""); hRecoTrkEnOfDiff->GetYaxis()->CenterTitle(); hRecoTrkEnOfDiff->SetFillColor(0); hRecoTrkEnOfDiff->SetLineColor(1); //hRecoTrkEnOfDiff->SetBit(TH1::kCanRebin); TH1F* hRecoShwEnOfDiff=new TH1F("hRecoShwEnOfDiff","hRecoShwEnOfDiff", 400,-100,100); hRecoShwEnOfDiff->SetTitle("Reconstructed Shw Energy (GeV)"); hRecoShwEnOfDiff->GetXaxis()-> SetTitle("Reconstructed Shw Energy (GeV)"); hRecoShwEnOfDiff->GetXaxis()->CenterTitle(); hRecoShwEnOfDiff->GetYaxis()->SetTitle(""); hRecoShwEnOfDiff->GetYaxis()->CenterTitle(); hRecoShwEnOfDiff->SetFillColor(0); hRecoShwEnOfDiff->SetLineColor(1); //hRecoShwEnOfDiff->SetBit(TH1::kCanRebin); //version to do reco/cuts with NuCuts::NuAnaVersion_t overrideAnaVersion=NuCuts::kCC0250Std; input.ResetNuEventLoopPositionToStart(); cout<<endl <<"************************************************"<<endl <<"*** Starting main loop over snarls ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuEvent();++i) { cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuEvent(),1); NuEvent& nu=const_cast<NuEvent&>(input.GetNextNuEvent(Msg::kDebug)); //OVERRIDE nu.releaseType=8240; //set the analysis version (could be kFullDST) nu.anaVersion=this->SanityCheckedAnaVersion (nu.anaVersion,overrideAnaVersion); //RE-RECONSTRUCT the neutrino energy reco.GetEvtEnergy(nu, false); reco.ApplyReweights(nu); //make all the std cuts if (!this->IsGoodStdCuts(plots,nu)) continue; if (nu.charge==-1) { plots->PrintEventInfo(nmTxt,nu); cnt.nuNQCounter++; } else if (nu.charge==+1) { plots->PrintEventInfo(nmbTxt,nu); cnt.nuPQCounter++; } else cout<<"ahhh, bad charge (1)"<<endl; Float_t energyDiff=-999; Bool_t printToScreen=false; const NuEvent* pnu=0; if (printToScreen) pnu=this->GetEvent(nu); if (printToScreen && pnu && nu.charge==-1) { const NuEvent& nui=*pnu; static NuReco reco; reco.GetShowerEnergyCC(nu); energyDiff=nu.energy-nui.energy; Float_t rangeCurvDiff=nu.trkEnRange-nu.trkEnCurv; if (TMath::Abs(energyDiff)>0.005*(Munits::GeV)) { MAXMSG("NuDSTAna",Msg::kInfo,500) <<endl<<"************************"<<endl <<endl<<"************************"<<endl <<endl<<"************************"<<endl <<endl<<"************************"<<endl <<endl<<"************************"<<endl <<endl<<"************************"<<endl <<endl<<"************************"<<endl <<endl<<"************************"<<endl <<endl<<"************************"<<endl <<endl<<"************************"<<endl <<endl<<"************************"<<endl <<endl<<"************************"<<endl <<endl<<"************************"<<endl <<"run="<<nu.run<<", snarl="<<nu.snarl<<", evt="<<nu.evt <<endl <<"My energy="<<nu.energy<<", CC std energy="<<nui.energy <<", Ediff="<<energyDiff <<endl <<"shwEn="<<nu.shwEn <<", shwEnCor="<<nu.shwEnCor <<", shwEnNoCor="<<nu.shwEnNoCor <<", primshw="<<nu.primshw <<", nshw="<<nu.nshw <<endl <<"shwEnNoCor1="<<nu.shwEnNoCor1 <<", shwEnNoCor2="<<nu.shwEnNoCor2 <<", shwEnNOCor3="<<nu.shwEnNoCor3 <<", shwEnNoCor4="<<nu.shwEnNoCor4 <<endl <<"shower1 E="<<reco.GetShowerEnergyCor(nu.shwEnNoCor1,CandShowerHandle::kCC,nu) <<" : x,y,z="<<nu.xShwVtx1 <<","<<nu.yShwVtx1 <<","<<nu.zShwVtx1 <<endl <<"shower2 E="<<reco.GetShowerEnergyCor(nu.shwEnNoCor2,CandShowerHandle::kCC,nu) <<" : x,y,z="<<nu.xShwVtx2 <<","<<nu.yShwVtx2 <<","<<nu.zShwVtx2 <<endl <<"shower3 E="<<reco.GetShowerEnergyCor(nu.shwEnNoCor3,CandShowerHandle::kCC,nu) <<" : x,y,z="<<nu.xShwVtx3 <<","<<nu.yShwVtx3 <<","<<nu.zShwVtx3 <<endl <<"shower4 E="<<reco.GetShowerEnergyCor(nu.shwEnNoCor4,CandShowerHandle::kCC,nu) <<" : x,y,z="<<nu.xShwVtx4 <<","<<nu.yShwVtx4 <<","<<nu.zShwVtx4 <<endl <<"track x,y,z="<<nu.xTrkVtx <<","<<nu.yTrkVtx <<","<<nu.zTrkVtx <<endl <<"trkEnRange="<<nu.trkEnRange <<", trkEnCurv="<<nu.trkEnCurv <<", rng-crv="<<rangeCurvDiff <<endl <<"trkEnCorRange1="<<nu.trkEnCorRange1 <<", trkEnCorRange2="<<nu.trkEnCorRange2 <<", trkEnCorRange3="<<nu.trkEnCorRange3 <<endl <<"trkEnCorCurv1="<<nu.trkEnCorCurv1 <<", trkEnCorCurv2="<<nu.trkEnCorCurv2 <<", trkEnCorCurv3="<<nu.trkEnCorCurv3 <<endl; } } if (printToScreen && ((!pnu && nu.charge==-1) || nu.energy>200)) { Float_t p=-1; if (nu.qp) p=1./nu.qp; MAXMSG("NuDSTAna",Msg::kInfo,500) <<endl<<"************************"<<endl <<"run="<<nu.run<<", snarl="<<nu.snarl<<", evt="<<nu.evt <<", entry="<<nu.entry <<endl <<"My energy="<<nu.energy<<", trkEn="<<nu.trkEn <<", shwEn="<<nu.shwEn <<endl <<"shwEnCor="<<nu.shwEnCor <<", shwEnNoCor="<<nu.shwEnNoCor <<", primshw="<<nu.primshw <<", nshw="<<nu.nshw <<", ntrk="<<nu.ntrk<<", nevt="<<nu.nevt <<endl <<"shwEnNoCor1="<<nu.shwEnNoCor1 <<", shwEnNoCor2="<<nu.shwEnNoCor2 <<", shwEnNOCor3="<<nu.shwEnNoCor3 <<", shwEnNoCor4="<<nu.shwEnNoCor4 <<endl <<"shower1 E="<<reco.GetShowerEnergyCor(nu.shwEnNoCor1,CandShowerHandle::kCC,nu) <<" : x,y,z="<<nu.xShwVtx1 <<","<<nu.yShwVtx1 <<","<<nu.zShwVtx1 <<endl <<"shower2 E="<<reco.GetShowerEnergyCor(nu.shwEnNoCor2,CandShowerHandle::kCC,nu) <<" : x,y,z="<<nu.xShwVtx2 <<","<<nu.yShwVtx2 <<","<<nu.zShwVtx2 <<endl <<"shower3 E="<<reco.GetShowerEnergyCor(nu.shwEnNoCor3,CandShowerHandle::kCC,nu) <<" : x,y,z="<<nu.xShwVtx3 <<","<<nu.yShwVtx3 <<","<<nu.zShwVtx3 <<endl <<"shower4 E="<<reco.GetShowerEnergyCor(nu.shwEnNoCor4,CandShowerHandle::kCC,nu) <<" : x,y,z="<<nu.xShwVtx4 <<","<<nu.yShwVtx4 <<","<<nu.zShwVtx4 <<endl <<"track x,y,z="<<nu.xTrkVtx <<","<<nu.yTrkVtx <<","<<nu.zTrkVtx <<endl <<"trkEnRange="<<nu.trkEnRange <<", trkEnCurv="<<nu.trkEnCurv <<", fitpass="<<nu.trkfitpass <<endl <<"rangeNoCor="<<nu.trkMomentumRange <<", curvNoCor="<<p <<endl <<"trkEnCorRange1="<<nu.trkEnCorRange1 <<", trkEnCorRange2="<<nu.trkEnCorRange2 <<", trkEnCorRange3="<<nu.trkEnCorRange3 <<endl <<"trkEnCorCurv1="<<nu.trkEnCorCurv1 <<", trkEnCorCurv2="<<nu.trkEnCorCurv2 <<", trkEnCorCurv3="<<nu.trkEnCorCurv3 <<endl <<"nshw="<<nu.nshw <<", rawPhEvt="<<nu.rawPhEvt <<", planeEvtHdrBeg="<<nu.planeEvtHdrBeg <<", planeEvtHdrEnd="<<nu.planeEvtHdrEnd <<endl; hRecoEnOfDiff->Fill(nu.energy); hRecoEnDiff->Fill(nu.energy); if (nu.containmentFlag==1) hRecoEnDiffRange->Fill(nu.energy); else if (nu.containmentFlag==2) hRecoEnDiffCurv->Fill(nu.energy); else cout<<"Ahhhhh"<<endl; } //if (pnu) continue; //if (energyDiff==-999) continue; //if (TMath::Abs(energyDiff)<0.005) continue; //make the final plots this->MakeFinalPlots(plots,nu); MAXMSG("NuDSTAna",Msg::kInfo,5) <<"Passed: index="<<nu.index <<", energy="<<nu.energy<<", energyMC="<<nu.energyMC<<endl; }//end of loop over summary tree MSG("NuAnalysis",Msg::kInfo)<<"Finished main loop"<<endl; //print out the numbers of events cnt.PrintMicroDST(); MSG("NuAnalysis",Msg::kInfo) <<" ** Finished StdAna method **"<<endl; }

void NuDSTAna::FluxComponents (  TString  xmlFileName  )

Definition at line 5958 of file NuDSTAna.cxx. References NuEvent::anaVersion, NuXMLConfig::AnaVersion(), NuXMLConfig::AnaVersionString(), NuEvent::applyBeamWeight, NuReco::ApplyReweights(), NuEvent::beamWeight, NuEvent::beamWeightRunI, NuEvent::beamWeightRunII, NuXMLConfig::BinningScheme(), NuEvent::charge, NuLibrary::cnt, NuEvent::detectorWeightNM, NuEvent::detectorWeightNMB, NuEvent::detectorWeightNMBRunI, NuEvent::detectorWeightNMBRunII, NuEvent::detectorWeightNMRunI, NuEvent::detectorWeightNMRunII, DoIO(), DoSystematicShifts(), NuEvent::energy, NuCounter::evtCounter, NuInputEvents::GetEntriesNuEvent(), NuReco::GetEvtEnergy(), NuInputEvents::GetNextNuEvent(), NuLibrary::Instance(), MAXMSG, MSG, NuEvent::ppvz, NuBase::PrintLoopProgress(), NuCounter::PrintMicroDST(), NuEvent::ptype, NuLibrary::reco, NuUtilities::RecoBins(), NuInputEvents::ResetNuEventLoopPositionToStart(), NuXMLConfig::RunPeriod(), NuEvent::rw, SanityCheckedAnaVersion(), NuEvent::shwEnWeight, NuEvent::shwEnWeightRunI, NuEvent::shwEnWeightRunII, NuEvent::simFlag, NuEvent::tptype, NuEvent::trkEnWeight, NuEvent::trkEnWeightRunI, NuEvent::trkEnWeightRunII, and NuEvent::Vz. { NuInputEvents& input=this->DoIO(0,"","null"); //get an instance of the code library NuLibrary& lib = NuLibrary::Instance(); //Get the NuXMLConfig object for configuration. NuXMLConfig* xmlConfig = 0; if (xmlFileName.IsNull()) { xmlConfig = new NuXMLConfig(); xmlConfig->Write(); } else { xmlConfig = new NuXMLConfig(xmlFileName); xmlConfig->Write(); } // Selection NuCuts::NuAnaVersion_t overrideAnaVersion = static_cast<NuCuts::NuAnaVersion_t>(xmlConfig->AnaVersion()); NuCutter cutter(xmlConfig->AnaVersionString()); // Binning scheme const NuUtilities cuts; NuBinningScheme::NuBinningScheme_t binningScheme = static_cast<NuBinningScheme::NuBinningScheme_t>(xmlConfig->BinningScheme()); std::vector<Double_t> vReco = cuts.RecoBins(binningScheme); int numRecoBins = vReco.size() - 1; TH1::AddDirectory(true); TString names[] = {"hTotal", "hUpPi", "hUpK", "hDecayPipe"}; TString titles[] = {"Total", "Upstream Pions", "Upstream Kaons", "Decay Pipe"}; TH1D *hPQ[5]; TH1D *hNQ[5]; TH1D *hVzPQ[5]; TH1D *hVzNQ[5]; for (int i = 0; i < 4; i++) { hPQ[i] = new TH1D(names[i], titles[i], numRecoBins, &(vReco[0])); hNQ[i] = new TH1D(names[i]+"NQ", titles[i]+" NQ", numRecoBins, &(vReco[0])); hVzPQ[i] = new TH1D(names[i]+"Vz", titles[i]+" Vz", 500,0,800); hVzNQ[i] = new TH1D(names[i]+"VzNQ", titles[i]+" Vz NQ", 500,0,800); } input.ResetNuEventLoopPositionToStart(); cout<<endl <<"************************************************"<<endl <<"*** Starting main loop over snarls ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuEvent();++i) { //for (Int_t i=0;i<0;++i) { lib.cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuEvent(),1); NuEvent &nu=const_cast<NuEvent&>(input.GetNextNuEvent(Msg::kDebug)); nu.anaVersion=this->SanityCheckedAnaVersion (nu.anaVersion,overrideAnaVersion); //Reweighting if (-1==xmlConfig->RunPeriod()){ MAXMSG("NuDSTAna",Msg::kInfo,5) <<"Not performing any reweighting" << endl; nu.applyBeamWeight = false; } //Should change rwActual, not beamWeight if (0==xmlConfig->RunPeriod()){ nu.applyBeamWeight = true; nu.beamWeight = nu.beamWeight; } if (1==xmlConfig->RunPeriod()){ nu.applyBeamWeight = true; nu.beamWeight = nu.beamWeightRunI; nu.trkEnWeight = nu.trkEnWeightRunI; nu.shwEnWeight = nu.shwEnWeightRunI; nu.detectorWeightNMB = nu.detectorWeightNMBRunI; nu.detectorWeightNM = nu.detectorWeightNMRunI; } if (2==xmlConfig->RunPeriod()){ nu.applyBeamWeight = true; nu.beamWeight = nu.beamWeightRunII; nu.trkEnWeight = nu.trkEnWeightRunII; nu.shwEnWeight = nu.shwEnWeightRunII; nu.detectorWeightNMB = nu.detectorWeightNMBRunII; nu.detectorWeightNM = nu.detectorWeightNMRunII; } //RE-RECONSTRUCT the neutrino energy lib.reco.GetEvtEnergy(nu, false); lib.reco.ApplyReweights(nu); this->DoSystematicShifts(nu,xmlConfig); cutter.MakeCuts(nu); if (cutter.Failed()) continue; int plotNo = 0; if (nu.simFlag == SimFlag::kMC) { bool isDP = nu.ppvz > 4500; int type = nu.ptype; if (type == -1) { cout << "Using old files. Bailing now." << endl; assert(false); } if (type == -13 || type == 13) { type = nu.tptype; isDP = false; } if (isDP) {// Decay Pipe plotNo = 3; } else if (type == -311 || type == 311 || type == -321 || type == 321 || type == 130 || type == 310) {// Kaons plotNo = 2; } else {// Pions plotNo = 1; } if (nu.charge == 1) { hPQ[plotNo]->Fill(nu.energy, nu.rw); if (nu.Vz > -900) hVzPQ[plotNo]->Fill(nu.Vz/100., nu.rw); } else { hNQ[plotNo]->Fill(nu.energy, nu.rw); if (nu.Vz > -900) hVzNQ[plotNo]->Fill(nu.Vz/100., nu.rw); } } if (nu.charge == 1) { hPQ[0]->Fill(nu.energy, nu.rw); if (nu.Vz > -900) hVzPQ[0]->Fill(nu.Vz/100., nu.rw); } else { hNQ[0]->Fill(nu.energy, nu.rw); if (nu.Vz > -900) hVzNQ[0]->Fill(nu.Vz/100., nu.rw); } } cout<<endl; MSG("NuAnalysis",Msg::kInfo)<<"Finished main loop"<<endl; cutter.PrintSummary(); //print out the numbers of events lib.cnt.PrintMicroDST(); MSG("NuAnalysis",Msg::kInfo) <<" ** Finished NewFieldAna method **"<<endl; }

const NuEvent * NuDSTAna::GetEvent (  const NuEvent &  nu  )  [protected]

Definition at line 846 of file NuDSTAna.cxx. References NuEvent::energy, NuEvent::evt, NuEvent::run, run(), s(), and NuEvent::snarl. Referenced by FDTestAna(). { static map<Int_t,map<Int_t,NuEvent> > mymap; static Bool_t firstTime=true; //check if file exists if (firstTime){ firstTime=false; string sFileName="fdlist-allevents.txt"; //open the file cout<<"Opening file "<<sFileName<<"..."<<endl; ifstream file(sFileName.c_str()); if (file){ cout<<"File exists"<<endl; //variables to hold input from file Int_t index=-1; Int_t run=-1; Int_t snarl=-1; Int_t evt=-1; Float_t energy=-1; string s; Int_t counter=0; //read in from the text file, have to deal with all the *'s while (file>>s>>index>>s>>run>>s>>snarl>>s>>evt>>s>>energy>>s) { //cout<<"index="<<index<<", run="<<run<<", snarl="<<snarl // <<", evt="<<evt<<", energy="<<energy<<endl; NuEvent& nui=*new NuEvent(); nui.run=run; nui.snarl=snarl; nui.evt=evt; nui.energy=energy; mymap[run][snarl]=nui; counter++; } cout<<"Total events found in txt file="<<counter<<endl; } else cout<<"No file"<<endl; Int_t counter=0; for (map<Int_t,map<Int_t,NuEvent> >::iterator it=mymap.begin(); it!=mymap.end();++it) { for (map<Int_t,NuEvent>::iterator it2=it->second.begin(); it2!=it->second.end();++it2) { //NuEvent& n=it2->second; //cout<<"run="<<n.run<<", snarl="<<n.snarl<<", energy="<<n.energy //<<endl; counter++; } } cout<<"Total events in map="<<counter<<endl; } //look up the run and snarl in the map //return the NuEvent if found map<Int_t,map<Int_t,NuEvent> >::iterator it=mymap.find(nu.run); if (it==mymap.end()) { cout<<"No such run in map="<<nu.run<<endl; return NULL; } else { map<Int_t,NuEvent>::iterator it2=it->second.find(nu.snarl); if (it2==it->second.end()) { cout<<"No such snarl in map for run="<<nu.run <<", snarl="<<nu.snarl<<endl; return NULL; } else return &(it2->second); } }

const NuEvent * NuDSTAna::GetEventND (  const NuEvent &  nu  )  [protected]

Definition at line 720 of file NuDSTAna.cxx. References NuEvent::abID, NuEvent::energy, NuEvent::evt, MAXMSG, NuEvent::run, run(), NuEvent::shwEn, NuEvent::snarl, and NuEvent::trkEn. Referenced by NDTestAna(). { static map<Int_t,map<Int_t,map<Int_t,NuEvent> > > mymap; static Bool_t firstTime=true; //check if file exists if (firstTime){ firstTime=false; //string sFileName="fdlist-allevents.txt"; //string sFileName="eventsFDDataTrish-sorted.txt"; string sFileName="eventsNDDataTrish-sorted.txt"; //open the file cout<<"Opening file "<<sFileName<<"..."<<endl; ifstream file(sFileName.c_str()); if (file){ cout<<"File exists..."<<endl; //variables to hold input from file //Int_t index=-1; Int_t run=-1; Int_t subrun=-1; Int_t snarl=-1; Int_t evt=-1; Float_t energy=-1; Float_t trkEn=-1; Float_t shwEn=-1; Float_t abID=-1; string s; Int_t counter=0; //read in from the text file, have to deal with all the *'s while (file>>run>>subrun>>snarl>>evt >>energy>>trkEn>>shwEn>>abID) { MAXMSG("NuDSTAna",Msg::kInfo,100) <<"run="<<run<<", snarl="<<snarl<<", evt="<<evt <<", energy="<<energy<<", trkEn="<<trkEn <<", shwEn="<<shwEn<<", abID="<<abID<<endl; if (run<9200 || run>9300) continue; NuEvent& nui=*new NuEvent(); nui.run=run; nui.snarl=snarl; nui.evt=evt; nui.energy=energy; nui.trkEn=trkEn; nui.shwEn=shwEn; nui.abID=abID; mymap[run][snarl][evt]=nui; counter++; } cout<<"Total events found in txt file="<<counter<<endl; } else cout<<"No file"<<endl; Int_t counter=0; for (map<Int_t,map<Int_t,map<Int_t,NuEvent> > >::iterator it= mymap.begin(); it!=mymap.end();++it) { for (map<Int_t,map<Int_t,NuEvent> >::iterator it2= it->second.begin(); it2!=it->second.end();++it2) { for (map<Int_t,NuEvent>::iterator it3=it2->second.begin(); it3!=it2->second.end();++it3) { NuEvent& n=it3->second; MAXMSG("NuDSTAna",Msg::kInfo,100) <<"Map: run="<<n.run<<", snarl="<<n.snarl<<", evt="<<n.evt <<", energy="<<n.energy<<endl; if (n.run==9259) { if (n.snarl<56595) {//140344 MAXMSG("NuDSTAna",Msg::kInfo,100) <<"Map: run="<<n.run <<", snarl="<<n.snarl<<", evt="<<n.evt <<", energy="<<n.energy<<endl; counter++; } } } } } cout<<"Total events in map="<<counter<<endl; } //look up the run and snarl in the map //return the NuEvent if found map<Int_t,map<Int_t,map<Int_t,NuEvent> > >::iterator it= mymap.find(nu.run); if (it==mymap.end()) { cout<<"No such run in map="<<nu.run<<endl; return NULL; } else { map<Int_t,map<Int_t,NuEvent> >::iterator it2= it->second.find(nu.snarl); if (it2==it->second.end()) { cout<<"No such snarl in map for run="<<nu.run <<", snarl="<<nu.snarl<<endl; return NULL; } else { map<Int_t,NuEvent>::iterator it3=it2->second.find(nu.evt); if (it3==it2->second.end()) { cout<<"No such evt in map for run="<<nu.run <<", snarl="<<nu.snarl<<", evt="<<nu.evt<<endl; return NULL; } else { return &(it3->second); } } } }

NuConfig NuDSTAna::GetNuConfig (  const NuEvent &  nu  )  const [protected]

Definition at line 3027 of file NuDSTAna.cxx. References NuEvent::anaVersion, NuConfig::anaVersion, NuEvent::beamType, NuConfig::beamType, NuEvent::cutOnBeamInfo, NuConfig::cutOnBeamInfo, NuEvent::cutOnDataQuality, NuConfig::cutOnDataQuality, NuEvent::cutOnSpillTiming, NuConfig::cutOnSpillTiming, NuEvent::detector, NuConfig::detector, NuEvent::intensity, NuConfig::intensity, NuEvent::mcVersion, NuConfig::mcVersion, NuEvent::recoVersion, NuConfig::recoVersion, NuEvent::releaseType, NuConfig::releaseType, NuEvent::reweightVersion, NuConfig::reweightVersion, NuEvent::run, NuConfig::run, NuEvent::runPeriod, NuConfig::runPeriod, NuEvent::simFlag, NuConfig::simFlag, NuEvent::useDBForBeamInfo, NuConfig::useDBForBeamInfo, NuEvent::useDBForDataQuality, NuConfig::useDBForDataQuality, NuEvent::useDBForSpillTiming, NuConfig::useDBForSpillTiming, NuEvent::useGeneratorReweight, and NuConfig::useGeneratorReweight. Referenced by DoIO(). { //create a config object NuConfig config; //copy all the info across config.run=nu.run; config.detector=nu.detector; config.simFlag=nu.simFlag; config.runPeriod=nu.runPeriod; config.intensity = (Int_t) nu.intensity; config.anaVersion=nu.anaVersion; config.useGeneratorReweight=nu.useGeneratorReweight; config.reweightVersion=nu.reweightVersion; config.mcVersion=nu.mcVersion; config.recoVersion=nu.recoVersion; config.releaseType=nu.releaseType; config.beamType=nu.beamType; config.useDBForDataQuality=nu.useDBForDataQuality; config.useDBForSpillTiming=nu.useDBForSpillTiming; config.useDBForBeamInfo=nu.useDBForBeamInfo; config.cutOnDataQuality=nu.cutOnDataQuality; config.cutOnSpillTiming=nu.cutOnSpillTiming; config.cutOnBeamInfo=nu.cutOnBeamInfo; return config; }

Bool_t NuDSTAna::IsGoodPreSelectionCuts (  const NuPlots *  plots, const NuEvent &  nu )  const [protected]

Definition at line 5310 of file NuDSTAna.cxx. References NuEvent::anaVersion, and plots(). Referenced by BRevAna(), Contamination(), MakeMicroDstFakeData(), MakeMicroDstForCSSSystematics(), MakeMicroDstHe(), MakeMicroDstJJEPresel(), MakeMicroDstWithStdCCRecoAndCuts(), MakeSelMicroDST(), NDQPRB(), QPStudy(), and SelectorTable(). { // In order to move over to the new cuts system, the cutting logic // has been moved. See NuCutsSelection.cxx for the implementation of // this function NuCutImps::NuCutsSelection cut(nu.anaVersion, plots); return cut.MakePreselectionCuts(nu); }

Bool_t NuDSTAna::IsGoodStdCuts (  const NuPlots *  plots, const NuEvent &  nu )  const [protected]

Definition at line 5322 of file NuDSTAna.cxx. References NuEvent::anaVersion, and plots(). Referenced by BRevAna(), Contamination(), DPSystematic(), FDTestAna(), JeffsTestAna(), MakeFCTree(), MakeSelMicroDST(), MMTransition(), NDOsc(), NDTestAna(), NewFieldAna(), RHCTest(), StdCCAna(), StdNMBAna(), and VsTime(). { // In order to move over to the new cuts system, the cutting logic // has been moved. See NuCutsSelection.cxx for the implementation of // this function NuCutImps::NuCutsSelection cut(nu.anaVersion, plots); return cut.MakeCuts(nu); }

void NuDSTAna::JeffsTestAna (   )

Definition at line 4821 of file NuDSTAna.cxx. References NuMCEvent::anaVersion, NuEvent::anaVersion, NuReco::ApplyReweights(), NuEvent::charge, NuLibrary::cnt, NuLibrary::cuts, NuConfig::detector, DoIO(), NuEvent::energy, NuMCEvent::energyMC, NuEvent::energyMC, NuCounter::evtCounter, NuPlots::FillDPIdSigmaQPFailDpIDCutPlots(), NuPlots::FillDPIdSigmaQPFailProbCutPlots(), NuPlots::FillDPIdSigmaQPFailSigQPCutPlots(), NuPlots::FillDPIdSigmaQPPassDpIDCutPlots(), NuPlots::FillDPIdSigmaQPPassSigQPCutPlots(), NuHistos::FillMatrixMethodHistos(), NuPlots::FillTrueFidEnergySpect(), NuPlots::FillTrueFidEnergySpectSpecial(), NuInputEvents::GetEntriesNuEvent(), NuInputEvents::GetEntriesNuMCEvent(), NuReco::GetEvtEnergy(), NuInputEvents::GetNextNuEvent(), NuInputEvents::GetNextNuMCEvent(), NuCounter::goodFitProbCounter, NuCounter::goodFitSigQPCounter, NuCounter::goodPIDCounter, NuLibrary::hist, NuEvent::index, NuInputEvents::InitialiseNuMCEventBranch(), NuLibrary::Instance(), NuCuts::IsGoodFitProb(), NuCuts::IsGoodPID(), NuCuts::IsGoodSigmaQP_QP(), IsGoodStdCuts(), NuCuts::IsInCylindricalVolume(), NuCuts::IsInFidVolTrueEvt(), MakeFinalPlots(), MAXMSG, MSG, NuCounter::nuNQCounter, NuCounter::nuPQCounter, NuBase::OpenTxtFile(), plots(), NuPlots::PrintEventInfo(), NuBase::PrintLoopProgress(), NuCounter::PrintMicroDST(), NuLibrary::reco, NuInputEvents::ResetNuEventLoopPositionToStart(), NuInputEvents::ResetNuMCEventLoopPositionToStart(), NuConfig::run, SanityCheckedAnaVersion(), NuEvent::xTrkVtx, NuEvent::yTrkVtx, and NuEvent::zTrkVtx. { NuInputEvents& input=this->DoIO(); //use config object to store info NuConfig config; config.detector=Detector::kFar; config.run=100; //text files to store info for evts passing cuts string sTxt="nmb";//nubars ofstream& nmbTxt=*(this->OpenTxtFile(config,sTxt.c_str())); string sTxtNM="nm";//neutrinos ofstream& nmTxt=*(this->OpenTxtFile(config,sTxtNM.c_str())); //get an instance of the code library NuLibrary& lib=NuLibrary::Instance(); //get an object to fill plots const NuPlots* plots=new NuPlots(); //version to do reco/cuts with NuCuts::NuAnaVersion_t overrideAnaVersion=NuCuts::kCC0250Std; input.ResetNuEventLoopPositionToStart(); cout<<endl <<"************************************************"<<endl <<"*** Starting main loop over snarls ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuEvent();++i) { lib.cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuEvent(),1); NuEvent& nu=const_cast<NuEvent&>(input.GetNextNuEvent(Msg::kDebug)); //OVERRIDE nu.anaVersion=this->SanityCheckedAnaVersion (nu.anaVersion,overrideAnaVersion); //cut on new 0.8m radius const Float_t beamzerox=1.4828*(Munits::m);//new for 2.5 analysis const Float_t beamzeroy=0.2384*(Munits::m);//new for 2.5 analysis Bool_t inFid=lib.cuts.IsInCylindricalVolume (nu.xTrkVtx,nu.yTrkVtx,nu.zTrkVtx,beamzerox,beamzeroy, 1*(Munits::m),5*(Munits::m),0.8*(Munits::m)); if (!inFid) continue; //RE-RECONSTRUCT the neutrino energy lib.reco.GetEvtEnergy(nu, false); lib.reco.ApplyReweights(nu); //make all the std cuts if (!this->IsGoodStdCuts(plots,nu)) continue; if (nu.charge==-1) { plots->PrintEventInfo(nmTxt,nu); lib.cnt.nuNQCounter++; } else if (nu.charge==+1) { plots->PrintEventInfo(nmbTxt,nu); lib.cnt.nuPQCounter++; } else cout<<"ahhh, bad charge(6)"<<endl; //OVERRIDE nu.anaVersion=NuCuts::kNMB0325Bravo; //cut on the PID if (!lib.cuts.IsGoodPID(nu)) { plots->FillDPIdSigmaQPFailDpIDCutPlots(nu); continue; } lib.cnt.goodPIDCounter++; plots->FillDPIdSigmaQPPassDpIDCutPlots(nu); //cut on the fractional track momentum and sign error if (!lib.cuts.IsGoodSigmaQP_QP(nu)) { plots->FillDPIdSigmaQPFailSigQPCutPlots(nu); continue; } lib.cnt.goodFitSigQPCounter++; plots->FillDPIdSigmaQPPassSigQPCutPlots(nu); //cut on the track fit probability if (!lib.cuts.IsGoodFitProb(nu)) { plots->FillDPIdSigmaQPFailProbCutPlots(nu); continue; } lib.cnt.goodFitProbCounter++; //make the final plots this->MakeFinalPlots(plots,nu); //fill matrix method histos lib.hist.FillMatrixMethodHistos(nu); MAXMSG("NuDSTAna",Msg::kInfo,5) <<"Passed: index="<<nu.index <<", energy="<<nu.energy<<", energyMC="<<nu.energyMC<<endl; } //print out the numbers of events lib.cnt.PrintMicroDST(); /* for (Int_t i=0;i<input.GetEntriesNuEvent();++i) { //for (Int_t i=0;i<0;++i) { lib.cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuEvent(),1); NuEvent& nu=const_cast<NuEvent&>(input.GetNextNuEvent(Msg::kDebug)); //speed up cut for looking at nmb only //if (nu.charge==-1) continue; //OVERRIDE nu.anaVersion=NuCuts::kCC0250Std; //nu.applyEnergyShifts=false; //nu.applyBeamWeight=true; //nu.applyDetectorWeight=false; //nu.applyGeneratorWeight=false; //nu.cutOnDataQuality=false; nu.anaVersion=NuCuts::kNMB0325Bravo; //RE-RECONSTRUCT the neutrino energy lib.reco.GetEvtEnergy(nu); lib.reco.ApplyReweights(nu); nu.anaVersion=NuCuts::kCC0250Std; //Bool_t passFid=lib.cuts.IsInFidVolOffset(nu); //if (!passFid) continue; //if (passFid) continue;//for Anti-FV //if (nu.ntrk==1) continue; //if (nu.ntrk>=2) continue; //select specific true events //if (nu.charge==-1) continue;//remove NQ events //if (nu.inu==-14) continue;//remove the true nubars //if (nu.iaction==1) continue;//remove the CC events //START OF STD CUTS //cut on the sntp good beam and that coil is on if (!lib.cuts.IsGoodBeamDetPOTCountingStage(nu)) continue; lib.cnt.goodBeamDetPOTCountingStage++; //ensure good number of tracks in the event if (!lib.cuts.IsGoodNumberOfTracks(nu)) continue; lib.cnt.evtWithTrkCounter++; //check if the trk is in the fiducial volume if (!lib.cuts.IsInFidVolTrk(nu)) continue; lib.cnt.trkInFidVolCounter++; //cut on LI if (lib.cuts.IsLI(nu)) continue; lib.cnt.evtNotIsLI++; //cut on the data quality if (!lib.cuts.IsGoodDataQuality(nu)) continue; lib.cnt.goodDataQualityCounter++; //cut on the spill time plots->FillEvtAndSpillTimingPlots(nu); if (!lib.cuts.IsGoodTimeToNearestSpill(nu)) continue; lib.cnt.goodTimeToNearestSpillCounter++; //cut on the beam if (!lib.cuts.IsGoodBeam(nu)) continue; lib.cnt.goodBeamInfoDBCounter++; //require a good trk fit if (!lib.cuts.IsGoodTrackFitPass(nu)) continue; lib.cnt.goodTrkPassCounter++; //require a forward going neutrino about beam direction if (!lib.cuts.IsGoodDirCos(nu)) continue; lib.cnt.goodDirectionCosineCounter++; //make the post-preselection plots this->MakePostPreSelectionPlots(plots,nu); //OVERRIDE nu.anaVersion=NuCuts::kNMB0325Bravo; //Float_t r=pow(nu.xTrkEnd,2)+pow(nu.yTrkEnd,2); //if (r) r=sqrt(r); //if (r<0.5) continue; //if (nu.planeTrkEnd-nu.planeTrkBeg<50) continue; //cut on the PID if (!lib.cuts.IsGoodPID(nu)) { plots->FillDPIdSigmaQPFailDpIDCutPlots(nu); continue; } lib.cnt.goodPIDCounter++; plots->FillDPIdSigmaQPPassDpIDCutPlots(nu); //cut on the fractional track momentum and sign error if (!lib.cuts.IsGoodSigmaQP_QP(nu)) { plots->FillDPIdSigmaQPFailSigQPCutPlots(nu); continue; } lib.cnt.goodFitSigQPCounter++; plots->FillDPIdSigmaQPPassSigQPCutPlots(nu); //cut on the track fit probability if (!lib.cuts.IsGoodFitProb(nu)) { plots->FillDPIdSigmaQPFailProbCutPlots(nu); continue; } lib.cnt.goodFitProbCounter++; //END OF STD CUTS if (nu.charge==-1) { plots->PrintEventInfo(nmTxt,nu); lib.cnt.nuNQCounter++; } else if (nu.charge==+1) { plots->PrintEventInfo(nmbTxt,nu); lib.cnt.nuPQCounter++; } else cout<<"ahhh, bad charge"<<endl; //make the final plots this->MakeFinalPlots(plots,nu); //fill matrix method histos lib.hist.FillMatrixMethodHistos(nu); MAXMSG("NuDSTAna",Msg::kInfo,5) <<"Passed: index="<<nu.index <<", energy="<<nu.energy<<", energyMC="<<nu.energyMC<<endl; }//end of loop over summary tree */ input.InitialiseNuMCEventBranch(); input.ResetNuMCEventLoopPositionToStart(); cout<<endl <<"************************************************"<<endl <<"*** Starting loop over truth info ***"<<endl <<"************************************************"<<endl; //for (Int_t i=0;i<input.GetEntriesNuMCEvent();++i) { for (Int_t i=0;i<0;++i) { lib.cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuMCEvent(),1); NuMCEvent& mc=const_cast<NuMCEvent&>(input.GetNextNuMCEvent (Msg::kDebug)); //OVERRIDE mc.anaVersion=this->SanityCheckedAnaVersion (mc.anaVersion,overrideAnaVersion); MAXMSG("NuDSTAna",Msg::kInfo,5) <<"energyMC="<<mc.energyMC<<endl; //make fid vol cut if (!lib.cuts.IsInFidVolTrueEvt(mc)) continue; //fill plots plots->FillTrueFidEnergySpect(mc); plots->FillTrueFidEnergySpectSpecial(mc); } MSG("NuAnalysis",Msg::kInfo) <<" ** Finished JeffsTestAna method **"<<endl; }

void NuDSTAna::MakeDstPQ (   )

this function makes a micro DST with just the PQ events Definition at line 4576 of file NuDSTAna.cxx. References NuEvent::charge, NuLibrary::cnt, DoIO(), NuCounter::evtCounter, NuOutputWriter::FillNuEventTree(), NuOutputWriter::Finish(), NuInputEvents::GetEntriesNuEvent(), NuInputEvents::GetNextNuEvent(), NuOutputWriter::GetNuEventToFill(), NuLibrary::Instance(), NuEvent::inu, NuCounter::nuNQCounter, NuCounter::nuPQCounter, NuBase::PrintLoopProgress(), NuCounter::PrintMicroDST(), NuInputEvents::ResetNuEventLoopPositionToStart(), and UpdatePotSinceLastEvt(). { //do the histogram IO NuOutputWriter* poutput=new NuOutputWriter(); NuInputEvents& input=this->DoIO(poutput,"NuDSTMicroPQ"); //get a reference NuOutputWriter& output=(*poutput); //get an instance of the code library NuLibrary& lib=NuLibrary::Instance(); input.ResetNuEventLoopPositionToStart(); cout<<endl <<"************************************************"<<endl <<"*** Starting main loop over snarls ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuEvent();++i) { lib.cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuEvent(),1); NuEvent& nu=const_cast<NuEvent&>(input.GetNextNuEvent(Msg::kDebug)); //count up the pots Bool_t newEvt=false; this->UpdatePotSinceLastEvt(nu,newEvt); //speed up cut for looking at nmb only if (nu.charge==-1) { lib.cnt.nuNQCounter++; if (nu.inu < 0) {//need the mis-id ones for eff/pur plots //keep these } else { continue; } } if (nu.charge==+1) { lib.cnt.nuPQCounter++; } //copy pots since last event to ntuple for this new evt newEvt=true; this->UpdatePotSinceLastEvt(nu,newEvt); //get the output nu to fill, copy across and fill tree NuEvent& nuOutput=output.GetNuEventToFill(); nuOutput=nu; output.FillNuEventTree(); } //print out the numbers of events lib.cnt.PrintMicroDST(); //close the file and write out everything output.Finish(); }

void NuDSTAna::MakeFCTree (  TString  xmlFileName  )

Definition at line 4437 of file NuDSTAna.cxx. References NuEvent::anaVersion, NuXMLConfig::AnaVersion(), NuEvent::applyBeamWeight, NuReco::ApplyReweights(), NuEvent::beamWeight, NuEvent::beamWeightRunI, NuEvent::beamWeightRunII, NuEvent::charge, NuLibrary::cnt, NuLibrary::cuts, NuEvent::detectorWeightNM, NuEvent::detectorWeightNMB, NuEvent::detectorWeightNMBRunI, NuEvent::detectorWeightNMBRunII, NuEvent::detectorWeightNMRunI, NuEvent::detectorWeightNMRunII, DoIO(), NuEvent::energy, NuEvent::energyMC, NuCounter::evtCounter, NuFCEvent::Extract(), NuCuts::FreeCuts(), NuInputEvents::GetEntriesNuEvent(), NuReco::GetEvtEnergy(), NuInputEvents::GetNextNuEvent(), NuEvent::index, NuLibrary::Instance(), NuCuts::IsGoodQP(), IsGoodStdCuts(), MAXMSG, MSG, NuCounter::nuNQCounter, NuCounter::nuPQCounter, plots(), NuCounter::PrintMicroDST(), NuLibrary::reco, NuFCEvent::Reset(), NuInputEvents::ResetNuEventLoopPositionToStart(), NuXMLConfig::RunPeriod(), SanityCheckedAnaVersion(), NuEvent::shwEnWeight, NuEvent::shwEnWeightRunI, NuEvent::shwEnWeightRunII, NuEvent::trkEnWeight, NuEvent::trkEnWeightRunI, and NuEvent::trkEnWeightRunII. { NuInputEvents& input=this->DoIO(0,"","null"); //get an instance of the code library NuLibrary& lib=NuLibrary::Instance(); //get an object to fill plots const NuPlots* plots=0; //Get the NuXMLConfig object for configuration. NuXMLConfig* xmlConfig = 0; if (xmlFileName.IsNull()) { xmlConfig = new NuXMLConfig(); xmlConfig->Write(); } else { xmlConfig = new NuXMLConfig(xmlFileName); xmlConfig->Write(); } //version to do reco/cuts with NuCuts::NuAnaVersion_t overrideAnaVersion = static_cast<NuCuts::NuAnaVersion_t>(xmlConfig->AnaVersion()); const NuUtilities cuts; TDirectory *save = gDirectory; gDirectory->pwd(); const char* type = "FCTree"; cout << "Create the dummy event" << endl; NuFCEvent *dummy_nu = new NuFCEvent(); cout << "Create tree type " << type << endl; TTree *tree = new TTree(type,type); cout << "Create branch" << endl; tree->Branch("NuFCEvent","NuFCEvent",&dummy_nu,32000,2); cout<<"Tree initialized."<<endl; input.ResetNuEventLoopPositionToStart(); cout<<endl <<"************************************************"<<endl <<"*** Starting main loop over snarls ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuEvent();++i) { lib.cnt.evtCounter++; //this->PrintLoopProgress(i,input.GetEntriesNuEvent(),1); NuEvent &nu=const_cast<NuEvent&>(input.GetNextNuEvent(Msg::kInfo)); //OVERRIDE //Selection nu.anaVersion=this->SanityCheckedAnaVersion (nu.anaVersion,overrideAnaVersion); //Reweighting if (-1==xmlConfig->RunPeriod()){ MAXMSG("NuFarNear",Msg::kInfo,5) <<"Not performing any reweighting" << endl; nu.applyBeamWeight = false; } //Should change rwActual, not beamWeight if (0==xmlConfig->RunPeriod()){ nu.applyBeamWeight = true; nu.beamWeight = nu.beamWeight; } if (1==xmlConfig->RunPeriod()){ nu.applyBeamWeight = true; nu.beamWeight = nu.beamWeightRunI; nu.trkEnWeight = nu.trkEnWeightRunI; nu.shwEnWeight = nu.shwEnWeightRunI; nu.detectorWeightNMB = nu.detectorWeightNMBRunI; nu.detectorWeightNM = nu.detectorWeightNMRunI; } if (2==xmlConfig->RunPeriod()){ nu.applyBeamWeight = true; nu.beamWeight = nu.beamWeightRunII; nu.trkEnWeight = nu.trkEnWeightRunII; nu.shwEnWeight = nu.shwEnWeightRunII; nu.detectorWeightNMB = nu.detectorWeightNMBRunII; nu.detectorWeightNM = nu.detectorWeightNMRunII; } //RE-RECONSTRUCT the neutrino energy lib.reco.GetEvtEnergy(nu, false); lib.reco.ApplyReweights(nu); // No Systematics //this->DoSystematicShifts(nu,xmlConfig); //Get NuMuBars only if (!lib.cuts.IsGoodQP(nu)) continue; //make all the std cuts if (!this->IsGoodStdCuts(plots,nu)) continue; //this is added to vary cuts via xml if (xmlConfig->AnaVersion() == 16 && nu.charge>0){ if(!lib.cuts.FreeCuts(nu,xmlConfig))continue; } // No oscillations //this->Oscillate(nu,xmlConfig); if (nu.charge==-1) lib.cnt.nuNQCounter++; else if (nu.charge==+1) lib.cnt.nuPQCounter++; else cout<<"ahhh, bad charge (4)"<<endl; //cout << "About to extract" << endl; dummy_nu->Extract(nu); //cout << "Extracted. About to fill." << endl; tree->Fill(); //cout << "Filled. About to reset." << endl; dummy_nu->Reset(); MAXMSG("NuFarNear",Msg::kInfo,5) <<"Passed: index="<<nu.index <<", energy="<<nu.energy<<", energyMC="<<nu.energyMC<<endl; }//end of loop over summary tree save->cd(); tree->Write(); //print out the numbers of events lib.cnt.PrintMicroDST(); MSG("NuDSTAna",Msg::kInfo) <<" ** Finished MakeFCTree method **"<<endl; }

void NuDSTAna::MakeFinalPlots (  const NuPlots *  plots, const NuEvent &  nu )  const [protected]

Definition at line 5346 of file NuDSTAna.cxx. References NuPlots::FillContainmentHistos(), NuPlots::FillDPIdSigmaQPPlotsN(), NuPlots::FillEnergyBinHistos(), NuPlots::FillKinematicsHistos(), NuPlots::FillRangeCurvCompHistos(), NuPlots::FillRecoEnYHistosN(), NuPlots::FillRelativeAngleHistos(), NuPlots::FillTruePIDHistos(), NuPlots::FillUVHistos(), NuPlots::FillXYZHistos(), and plots(). Referenced by CSSAnaRashid(), FDTestAna(), JeffsTestAna(), NDTestAna(), NewFieldAna(), NMBAna(), StdCCAna(), and StdNMBAna(). { //same list as in NuAnalysis, but with trk/evt ones commented out plots->FillRecoEnYHistosN(nu); plots->FillDPIdSigmaQPPlotsN(nu); plots->FillEnergyBinHistos(nu); //plots->FillShwHistos(ntp,evt,nu); plots->FillUVHistos(nu); plots->FillXYZHistos(nu); plots->FillContainmentHistos(nu); plots->FillRelativeAngleHistos(nu); plots->FillTruePIDHistos(nu); //plots->FillTrackResponseHistos(ntp,trk,nu); plots->FillRangeCurvCompHistos(nu); plots->FillKinematicsHistos(nu); }

void NuDSTAna::MakeMicroDST (  const TString  anaVersion, const TString  xmlfile = "" )

Make a microDST, optionally processing from the XML file. Definition at line 3098 of file NuDSTAna.cxx. References NuEvent::applyBeamWeight, NuReco::ApplyReweights(), NuMCEvent::beamWeight, NuEvent::beamWeight, NuMCEvent::beamWeightRunI, NuEvent::beamWeightRunI, NuMCEvent::beamWeightRunII, NuEvent::beamWeightRunII, NuEvent::charge, NuLibrary::cnt, Anp::Data, NuEvent::detectorWeightNM, NuEvent::detectorWeightNMB, NuEvent::detectorWeightNMBRunI, NuEvent::detectorWeightNMBRunII, NuEvent::detectorWeightNMRunI, NuEvent::detectorWeightNMRunII, DoIO(), DoSystematicShifts(), NuMCEvent::energyMC, NuCounter::evtCounter, NuOutputWriter::FillNuEventTree(), NuOutputWriter::FillNuMCEventTree(), NuOutputWriter::Finish(), NuCutter::GetCut(), NuInputEvents::GetEntriesNuEvent(), NuInputEvents::GetEntriesNuMCEvent(), NuReco::GetEvtEnergy(), NuInputEvents::GetNextNuEvent(), NuInputEvents::GetNextNuMCEvent(), NuOutputWriter::GetNuEventToFill(), NuOutputWriter::GetNuMCEventToFill(), NuCut::InFidVolTrueEvt(), NuInputEvents::InitialiseNuMCEventBranch(), NuLibrary::Instance(), NuCutter::MakeCuts(), MAXMSG, NuCounter::nuNQCounter, NuCounter::nuPQCounter, Oscillate(), plots(), NuBase::PrintLoopProgress(), NuCutter::PrintSummary(), NuLibrary::reco, NuInputEvents::ResetNuEventLoopPositionToStart(), NuInputEvents::ResetNuMCEventLoopPositionToStart(), NuMCEvent::rw, NuEvent::shwEnWeight, NuEvent::shwEnWeightRunI, NuEvent::shwEnWeightRunII, NuEvent::trkEnWeight, NuEvent::trkEnWeightRunI, NuEvent::trkEnWeightRunII, and UpdatePotSinceLastEvt(). { //do the histogram IO NuOutputWriter output; NuInputEvents& input = this->DoIO(&output,("NuDSTMicro" + anaVersion).Data()); // Set up useful and needed instances NuLibrary& lib=NuLibrary::Instance(); const NuPlots* plots = 0; // Initialise the XML object auto_ptr<NuXMLConfig> xmlConfig; if (xmlFilename.IsNull()) { xmlConfig.reset(new NuXMLConfig()); } else { xmlConfig.reset(new NuXMLConfig(xmlFilename)); } // Decide which analysis version to use TString realAna; // If we have been given an ana version directly, use that. // Otherwise, use the string from the XML file if (!anaVersion.IsNull()) realAna = anaVersion; else realAna = xmlConfig->AnaVersionString(); // Whichever we used, set the XML string now xmlConfig->SetAnaVersionString(realAna); // Save a copy to the output file xmlConfig->Write(); // Build the cutter object NuCutter cutter(realAna, plots); cout<<endl <<"************************************************"<<endl <<"*** Starting main loop over snarls ***"<<endl <<"************************************************"<<endl; input.ResetNuEventLoopPositionToStart(); for (Int_t i=0;i<input.GetEntriesNuEvent();++i) { lib.cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuEvent(),1); NuEvent& nu=const_cast<NuEvent&>(input.GetNextNuEvent(Msg::kDebug)); // Stop cutting on data quality for now //nu.useDBForDataQuality = false; // Record the POTs as they go past, so that when we get an event // that passes, it has the correct POT this->UpdatePotSinceLastEvt(nu,false); // Do the run reweighting if (-1==xmlConfig->RunPeriod()){ MAXMSG("NuDSTAna",Msg::kInfo,5) <<"Not performing any reweighting" << endl; nu.applyBeamWeight = false; } //Should change rwActual, not beamWeight if (0==xmlConfig->RunPeriod()){ nu.applyBeamWeight = true; nu.beamWeight = nu.beamWeight; } if (1==xmlConfig->RunPeriod()){ nu.applyBeamWeight = true; nu.beamWeight = nu.beamWeightRunI; nu.trkEnWeight = nu.trkEnWeightRunI; nu.shwEnWeight = nu.shwEnWeightRunI; nu.detectorWeightNMB = nu.detectorWeightNMBRunI; nu.detectorWeightNM = nu.detectorWeightNMRunI; } if (2==xmlConfig->RunPeriod()){ nu.applyBeamWeight = true; nu.beamWeight = nu.beamWeightRunII; nu.trkEnWeight = nu.trkEnWeightRunII; nu.shwEnWeight = nu.shwEnWeightRunII; nu.detectorWeightNMB = nu.detectorWeightNMBRunII; nu.detectorWeightNM = nu.detectorWeightNMRunII; } //RE-RECONSTRUCT the neutrino energy including kNN, reweight lib.reco.GetEvtEnergy(nu, true); lib.reco.ApplyReweights(nu); // Apply the systematic shift if required according to xmlConfig this->DoSystematicShifts(nu,xmlConfig.get()); // Make the cuts! if (!cutter.MakeCuts(nu)) continue; // Oscillate if desired (to make fake data) this->Oscillate(nu,xmlConfig.get()); // figure out the first and last time in the whole ntuple // this is very useful for making plots of quantities vs time // plots->FillNtupleEarliestLatestTime(nu); // Count the events to print to screen if (nu.charge==-1) lib.cnt.nuNQCounter++; else if (nu.charge==+1) lib.cnt.nuPQCounter++; // else MSG("NuDSTAna",Msg::kWarning) << "Bad charge (" << nu.charge // << ") found!" << endl; // Copy pots since last event to ntuple for this new evt this->UpdatePotSinceLastEvt(nu,true); //get the output nu to fill, copy nu to the output nu, fill tree NuEvent& nuOutput=output.GetNuEventToFill(); nuOutput=nu; output.FillNuEventTree(); } input.InitialiseNuMCEventBranch(); input.ResetNuMCEventLoopPositionToStart(); cout<<endl <<"************************************************"<<endl <<"*** Starting loop over truth info ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuMCEvent();++i) { lib.cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuMCEvent(),1); NuMCEvent& mc=const_cast<NuMCEvent&>(input.GetNextNuMCEvent (Msg::kDebug)); //OVERRIDE // mc.anaVersion=this->SanityCheckedAnaVersion // (mc.anaVersion,overrideAnaVersion); MAXMSG("NuDSTAna",Msg::kInfo,5) <<"energyMC="<<mc.energyMC<<endl; // Make fid vol cut if (!cutter.GetCut()->InFidVolTrueEvt(mc)) continue; //override weights //mc.rw=mc.beamWeightRunI; if (-1==xmlConfig->RunPeriod()){ mc.rw = 1.0; } //Should change rwActual, not beamWeight if (0==xmlConfig->RunPeriod()){ mc.rw = mc.beamWeight; } if (1==xmlConfig->RunPeriod()){ mc.rw = mc.beamWeightRunI; } if (2==xmlConfig->RunPeriod()){ mc.rw = mc.beamWeightRunII; } this->Oscillate(mc,xmlConfig.get()); //get the output nu to fill,copy mc to the output mc, fill tree NuMCEvent& mcOutput=output.GetNuMCEventToFill(); mcOutput=mc; output.FillNuMCEventTree(); } cutter.PrintSummary(); //close the file and write out everything output.Finish(); }

void NuDSTAna::MakeMicroDst2010 (   )

Definition at line 3956 of file NuDSTAna.cxx. References NuMCEvent::anaVersion, NuEvent::anaVersion, NuReco::ApplyReweights(), NuEvent::charge, NuLibrary::cnt, NuEvent::coilIsReverse, NuLibrary::cuts, DoIO(), NuMCEvent::energyMC, NuCounter::evtCounter, NuPlots::FillNtupleEarliestLatestTime(), NuOutputWriter::FillNuEventTree(), NuOutputWriter::FillNuMCEventTree(), NuOutputWriter::Finish(), NuInputEvents::GetEntriesNuEvent(), NuInputEvents::GetEntriesNuMCEvent(), NuReco::GetEvtEnergy(), NuInputEvents::GetNextNuEvent(), NuInputEvents::GetNextNuMCEvent(), NuOutputWriter::GetNuEventToFill(), NuOutputWriter::GetNuMCEventToFill(), NuEvent::hornIsReverse, NuInputEvents::InitialiseNuMCEventBranch(), NuLibrary::Instance(), NuCuts::IsInFidVolTrueEvt(), NuCutter::MakePreselectionCuts(), MAXMSG, NuCounter::nuNQCounter, NuCounter::nuPQCounter, NuCutter::Passed(), plots(), NuBase::PrintLoopProgress(), NuCounter::PrintMicroDST(), NuCutter::PrintSummary(), NuLibrary::reco, NuInputEvents::ResetNuEventLoopPositionToStart(), NuInputEvents::ResetNuMCEventLoopPositionToStart(), NuCutter::ResetStatus(), SanityCheckedAnaVersion(), and UpdatePotSinceLastEvt(). { //do the histogram IO NuOutputWriter* poutput = new NuOutputWriter; NuInputEvents& input = DoIO(poutput, "NuDSTMicro2010"); //get a reference NuOutputWriter& output=(*poutput); //get an instance of the code library NuLibrary& lib = NuLibrary::Instance(); //interface for the pids, plots NuPIDInterface pid; const NuPlots* plots = 0; NuCutter ccCutter("CCA"); NuCutter ncCutter("CCA_NC"); //prepare for loop input.ResetNuEventLoopPositionToStart(); cout<<endl <<"************************************************"<<endl <<"*** Starting main loop over snarls ***"<<endl <<"************************************************"<<endl; for(int i = 0; i < input.GetEntriesNuEvent(); ++i){ ++lib.cnt.evtCounter; PrintLoopProgress(i, input.GetEntriesNuEvent(), 1); NuEvent& nu = const_cast<NuEvent&>(input.GetNextNuEvent(Msg::kDebug)); //OVERRIDE nu.anaVersion = SanityCheckedAnaVersion(nu.anaVersion, NuCuts::kCC0720Std); //count up the pots UpdatePotSinceLastEvt(nu, false); //RE-RECONSTRUCT the neutrino energy including kNN, reweight lib.reco.GetEvtEnergy(nu, true); lib.reco.ApplyReweights(nu); if(nu.coilIsReverse != nu.hornIsReverse){ MAXMSG("NuDSTAna", Msg::kWarning, 50) << "Found a " << (nu.coilIsReverse ? "reversed" : "forward") << " coil event in a " << (nu.hornIsReverse ? "reversed" : "forward") << " horn run. The event is being kept, but there may be a problem!" << " This warning is expected for RHC MC." << endl; } // Need to reset otherwise previous event failing will fail this one ccCutter.ResetStatus(); ncCutter.ResetStatus(); // Always do both so that the final statistics will make more sense ccCutter.MakePreselectionCuts(nu); ncCutter.MakePreselectionCuts(nu); // If the event passes either preselection then we keep it if(!ccCutter.Passed() && !ncCutter.Passed()) continue; //figure out the first and last time in the whole ntuple //this is very useful for making plots of quantities vs time plots->FillNtupleEarliestLatestTime(nu); //count the events to print to screen if(nu.charge == -1) ++lib.cnt.nuNQCounter; if(nu.charge == +1) ++lib.cnt.nuPQCounter; //copy pots since last event to ntuple for this new evt UpdatePotSinceLastEvt(nu, true); //get the output nu to fill, copy nu to the output nu, fill tree output.GetNuEventToFill() = nu; output.FillNuEventTree(); } // end for i input.InitialiseNuMCEventBranch(); input.ResetNuMCEventLoopPositionToStart(); cout<<endl <<"************************************************"<<endl <<"*** Starting loop over truth info ***"<<endl <<"************************************************"<<endl; for(int i = 0; i < input.GetEntriesNuMCEvent(); ++i){ ++lib.cnt.evtCounter; PrintLoopProgress(i, input.GetEntriesNuMCEvent(), 1); NuMCEvent& mc = const_cast<NuMCEvent&>(input.GetNextNuMCEvent(Msg::kDebug)); //OVERRIDE mc.anaVersion = SanityCheckedAnaVersion(mc.anaVersion, NuCuts::kCC0720Std); MAXMSG("NuDSTAna", Msg::kInfo,5) << "energyMC=" << mc.energyMC << endl; //make fid vol cut if(!lib.cuts.IsInFidVolTrueEvt(mc)) continue; //get the output nu to fill,copy mc to the output mc, fill tree output.GetNuMCEventToFill() = mc; output.FillNuMCEventTree(); } // end for i ccCutter.PrintSummary(); ncCutter.PrintSummary(); //print out the numbers of events lib.cnt.PrintMicroDST(); //close the file and write out everything output.Finish(); }

void NuDSTAna::MakeMicroDstFakeData (  bool  presel = true  )

this function makes a micro DST with std CC reco and cuts Definition at line 4257 of file NuDSTAna.cxx. References NuMCEvent::anaVersion, NuEvent::anaVersion, NuEvent::applyBeamWeight, NuReco::ApplyReweights(), NuEvent::beamWeight, NuMCEvent::beamWeightRunI, NuEvent::beamWeightRunI, NuMCEvent::beamWeightRunII, NuEvent::beamWeightRunII, NuEvent::charge, NuLibrary::cnt, NuLibrary::cuts, NuEvent::detectorWeightNM, NuEvent::detectorWeightNMB, NuEvent::detectorWeightNMBRunI, NuEvent::detectorWeightNMBRunII, NuEvent::detectorWeightNMRunI, NuEvent::detectorWeightNMRunII, DoIO(), NuMCEvent::energyMC, NuCounter::evtCounter, NuPlots::FillNtupleEarliestLatestTime(), NuOutputWriter::FillNuEventTree(), NuOutputWriter::FillNuMCEventTree(), NuOutputWriter::Finish(), NuInputEvents::GetEntriesNuEvent(), NuInputEvents::GetEntriesNuMCEvent(), NuReco::GetEvtEnergy(), NuInputEvents::GetNextNuEvent(), NuInputEvents::GetNextNuMCEvent(), NuOutputWriter::GetNuEventToFill(), NuOutputWriter::GetNuMCEventToFill(), NuInputEvents::InitialiseNuMCEventBranch(), NuLibrary::Instance(), IsGoodPreSelectionCuts(), NuCuts::IsInFidVolTrueEvt(), MAXMSG, NuCounter::nuNQCounter, NuCounter::nuPQCounter, Oscillate(), plots(), NuBase::PrintLoopProgress(), NuCounter::PrintMicroDST(), NuLibrary::reco, NuInputEvents::ResetNuEventLoopPositionToStart(), NuInputEvents::ResetNuMCEventLoopPositionToStart(), NuMCEvent::rw, SanityCheckedAnaVersion(), NuXMLConfig::SetCPT(), NuEvent::shwEnWeight, NuEvent::shwEnWeightRunI, NuEvent::shwEnWeightRunII, NuEvent::trkEnWeight, NuEvent::trkEnWeightRunI, NuEvent::trkEnWeightRunII, and UpdatePotSinceLastEvt(). { //do the histogram IO NuOutputWriter* poutput=new NuOutputWriter(); TString name; if (presel) name = "NuDSTMicroFakeData"; else name = "NuDSTFullFakeData"; NuInputEvents& input=this->DoIO(poutput,name.Data()); //get a reference NuOutputWriter& output=(*poutput); //get an instance of the code library NuLibrary& lib=NuLibrary::Instance(); //interface for the pids, plots NuPIDInterface pid; const NuPlots* plots=0; //version to do reco/cuts with NuCuts::NuAnaVersion_t overrideAnaVersion=NuCuts::kJJE1; // Make an xmlConfig object for oscilaltions NuXMLConfig *xmlConfig = new NuXMLConfig(); xmlConfig->SetCPT(); xmlConfig->Write("NuXMLConfig"); //prepare for loop input.ResetNuEventLoopPositionToStart(); cout<<endl <<"************************************************"<<endl <<"*** Starting main loop over snarls ***"<<endl <<"************************************************"<<endl; int RunIPart = static_cast<Int_t>(input.GetEntriesNuEvent() * 1.27 / 3.21); for (Int_t i=0;i<input.GetEntriesNuEvent();++i) { lib.cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuEvent(),1); NuEvent& nu=const_cast<NuEvent&>(input.GetNextNuEvent(Msg::kDebug)); //OVERRIDE nu.anaVersion=this->SanityCheckedAnaVersion (nu.anaVersion,overrideAnaVersion); //count up the pots Bool_t newEvt=false; this->UpdatePotSinceLastEvt(nu,newEvt); //OVERRIDE //Selection nu.anaVersion=this->SanityCheckedAnaVersion (nu.anaVersion,overrideAnaVersion); if (i < RunIPart){ nu.applyBeamWeight = true; nu.beamWeight = nu.beamWeightRunI; nu.trkEnWeight = nu.trkEnWeightRunI; nu.shwEnWeight = nu.shwEnWeightRunI; nu.detectorWeightNMB = nu.detectorWeightNMBRunI; nu.detectorWeightNM = nu.detectorWeightNMRunI; } else{ nu.applyBeamWeight = true; nu.beamWeight = nu.beamWeightRunII; nu.trkEnWeight = nu.trkEnWeightRunII; nu.shwEnWeight = nu.shwEnWeightRunII; nu.detectorWeightNMB = nu.detectorWeightNMBRunII; nu.detectorWeightNM = nu.detectorWeightNMRunII; } //RE-RECONSTRUCT the neutrino energy, including kNN lib.reco.GetEvtEnergy(nu, true); lib.reco.ApplyReweights(nu); //Oscillate if desired (to make fake data) this->Oscillate(nu,xmlConfig); // PoID Officially depracated // Add in Pedro's pid's // pid.GetPoID(nu); //make the preselection cuts if (presel) { if (!this->IsGoodPreSelectionCuts(plots,nu)) continue; } //figure out the first and last time in the whole ntuple //this is very useful for making plots of quantities vs time plots->FillNtupleEarliestLatestTime(nu); //count the events to print to screen if (nu.charge==-1) { lib.cnt.nuNQCounter++; } else if (nu.charge==+1) { lib.cnt.nuPQCounter++; } //copy pots since last event to ntuple for this new evt newEvt=true; this->UpdatePotSinceLastEvt(nu,newEvt); //get the output nu to fill, copy nu to the output nu, fill tree NuEvent& nuOutput=output.GetNuEventToFill(); nuOutput=nu; output.FillNuEventTree(); } input.InitialiseNuMCEventBranch(); input.ResetNuMCEventLoopPositionToStart(); cout<<endl <<"************************************************"<<endl <<"*** Starting loop over truth info ***"<<endl <<"************************************************"<<endl; RunIPart = static_cast<Int_t>(input.GetEntriesNuMCEvent() * 1.27 / 3.21); for (Int_t i=0;i<input.GetEntriesNuMCEvent();++i) { lib.cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuMCEvent(),1); NuMCEvent& mc=const_cast<NuMCEvent&>(input.GetNextNuMCEvent (Msg::kDebug)); //OVERRIDE mc.anaVersion=this->SanityCheckedAnaVersion (mc.anaVersion,overrideAnaVersion); MAXMSG("NuDSTAna",Msg::kInfo,5) <<"energyMC="<<mc.energyMC<<endl; //make fid vol cut if (!lib.cuts.IsInFidVolTrueEvt(mc)) continue; if (i < RunIPart){ mc.rw=mc.beamWeightRunI; } else{ mc.rw=mc.beamWeightRunII; } //Oscillate if desired (to make fake data) this->Oscillate(mc,xmlConfig); //get the output nu to fill,copy mc to the output mc, fill tree NuMCEvent& mcOutput=output.GetNuMCEventToFill(); mcOutput=mc; output.FillNuMCEventTree(); } //print out the numbers of events lib.cnt.PrintMicroDST(); //close the file and write out everything output.Finish(); }

void NuDSTAna::MakeMicroDstForCSSSystematics (   )

this function makes a micro DST with just events for CSS study Definition at line 3280 of file NuDSTAna.cxx. References NuMCEvent::anaVersion, NuEvent::anaVersion, NuReco::ApplyReweights(), NuMCEvent::beamWeightRunI, NuEvent::beamWeightRunI, NuEvent::charge, NuLibrary::cnt, NuLibrary::cuts, DoIO(), NuMCEvent::energyMC, NuCounter::evtCounter, NuPlots::FillNtupleEarliestLatestTime(), NuOutputWriter::FillNuEventTree(), NuOutputWriter::FillNuMCEventTree(), NuOutputWriter::Finish(), NuInputEvents::GetEntriesNuEvent(), NuInputEvents::GetEntriesNuMCEvent(), NuReco::GetEvtEnergy(), NuInputEvents::GetNextNuEvent(), NuInputEvents::GetNextNuMCEvent(), NuOutputWriter::GetNuEventToFill(), NuOutputWriter::GetNuMCEventToFill(), NuInputEvents::InitialiseNuMCEventBranch(), NuLibrary::Instance(), IsGoodPreSelectionCuts(), NuCuts::IsInFidVolTrueEvt(), MAXMSG, NuCounter::nuNQCounter, NuCounter::nuPQCounter, plots(), NuBase::PrintLoopProgress(), NuCounter::PrintMicroDST(), NuLibrary::reco, NuInputEvents::ResetNuEventLoopPositionToStart(), NuInputEvents::ResetNuMCEventLoopPositionToStart(), NuMCEvent::rw, NuEvent::rw, SanityCheckedAnaVersion(), and UpdatePotSinceLastEvt(). { //do the histogram IO NuOutputWriter* poutput=new NuOutputWriter(); NuInputEvents& input=this->DoIO(poutput,"NuDSTMicroCSS"); //get a reference NuOutputWriter& output=(*poutput); //get an instance of the code library NuLibrary& lib=NuLibrary::Instance(); //get plots object const NuPlots* plots=0; //version to do reco/cuts with NuCuts::NuAnaVersion_t overrideAnaVersion=NuCuts::kNMB0325Bravo; //prepare for loop input.ResetNuEventLoopPositionToStart(); cout<<endl <<"************************************************"<<endl <<"*** Starting main loop over snarls ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuEvent();++i) { lib.cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuEvent(),1); NuEvent& nu=const_cast<NuEvent&>(input.GetNextNuEvent(Msg::kDebug)); //OVERRIDE nu.anaVersion=this->SanityCheckedAnaVersion (nu.anaVersion,overrideAnaVersion); //count up the pots Bool_t newEvt=false; this->UpdatePotSinceLastEvt(nu,newEvt); //RE-RECONSTRUCT the neutrino energy, including kNN lib.reco.GetEvtEnergy(nu, true); lib.reco.ApplyReweights(nu); MAXMSG("NuDSTAna",Msg::kWarning,5) <<"Note: setting rw variable to use SKZP RunI beam weight"<<endl; nu.rw=nu.beamWeightRunI; //make the preselection cuts if (!this->IsGoodPreSelectionCuts(plots,nu)) continue; //NC PID taken out due to the fact that Andy's PID uses the charge //and the effect of this is not yet understood. //cut on the PID //if (!lib.cuts.IsGoodPID(nu)) { //continue; //} //lib.cnt.goodPIDCounter++; //figure out the first and last time in the whole ntuple //this is very useful for making plots of quantities vs time plots->FillNtupleEarliestLatestTime(nu); //count the events to print to screen if (nu.charge==-1) lib.cnt.nuNQCounter++; else if (nu.charge==+1) lib.cnt.nuPQCounter++; //copy pots since last event to ntuple for this new evt newEvt=true; this->UpdatePotSinceLastEvt(nu,newEvt); //get the output nu to fill, copy nu to the output nu, fill tree NuEvent& nuOutput=output.GetNuEventToFill(); nuOutput=nu; output.FillNuEventTree(); } input.InitialiseNuMCEventBranch(); input.ResetNuMCEventLoopPositionToStart(); cout<<endl <<"************************************************"<<endl <<"*** Starting loop over truth info ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuMCEvent();++i) { lib.cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuMCEvent(),1); NuMCEvent& mc=const_cast<NuMCEvent&>(input.GetNextNuMCEvent (Msg::kDebug)); //OVERRIDE mc.anaVersion=this->SanityCheckedAnaVersion (mc.anaVersion,overrideAnaVersion); MAXMSG("NuDSTAna",Msg::kInfo,5) <<"energyMC="<<mc.energyMC<<endl; //make fid vol cut if (!lib.cuts.IsInFidVolTrueEvt(mc)) continue; MAXMSG("NuDSTAna",Msg::kWarning,5) <<"Note: setting rw variable to use SKZP RunI beam weight"<<endl; mc.rw=mc.beamWeightRunI; //get the output nu to fill,copy mc to the output mc, fill tree NuMCEvent& mcOutput=output.GetNuMCEventToFill(); mcOutput=mc; output.FillNuMCEventTree(); } //print out the numbers of events lib.cnt.PrintMicroDST(); //close the file and write out everything output.Finish(); }

void NuDSTAna::MakeMicroDstHe (  bool  forceRHC = false  )

this function makes a micro DST with std CC reco and cuts It also applies the He reweighting appropriate to the horn current configuration Definition at line 4083 of file NuDSTAna.cxx. References NuMCEvent::anaVersion, NuEvent::anaVersion, NuEvent::applyBeamWeight, NuReco::ApplyReweights(), NuEvent::beamType, NuEvent::charge, NuLibrary::cnt, NuEvent::coilIsReverse, NuLibrary::cuts, DoIO(), NuMCEvent::energyMC, NuCounter::evtCounter, NuZBeamReweight::ExtractZBeamReweight(), NuPlots::FillNtupleEarliestLatestTime(), NuOutputWriter::FillNuEventTree(), NuOutputWriter::FillNuMCEventTree(), NuOutputWriter::Finish(), NuInputEvents::GetEntriesNuEvent(), NuInputEvents::GetEntriesNuMCEvent(), NuReco::GetEvtEnergy(), ReleaseType::GetMCSubVersion(), NuInputEvents::GetNextNuEvent(), NuInputEvents::GetNextNuMCEvent(), NuOutputWriter::GetNuEventToFill(), NuOutputWriter::GetNuMCEventToFill(), NuZBeamReweight::GetWeightHelium(), NuEvent::hornIsReverse, NuInputEvents::InitialiseNuMCEventBranch(), NuLibrary::Instance(), ReleaseType::IsDaikon(), IsGoodPreSelectionCuts(), NuCuts::IsInFidVolTrueEvt(), MAXMSG, MSG, NuCounter::nuNQCounter, NuCounter::nuPQCounter, plots(), NuBase::PrintLoopProgress(), NuCounter::PrintMicroDST(), NuUtilities::PrintRelease(), NuLibrary::reco, NuEvent::releaseType, NuInputEvents::ResetNuEventLoopPositionToStart(), NuInputEvents::ResetNuMCEventLoopPositionToStart(), NuEvent::runPeriod, NuEvent::rw, SanityCheckedAnaVersion(), NuEvent::simFlag, UpdatePotSinceLastEvt(), and NuLibrary::zBeamReweight. { //do the histogram IO NuOutputWriter* poutput=new NuOutputWriter(); NuInputEvents& input=this->DoIO(poutput,"NuDSTPreselHe"); //get a reference NuOutputWriter& output=(*poutput); //get an instance of the code library NuLibrary& lib=NuLibrary::Instance(); //interface for the pids, plots NuPIDInterface pid; const NuPlots* plots=0; //version to do reco/cuts with NuCuts::NuAnaVersion_t overrideAnaVersion=NuCuts::kJJE1; //prepare for loop input.ResetNuEventLoopPositionToStart(); cout<<endl <<"************************************************"<<endl <<"*** Starting main loop over snarls ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuEvent();++i) { lib.cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuEvent(),1); NuEvent& nu=const_cast<NuEvent&>(input.GetNextNuEvent(Msg::kDebug)); if (nu.simFlag != SimFlag::kMC) { MSG("NuDSTAna",Msg::kError) << "Cout this is not an MC file -- He reweighting is inappropriate. Bailing." << endl; assert(false); } if (ReleaseType::IsDaikon(nu.releaseType) && ReleaseType::GetMCSubVersion(nu.releaseType) > 4) { MSG("NuDSTAna",Msg::kError) << "Trying to make an NuDSTPreselHe for releaseType = " << NuUtilities::PrintRelease(nu.releaseType) << " -- He should already be accounted for. Use MakeMicroDstJJEPresel(). Bailing." << endl; assert(false); } if (forceRHC) { if (nu.runPeriod == 4) { MAXMSG("NuDSTAna",Msg::kWarning, 10) << "This file already seems to be RHC -- no forcing need, but done anyways." << endl; } else if (nu.runPeriod != 0) { MAXMSG("NuDSTAna",Msg::kWarning, 10) << "This file has runPeriod=" << nu.runPeriod << " so it should know if it is RHC. Forcing anyways but you've been warned." << endl; } // Force some parameters: nu.runPeriod = 4; nu.hornIsReverse = true; nu.beamType = BeamType::kL010z185i_rev; // Redo the beam weights lib.zBeamReweight.ExtractZBeamReweight(nu); //Reweighting nu.applyBeamWeight = true; } //OVERRIDE nu.anaVersion=this->SanityCheckedAnaVersion (nu.anaVersion,overrideAnaVersion); //count up the pots Bool_t newEvt=false; this->UpdatePotSinceLastEvt(nu,newEvt); //RE-RECONSTRUCT the neutrino energy including kNN, reweight lib.reco.GetEvtEnergy(nu, true); lib.reco.ApplyReweights(nu); nu.rw *= lib.zBeamReweight.GetWeightHelium(nu); if (nu.coilIsReverse != nu.hornIsReverse) { MAXMSG("NuDSTAna",Msg::kWarning,50) << "Found a reversed coil event. Skipping it, but POT counting will be off!" << endl; continue; } //MAXMSG("NuDSTAna",Msg::kWarning,5) //<<"Note: setting rw variable to use SKZP RunI beam weight"<<endl; //nu.rw=nu.beamWeightRunI; //make the preselection cuts if (!this->IsGoodPreSelectionCuts(plots,nu)) continue; //figure out the first and last time in the whole ntuple //this is very useful for making plots of quantities vs time plots->FillNtupleEarliestLatestTime(nu); //count the events to print to screen if (nu.charge==-1) { lib.cnt.nuNQCounter++; } else if (nu.charge==+1) { lib.cnt.nuPQCounter++; } //copy pots since last event to ntuple for this new evt newEvt=true; this->UpdatePotSinceLastEvt(nu,newEvt); //get the output nu to fill, copy nu to the output nu, fill tree NuEvent& nuOutput=output.GetNuEventToFill(); nuOutput=nu; output.FillNuEventTree(); } input.InitialiseNuMCEventBranch(); input.ResetNuMCEventLoopPositionToStart(); cout<<endl <<"************************************************"<<endl <<"*** Starting loop over truth info ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuMCEvent();++i) { lib.cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuMCEvent(),1); NuMCEvent& mc=const_cast<NuMCEvent&>(input.GetNextNuMCEvent (Msg::kDebug)); //OVERRIDE mc.anaVersion=this->SanityCheckedAnaVersion (mc.anaVersion,overrideAnaVersion); MAXMSG("NuDSTAna",Msg::kInfo,5) <<"energyMC="<<mc.energyMC<<endl; //make fid vol cut if (!lib.cuts.IsInFidVolTrueEvt(mc)) continue; //MAXMSG("NuDSTAna",Msg::kWarning,5) //<<"Note: setting rw variable to use SKZP RunI beam weight"<<endl; //mc.rw=mc.beamWeightRunI; //get the output nu to fill,copy mc to the output mc, fill tree NuMCEvent& mcOutput=output.GetNuMCEventToFill(); mcOutput=mc; output.FillNuMCEventTree(); } //print out the numbers of events lib.cnt.PrintMicroDST(); //close the file and write out everything output.Finish(); }

void NuDSTAna::MakeMicroDstJJEPresel (  int  run = -1  )

this function makes a micro DST with std CC reco and cuts Definition at line 3774 of file NuDSTAna.cxx. References NuMCEvent::anaVersion, NuEvent::anaVersion, NuReco::ApplyReweights(), NuEvent::charge, NuLibrary::cnt, NuEvent::coilIsReverse, NuLibrary::cuts, DoIO(), NuMCEvent::energyMC, NuCounter::evtCounter, NuPlots::FillNtupleEarliestLatestTime(), NuOutputWriter::FillNuEventTree(), NuOutputWriter::FillNuMCEventTree(), NuOutputWriter::Finish(), NuInputEvents::GetEntriesNuEvent(), NuInputEvents::GetEntriesNuMCEvent(), NuReco::GetEvtEnergy(), NuInputEvents::GetNextNuEvent(), NuInputEvents::GetNextNuMCEvent(), NuOutputWriter::GetNuEventToFill(), NuOutputWriter::GetNuMCEventToFill(), NuEvent::hornIsReverse, NuInputEvents::InitialiseNuMCEventBranch(), NuLibrary::Instance(), IsGoodPreSelectionCuts(), NuCuts::IsInFidVolTrueEvt(), MAXMSG, NuCounter::nuNQCounter, NuCounter::nuPQCounter, plots(), NuBase::PrintLoopProgress(), NuCounter::PrintMicroDST(), NuLibrary::reco, NuInputEvents::ResetNuEventLoopPositionToStart(), NuInputEvents::ResetNuMCEventLoopPositionToStart(), run(), SanityCheckedAnaVersion(), NuEvent::timeSec, and UpdatePotSinceLastEvt(). { //do the histogram IO NuOutputWriter* poutput=new NuOutputWriter(); NuInputEvents& input=this->DoIO(poutput,"NuDSTMicroJJEPresel"); //get a reference NuOutputWriter& output=(*poutput); //get an instance of the code library NuLibrary& lib=NuLibrary::Instance(); //interface for the pids, plots NuPIDInterface pid; const NuPlots* plots=0; //version to do reco/cuts with NuCuts::NuAnaVersion_t overrideAnaVersion=NuCuts::kJJE1; //prepare for loop input.ResetNuEventLoopPositionToStart(); cout<<endl <<"************************************************"<<endl <<"*** Starting main loop over snarls ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuEvent();++i) { lib.cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuEvent(),1); NuEvent& nu=const_cast<NuEvent&>(input.GetNextNuEvent(Msg::kDebug)); // Stop cutting on data quality for now //nu.useDBForDataQuality = false; //OVERRIDE nu.anaVersion=this->SanityCheckedAnaVersion (nu.anaVersion,overrideAnaVersion); //count up the pots Bool_t newEvt=false; this->UpdatePotSinceLastEvt(nu,newEvt); if (run >= 0) { // LE Times int startRunI = 1116619345; // 2005-05-20 20:02:25 int endRunI = 1140934189; // 2006-02-26 06:09:49 int startRunII = 1158043200; // 2006-09-12 00:06:40 int endRunII = 1184352157; // 2007-07-13 18:42:37 bool RunILE = (nu.timeSec >= startRunI && nu.timeSec <= endRunI); bool RunIILE = (nu.timeSec >= startRunII && nu.timeSec <= endRunII); if (run == 1 && !RunILE) continue; if (run == 2 && !RunIILE) continue; if (!RunILE && !RunIILE) continue; } //RE-RECONSTRUCT the neutrino energy including kNN, reweight lib.reco.GetEvtEnergy(nu, true); lib.reco.ApplyReweights(nu); if (nu.coilIsReverse != nu.hornIsReverse) { MAXMSG("NuDSTAna",Msg::kWarning,50) << "Found a " << (nu.coilIsReverse?"reversed":"forward") << " coil event in a " << (nu.hornIsReverse?"reversed":"forward") << " horn run. The event is being kept, but there may be a problem! This warning is expected for RHC MC." << endl; } // // Hack to fix misreconstructed FD RHC MC // if (nu.detector == Detector::kFar && nu.simFlag == SimFlag::kMC && nu.runPeriod == 4) { // MAXMSG("NuDSTAna",Msg::kWarning,50) << "Reversing the charge for " << NuUtilities::PrintRelease(nu.releaseType) // << " events from RunPeriod 4. This is because the first round of FD RHC Daikon07 MC was reconstructed with the wrong field." << endl // << "Pleae confirm that results from these files make sense." << endl; // // nu.charge *= -1; // nu.sigqp_qp *= -1; // // nu.qp *= -1; // nu.qp_rangebiased *= -1; // nu.qp_sigqp *= -1; // nu.qp1 *= -1; // nu.qp_rangebiased1 *= -1; // nu.qp_sigqp1 *= -1; // nu.qp2 *= -1; // nu.qp_rangebiased2 *= -1; // nu.qp_sigqp2 *= -1; // nu.qp3 *= -1; // nu.qp_rangebiased3 *= -1; // nu.qp_sigqp3 *= -1; // } //MAXMSG("NuDSTAna",Msg::kWarning,5) //<<"Note: setting rw variable to use SKZP RunI beam weight"<<endl; //nu.rw=nu.beamWeightRunI; //make the preselection cuts if (!this->IsGoodPreSelectionCuts(plots,nu)) continue; //figure out the first and last time in the whole ntuple //this is very useful for making plots of quantities vs time plots->FillNtupleEarliestLatestTime(nu); //count the events to print to screen if (nu.charge==-1) { lib.cnt.nuNQCounter++; } else if (nu.charge==+1) { lib.cnt.nuPQCounter++; } //copy pots since last event to ntuple for this new evt newEvt=true; this->UpdatePotSinceLastEvt(nu,newEvt); //get the output nu to fill, copy nu to the output nu, fill tree NuEvent& nuOutput=output.GetNuEventToFill(); nuOutput=nu; output.FillNuEventTree(); } input.InitialiseNuMCEventBranch(); input.ResetNuMCEventLoopPositionToStart(); cout<<endl <<"************************************************"<<endl <<"*** Starting loop over truth info ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuMCEvent();++i) { lib.cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuMCEvent(),1); NuMCEvent& mc=const_cast<NuMCEvent&>(input.GetNextNuMCEvent (Msg::kDebug)); //OVERRIDE mc.anaVersion=this->SanityCheckedAnaVersion (mc.anaVersion,overrideAnaVersion); MAXMSG("NuDSTAna",Msg::kInfo,5) <<"energyMC="<<mc.energyMC<<endl; //make fid vol cut if (!lib.cuts.IsInFidVolTrueEvt(mc)) continue; //MAXMSG("NuDSTAna",Msg::kWarning,5) //<<"Note: setting rw variable to use SKZP RunI beam weight"<<endl; //mc.rw=mc.beamWeightRunI; //get the output nu to fill,copy mc to the output mc, fill tree NuMCEvent& mcOutput=output.GetNuMCEventToFill(); mcOutput=mc; output.FillNuMCEventTree(); } //print out the numbers of events lib.cnt.PrintMicroDST(); //close the file and write out everything output.Finish(); }

void NuDSTAna::MakeMicroDstWithStdCCRecoAndCuts (   )

this function makes a micro DST with std CC reco and cuts Definition at line 3647 of file NuDSTAna.cxx. References NuMCEvent::anaVersion, NuEvent::anaVersion, NuReco::ApplyReweights(), NuEvent::charge, NuLibrary::cnt, NuLibrary::cuts, DoIO(), NuMCEvent::energyMC, NuCounter::evtCounter, NuPlots::FillNtupleEarliestLatestTime(), NuOutputWriter::FillNuEventTree(), NuOutputWriter::FillNuMCEventTree(), NuOutputWriter::Finish(), NuInputEvents::GetEntriesNuEvent(), NuInputEvents::GetEntriesNuMCEvent(), NuReco::GetEvtEnergy(), NuInputEvents::GetNextNuEvent(), NuInputEvents::GetNextNuMCEvent(), NuOutputWriter::GetNuEventToFill(), NuOutputWriter::GetNuMCEventToFill(), NuInputEvents::InitialiseNuMCEventBranch(), NuLibrary::Instance(), IsGoodPreSelectionCuts(), NuCuts::IsInFidVolTrueEvt(), MAXMSG, NuCounter::nuNQCounter, NuCounter::nuPQCounter, plots(), NuBase::PrintLoopProgress(), NuCounter::PrintMicroDST(), NuLibrary::reco, NuInputEvents::ResetNuEventLoopPositionToStart(), NuInputEvents::ResetNuMCEventLoopPositionToStart(), SanityCheckedAnaVersion(), and UpdatePotSinceLastEvt(). { //do the histogram IO NuOutputWriter* poutput=new NuOutputWriter(); NuInputEvents& input=this->DoIO(poutput,"NuDSTMicroStdCC"); //get a reference NuOutputWriter& output=(*poutput); //get an instance of the code library NuLibrary& lib=NuLibrary::Instance(); const NuPlots* plots=0; //version to do reco/cuts with NuCuts::NuAnaVersion_t overrideAnaVersion=NuCuts::kCC0325Std; //prepare for loop input.ResetNuEventLoopPositionToStart(); cout<<endl <<"************************************************"<<endl <<"*** Starting main loop over snarls ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuEvent();++i) { lib.cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuEvent(),1); NuEvent& nu=const_cast<NuEvent&>(input.GetNextNuEvent(Msg::kDebug)); //OVERRIDE nu.anaVersion=this->SanityCheckedAnaVersion (nu.anaVersion,overrideAnaVersion); //count up the pots Bool_t newEvt=false; this->UpdatePotSinceLastEvt(nu,newEvt); //RE-RECONSTRUCT the neutrino energy, including kNN lib.reco.GetEvtEnergy(nu, true); lib.reco.ApplyReweights(nu); //MAXMSG("NuDSTAna",Msg::kWarning,5) //<<"Note: setting rw variable to use SKZP RunI beam weight"<<endl; //nu.rw=nu.beamWeightRunI; //make the preselection cuts if (!this->IsGoodPreSelectionCuts(plots,nu)) continue; //figure out the first and last time in the whole ntuple //this is very useful for making plots of quantities vs time plots->FillNtupleEarliestLatestTime(nu); //count the events to print to screen if (nu.charge==-1) { lib.cnt.nuNQCounter++; } else if (nu.charge==+1) { lib.cnt.nuPQCounter++; } //copy pots since last event to ntuple for this new evt newEvt=true; this->UpdatePotSinceLastEvt(nu,newEvt); //get the output nu to fill, copy nu to the output nu, fill tree NuEvent& nuOutput=output.GetNuEventToFill(); nuOutput=nu; output.FillNuEventTree(); } input.InitialiseNuMCEventBranch(); input.ResetNuMCEventLoopPositionToStart(); cout<<endl <<"************************************************"<<endl <<"*** Starting loop over truth info ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuMCEvent();++i) { lib.cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuMCEvent(),1); NuMCEvent& mc=const_cast<NuMCEvent&>(input.GetNextNuMCEvent (Msg::kDebug)); //OVERRIDE mc.anaVersion=this->SanityCheckedAnaVersion (mc.anaVersion,overrideAnaVersion); MAXMSG("NuDSTAna",Msg::kInfo,5) <<"energyMC="<<mc.energyMC<<endl; //make fid vol cut if (!lib.cuts.IsInFidVolTrueEvt(mc)) continue; //MAXMSG("NuDSTAna",Msg::kWarning,5) //<<"Note: setting rw variable to use SKZP RunI beam weight"<<endl; //mc.rw=mc.beamWeightRunI; //get the output nu to fill,copy mc to the output mc, fill tree NuMCEvent& mcOutput=output.GetNuMCEventToFill(); mcOutput=mc; output.FillNuMCEventTree(); } //print out the numbers of events lib.cnt.PrintMicroDST(); //close the file and write out everything output.Finish(); }

void NuDSTAna::MakePostPreSelectionPlots (  const NuPlots *  plots, const NuEvent &  nu )  const [protected]

Definition at line 5334 of file NuDSTAna.cxx. References NuCutImps::NuCutsSelection::MakePostPreSelectionPlots(), and plots(). Referenced by CSSAnaRashid(), and NMBAna(). { // In order to move over to the new cuts system, the cutting logic // has been moved. See NuCutsSelection.cxx for the implementation of // this function NuCutImps::NuCutsSelection cut(plots); cut.MakePostPreSelectionPlots(nu); }

void NuDSTAna::MakeSelMicroDST (  Int_t  selector  )

this function makes a micro DST with selector 11 cuts Definition at line 3515 of file NuDSTAna.cxx. References NuMCEvent::anaVersion, NuEvent::anaVersion, NuReco::ApplyReweights(), NuEvent::charge, NuLibrary::cnt, NuLibrary::cuts, DoIO(), NuMCEvent::energyMC, NuCounter::evtCounter, NuPlots::FillNtupleEarliestLatestTime(), NuOutputWriter::FillNuEventTree(), NuOutputWriter::FillNuMCEventTree(), NuOutputWriter::Finish(), NuInputEvents::GetEntriesNuEvent(), NuInputEvents::GetEntriesNuMCEvent(), NuReco::GetEvtEnergy(), NuInputEvents::GetNextNuEvent(), NuInputEvents::GetNextNuMCEvent(), NuOutputWriter::GetNuEventToFill(), NuOutputWriter::GetNuMCEventToFill(), NuInputEvents::InitialiseNuMCEventBranch(), NuLibrary::Instance(), IsGoodPreSelectionCuts(), IsGoodStdCuts(), NuCuts::IsInFidVolTrueEvt(), MAXMSG, NuCounter::nuNQCounter, NuCounter::nuPQCounter, plots(), NuBase::PrintLoopProgress(), NuCounter::PrintMicroDST(), NuLibrary::reco, NuInputEvents::ResetNuEventLoopPositionToStart(), NuInputEvents::ResetNuMCEventLoopPositionToStart(), SanityCheckedAnaVersion(), and UpdatePotSinceLastEvt(). { //do the histogram IO NuOutputWriter* poutput=new NuOutputWriter(); NuInputEvents& input=this->DoIO(poutput,"NuDSTMicroNMB11"); //get a reference NuOutputWriter& output=(*poutput); //get an instance of the code library NuLibrary& lib=NuLibrary::Instance(); const NuPlots* plots=0; //version to do reco/cuts with NuCuts::NuAnaVersion_t overrideAnaVersion= (NuCuts::NuAnaVersion_t)selector; //prepare for loop input.ResetNuEventLoopPositionToStart(); cout<<endl <<"************************************************"<<endl <<"*** Starting main loop over snarls ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuEvent();++i) { lib.cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuEvent(),1); NuEvent& nu=const_cast<NuEvent&>(input.GetNextNuEvent(Msg::kDebug)); //OVERRIDE nu.anaVersion=this->SanityCheckedAnaVersion (nu.anaVersion,overrideAnaVersion); //count up the pots Bool_t newEvt=false; this->UpdatePotSinceLastEvt(nu,newEvt); //RE-RECONSTRUCT the neutrino energy, including kNN lib.reco.GetEvtEnergy(nu, true); lib.reco.ApplyReweights(nu); //MAXMSG("NuDSTAna",Msg::kWarning,5) //<<"Note: setting rw variable to use SKZP RunI beam weight"<<endl; //nu.rw=nu.beamWeightRunI; //make the preselection cuts if (!this->IsGoodPreSelectionCuts(plots,nu)) continue; // Make the advanced cuts if (!this->IsGoodStdCuts(plots,nu)) continue; //figure out the first and last time in the whole ntuple //this is very useful for making plots of quantities vs time plots->FillNtupleEarliestLatestTime(nu); //count the events to print to screen if (nu.charge==-1) { lib.cnt.nuNQCounter++; } else if (nu.charge==+1) { lib.cnt.nuPQCounter++; } //copy pots since last event to ntuple for this new evt newEvt=true; this->UpdatePotSinceLastEvt(nu,newEvt); //get the output nu to fill, copy nu to the output nu, fill tree NuEvent& nuOutput=output.GetNuEventToFill(); nuOutput=nu; output.FillNuEventTree(); } input.InitialiseNuMCEventBranch(); input.ResetNuMCEventLoopPositionToStart(); cout<<endl <<"************************************************"<<endl <<"*** Starting loop over truth info ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuMCEvent();++i) { lib.cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuMCEvent(),1); NuMCEvent& mc=const_cast<NuMCEvent&>(input.GetNextNuMCEvent (Msg::kDebug)); //OVERRIDE mc.anaVersion=this->SanityCheckedAnaVersion (mc.anaVersion,overrideAnaVersion); MAXMSG("NuDSTAna",Msg::kInfo,5) <<"energyMC="<<mc.energyMC<<endl; //make fid vol cut if (!lib.cuts.IsInFidVolTrueEvt(mc)) continue; //MAXMSG("NuDSTAna",Msg::kWarning,5) //<<"Note: setting rw variable to use SKZP RunI beam weight"<<endl; //mc.rw=mc.beamWeightRunI; //get the output nu to fill,copy mc to the output mc, fill tree NuMCEvent& mcOutput=output.GetNuMCEventToFill(); mcOutput=mc; output.FillNuMCEventTree(); } //print out the numbers of events lib.cnt.PrintMicroDST(); //close the file and write out everything output.Finish(); }

void NuDSTAna::MMAna (  std::string  sOutputFileName = ""  )

Definition at line 5367 of file NuDSTAna.cxx. References DoIO(). { this->DoIO(0,"",sOutputFileName); }

void NuDSTAna::MMRereco (  std::string  sOutputFileName = "", TString  xmlFileName = "" )

Definition at line 5400 of file NuDSTAna.cxx. References NuMCEvent::anaVersion, NuXMLConfig::AnaVersion(), NuEvent::anaVersion, NuXMLConfig::AnaVersionString(), NuEvent::applyBeamWeight, NuReco::ApplyReweights(), NuMCEvent::beamWeight, NuEvent::beamWeight, NuMCEvent::beamWeightRunI, NuEvent::beamWeightRunI, NuMCEvent::beamWeightRunII, NuEvent::beamWeightRunII, NuXMLConfig::BinningScheme(), NuEvent::charge, NuLibrary::cnt, NuLibrary::cuts, NuEvent::detectorWeightNM, NuEvent::detectorWeightNMB, NuEvent::detectorWeightNMBRunI, NuEvent::detectorWeightNMBRunII, NuEvent::detectorWeightNMRunI, NuEvent::detectorWeightNMRunII, DoIO(), DoSystematicShifts(), NuEvent::energy, NuMCEvent::energyMC, NuEvent::energyMC, NuCounter::evtCounter, NuCutter::Failed(), NuHistos::FillMatrixMethodHistos(), NuHistos::FillMatrixMethodNCHistos(), NuPlots::FillTrueFidEnergySpect(), NuCuts::FreeCuts(), NuInputEvents::GetEntriesNuEvent(), NuInputEvents::GetEntriesNuMCEvent(), NuReco::GetEvtEnergy(), NuInputEvents::GetNextNuEvent(), NuInputEvents::GetNextNuMCEvent(), NuXMLConfig::GetUnknownKey(), NuLibrary::hist, NuEvent::index, NuInputEvents::InitialiseNuMCEventBranch(), NuLibrary::Instance(), NuCutter::IsValid(), NuCutter::MakeCuts(), MAXMSG, MSG, NuCounter::nuNQCounter, NuCounter::nuPQCounter, Oscillate(), NuCutter::Passed(), plots(), NuBase::PrintLoopProgress(), NuCutter::PrintSummary(), NuLibrary::reco, NuInputEvents::ResetNuEventLoopPositionToStart(), NuInputEvents::ResetNuMCEventLoopPositionToStart(), NuXMLConfig::RunPeriod(), NuMCEvent::rw, SanityCheckedAnaVersion(), NuCutter::SetCut(), NuEvent::shwEnWeight, NuEvent::shwEnWeightRunI, NuEvent::shwEnWeightRunII, NuEvent::trkEnWeight, NuEvent::trkEnWeightRunI, and NuEvent::trkEnWeightRunII. { NuInputEvents& input=this->DoIO(0,"",sOutputFileName); //get an instance of the code library NuLibrary& lib=NuLibrary::Instance(); //get an object to fill plots const NuPlots* plots=new NuPlots(); //Get the NuXMLConfig object for configuration. NuXMLConfig* xmlConfig = 0; if (xmlFileName.IsNull()) { xmlConfig = new NuXMLConfig(); xmlConfig->Write(); } else { xmlConfig = new NuXMLConfig(xmlFileName); xmlConfig->Write(); } //Binning scheme NuBinningScheme::NuBinningScheme_t binningScheme = static_cast<NuBinningScheme::NuBinningScheme_t>(xmlConfig->BinningScheme()); // Create the cutter objects NuCutter cutter(xmlConfig->AnaVersionString(), plots); NuCutter NCcutter; //version to do reco/cuts with NuCuts::NuAnaVersion_t overrideAnaVersion = static_cast<NuCuts::NuAnaVersion_t>(cutter.AnaVersion()); // Check to see if the user wants to do an NC cut along with the CC one if (! xmlConfig->GetUnknownKey("anaVersionNC").IsNull()) { MSG("NuDSTAna",Msg::kInfo) << "Found anaVersionNC in configuration... Doing additional NC cuts" << endl; NCcutter.SetCut(xmlConfig->GetUnknownKey("anaVersionNC")); } else{ MSG("NuDSTAna",Msg::kInfo) << "Didn't find anaVersionNC key in configuration. No NC histograms will be produced." << endl; } input.ResetNuEventLoopPositionToStart(); cout<<endl <<"************************************************"<<endl <<"*** Starting main loop over snarls ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuEvent();++i) { lib.cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuEvent(),1); NuEvent &nu=const_cast<NuEvent&>(input.GetNextNuEvent(Msg::kDebug)); //OVERRIDE //Selection nu.anaVersion=this->SanityCheckedAnaVersion (nu.anaVersion,overrideAnaVersion); //Reweighting if (-1==xmlConfig->RunPeriod()){ MAXMSG("NuDSTAna",Msg::kInfo,5) <<"Not performing any reweighting" << endl; nu.applyBeamWeight = false; } //Should change rwActual, not beamWeight if (0==xmlConfig->RunPeriod()){ nu.applyBeamWeight = true; nu.beamWeight = nu.beamWeight; } if (1==xmlConfig->RunPeriod()){ nu.applyBeamWeight = true; nu.beamWeight = nu.beamWeightRunI; nu.trkEnWeight = nu.trkEnWeightRunI; nu.shwEnWeight = nu.shwEnWeightRunI; nu.detectorWeightNMB = nu.detectorWeightNMBRunI; nu.detectorWeightNM = nu.detectorWeightNMRunI; } if (2==xmlConfig->RunPeriod()){ nu.applyBeamWeight = true; nu.beamWeight = nu.beamWeightRunII; nu.trkEnWeight = nu.trkEnWeightRunII; nu.shwEnWeight = nu.shwEnWeightRunII; nu.detectorWeightNMB = nu.detectorWeightNMBRunII; nu.detectorWeightNM = nu.detectorWeightNMRunII; } //RE-RECONSTRUCT the neutrino energy lib.reco.GetEvtEnergy(nu, false); lib.reco.ApplyReweights(nu); //apply the systematic shift if required according to xmlConfig this->DoSystematicShifts(nu,xmlConfig); // Do the cuts: cutter.MakeCuts(nu); NCcutter.MakeCuts(nu); // If neither of these passed, continue if (cutter.Failed() && NCcutter.Failed()) continue; // For now, print a warning if the event passes both cuts. If we care, we can // print more information out here if (cutter.Passed() && NCcutter.Passed()) { MAXMSG("NuDSTAna",Msg::kWarning, 10) << "Event passed multiple cuts!" << endl; } // Oscillate if desired (to make fake data) this->Oscillate(nu,xmlConfig); // did we pass the (CC?) selection? if (cutter.Passed()) { // making the cuts via the xml MAXMSG("NuDSTAna",Msg::kInfo,5) <<"xmlcut: " << xmlConfig->AnaVersionString() <<" charge: " << nu.charge << endl; // Process dave's free cuts stuff if (xmlConfig->AnaVersion() == 16 && nu.charge>0){ if(!lib.cuts.FreeCuts(nu,xmlConfig))continue; } //make the final plots //if (plots) this->MakeFinalPlots(plots,nu); if (nu.charge==-1) lib.cnt.nuNQCounter++; else if (nu.charge==+1) lib.cnt.nuPQCounter++; else cout<<"ahhh, bad charge (8)"<<endl; //fill matrix method histos lib.hist.FillMatrixMethodHistos(nu, binningScheme); MAXMSG("NuDSTAna",Msg::kInfo,5) <<"Passed: index="<<nu.index <<", energy="<<nu.energy<<", energyMC="<<nu.energyMC<<endl; } // Now, if we selected NC: if (NCcutter.Passed()) { lib.hist.FillMatrixMethodNCHistos(nu, binningScheme); } }//end of loop over summary tree input.InitialiseNuMCEventBranch(); input.ResetNuMCEventLoopPositionToStart(); input.InitialiseNuMCEventBranch(); input.ResetNuMCEventLoopPositionToStart(); cout<<endl <<"************************************************"<<endl <<"*** Starting loop over truth info ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuMCEvent();++i) { lib.cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuMCEvent(),1); NuMCEvent& mc=const_cast<NuMCEvent&>(input.GetNextNuMCEvent (Msg::kDebug)); //OVERRIDE //Selection mc.anaVersion=this->SanityCheckedAnaVersion (mc.anaVersion,overrideAnaVersion); MAXMSG("NuDSTAna",Msg::kInfo,5) <<"energyMC="<<mc.energyMC<<endl; //make fid vol cut //if (!lib.cuts.IsInFidVolTrueEvt(mc)) continue; if (!cutter.GetCut()->InFidVolTrueEvt(mc)) continue; //override weights //mc.rw=mc.beamWeightRunI; if (-1==xmlConfig->RunPeriod()){ mc.rw = 1.0; } //Should change rwActual, not beamWeight if (0==xmlConfig->RunPeriod()){ mc.rw = mc.beamWeight; } if (1==xmlConfig->RunPeriod()){ mc.rw = mc.beamWeightRunI; } if (2==xmlConfig->RunPeriod()){ mc.rw = mc.beamWeightRunII; } this->Oscillate(mc,xmlConfig); //fill plots if (plots) plots->FillTrueFidEnergySpect(mc,binningScheme); } MSG("NuAnalysis",Msg::kInfo)<<"Finished main loop"<<endl; cutter.PrintSummary(); // If the NC cutter is valid, print for that too if (NCcutter.IsValid()) { MSG("NuDSTAna",Msg::kInfo) << "Cutting statistics for NC cut:" << endl; NCcutter.PrintSummary(); } MSG("NuAnalysis",Msg::kInfo) <<" ** Finished MMRereco method **"<<endl; }

void NuDSTAna::MMTransition (  std::string  sOutputFileName = "", TString  xmlFileName = "" )

Definition at line 5629 of file NuDSTAna.cxx. References NuEvent::anaVersion, NuMCEvent::anaVersion, NuXMLConfig::AnaVersion(), NuEvent::applyBeamWeight, NuReco::ApplyReweights(), NuEvent::beamWeight, NuMCEvent::beamWeight, NuEvent::beamWeightRunI, NuMCEvent::beamWeightRunI, NuEvent::beamWeightRunII, NuMCEvent::beamWeightRunII, NuXMLConfig::BinningScheme(), NuLibrary::cnt, NuLibrary::cuts, NuMCEvent::detector, NuEvent::detectorWeightNM, NuEvent::detectorWeightNMB, NuEvent::detectorWeightNMBRunI, NuEvent::detectorWeightNMBRunII, NuEvent::detectorWeightNMRunI, NuEvent::detectorWeightNMRunII, DoIO(), NuMCEvent::energyMC, NuCounter::evtCounter, NuTransition::Fill(), NuHistos::FillMatrixMethodHistos(), NuPlots::FillTrueFidEnergySpect(), NuInputEvents::GetEntriesNuEvent(), NuInputEvents::GetEntriesNuMCEvent(), NuReco::GetEvtEnergy(), NuInputEvents::GetNextNuEvent(), NuInputEvents::GetNextNuMCEvent(), NuLibrary::hist, NuInputEvents::InitialiseNuEventBranch(), NuInputEvents::InitialiseNuMCEventBranch(), NuLibrary::Instance(), IsGoodStdCuts(), NuCuts::IsInFidVolTrueEvt(), MAXMSG, MSG, Oscillate(), plots(), NuBase::PrintLoopProgress(), NuCounter::PrintMicroDST(), NuLibrary::reco, NuInputEvents::ResetNuEventLoopPositionToStart(), NuInputEvents::ResetNuMCEventLoopPositionToStart(), NuTransition::Reweight(), NuXMLConfig::RunPeriod(), NuMCEvent::rw, SanityCheckedAnaVersion(), NuEvent::shwEnWeight, NuEvent::shwEnWeightRunI, NuEvent::shwEnWeightRunII, NuXMLConfig::TransitionProb(), NuEvent::trkEnWeight, NuEvent::trkEnWeightRunI, and NuEvent::trkEnWeightRunII. { NuInputEvents& input=this->DoIO(0,"",sOutputFileName); //get an instance of the code library NuLibrary& lib = NuLibrary::Instance(); //get an object to fill plots const NuPlots* plots=0; //Get the NuXMLConfig object for configuration. NuXMLConfig* xmlConfig = 0; if (xmlFileName.IsNull()) { xmlConfig = new NuXMLConfig(); xmlConfig->Write(); } else { xmlConfig = new NuXMLConfig(xmlFileName); xmlConfig->Write(); } //version to do reco/cuts with NuCuts::NuAnaVersion_t overrideAnaVersion = static_cast<NuCuts::NuAnaVersion_t>(xmlConfig->AnaVersion()); //Binning scheme NuBinningScheme::NuBinningScheme_t binningScheme = static_cast<NuBinningScheme::NuBinningScheme_t>(xmlConfig->BinningScheme()); NuTransition * transition = new NuTransition(xmlConfig); input.InitialiseNuMCEventBranch(); input.ResetNuMCEventLoopPositionToStart(); NuMCEvent& mc=const_cast<NuMCEvent&>(input.GetNextNuMCEvent(Msg::kDebug)); if (xmlConfig->TransitionProb() > 0 && mc.detector == Detector::kFar) { input.ResetNuMCEventLoopPositionToStart(); cout<<endl <<"************************************************"<<endl <<"*** Starting loop over truth info ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuMCEvent();++i) { lib.cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuMCEvent(),1); NuMCEvent& mc=const_cast<NuMCEvent&>(input.GetNextNuMCEvent (Msg::kDebug)); //OVERRIDE //Selection mc.anaVersion=this->SanityCheckedAnaVersion (mc.anaVersion,overrideAnaVersion); MAXMSG("NuDSTAna",Msg::kInfo,5) <<"energyMC="<<mc.energyMC<<endl; //make fid vol cut if (!lib.cuts.IsInFidVolTrueEvt(mc)) continue; //override weights //mc.rw=mc.beamWeightRunI; if (-1==xmlConfig->RunPeriod()){ mc.rw = 1.0; } //Should change rwActual, not beamWeight if (0==xmlConfig->RunPeriod()){ mc.rw = mc.beamWeight; } if (1==xmlConfig->RunPeriod()){ mc.rw = mc.beamWeightRunI; } if (2==xmlConfig->RunPeriod()){ mc.rw = mc.beamWeightRunII; } transition->Fill(mc); this->Oscillate(mc,xmlConfig); //fill plots plots->FillTrueFidEnergySpect(mc,binningScheme); } } input.InitialiseNuEventBranch(); input.ResetNuEventLoopPositionToStart(); cout<<endl <<"************************************************"<<endl <<"*** Starting main loop over snarls ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuEvent();++i) { //for (Int_t i=0;i<0;++i) { lib.cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuEvent(),1); NuEvent &nu=const_cast<NuEvent&>(input.GetNextNuEvent(Msg::kDebug)); //OVERRIDE //Selection nu.anaVersion=this->SanityCheckedAnaVersion (nu.anaVersion,overrideAnaVersion); //Reweighting if (-1==xmlConfig->RunPeriod()){ MAXMSG("NuDSTAna",Msg::kInfo,5) <<"Not performing any reweighting" << endl; nu.applyBeamWeight = false; } //Should change rwActual, not beamWeight if (0==xmlConfig->RunPeriod()){ nu.applyBeamWeight = true; nu.beamWeight = nu.beamWeight; } if (1==xmlConfig->RunPeriod()){ nu.applyBeamWeight = true; nu.beamWeight = nu.beamWeightRunI; nu.trkEnWeight = nu.trkEnWeightRunI; nu.shwEnWeight = nu.shwEnWeightRunI; nu.detectorWeightNMB = nu.detectorWeightNMBRunI; nu.detectorWeightNM = nu.detectorWeightNMRunI; } if (2==xmlConfig->RunPeriod()){ nu.applyBeamWeight = true; nu.beamWeight = nu.beamWeightRunII; nu.trkEnWeight = nu.trkEnWeightRunII; nu.shwEnWeight = nu.shwEnWeightRunII; nu.detectorWeightNMB = nu.detectorWeightNMBRunII; nu.detectorWeightNM = nu.detectorWeightNMRunII; } //RE-RECONSTRUCT the neutrino energy lib.reco.GetEvtEnergy(nu, false); lib.reco.ApplyReweights(nu); if (!this->IsGoodStdCuts(plots,nu)) continue; //NuEvent *nuOsc = (NuEvent*)nu.Clone(); //NuEvent *nuTrans = transition->GetTransitionEvent(nu); // Reweight for systematics, oscillations and transitions transition->Reweight(nu); // apply the systematic shift if required according to xmlConfig // but only to the normal, not the appeared event //this->DoSystematicShifts(*nuOsc,xmlConfig); // Oscillate if desired (to make fake data) //this->Oscillate(*nuOsc,xmlConfig); // Reduce taus corresponding to transitions //if (nuOsc->inu == 16 || nuOsc->inu == -16) { // MAXMSG("NuDSTAna",Msg::kInfo,1) // << "Weighting down appeared NuTaus IN NUDSTANA for transitions by " // << (1.0 - xmlConfig->TransitionProb()) << endl; // nuOsc->rw *= (1.0 - xmlConfig->TransitionProb()); //} //double oldWeight = nuOsc->rw; //delete nuOsc; //if (nuTrans) { // oldWeight += nuTrans->rw; // delete nuTrans; //} //if (TMath::Abs(oldWeight - nu.rw) < 1e-5) { // MAXMSG("NuDSTAna",Msg::kInfo,5) << "===> Weights OK!" << endl; //} //else { // MSG("NuDSTAna",Msg::kInfo) << "===> Weights disagree: old = " << oldWeight << ", new = " << nu.rw << endl; //} // fill matrix method histos // for the original oscillated event, nu or nubar lib.hist.FillMatrixMethodHistos(nu, binningScheme); } MSG("NuAnalysis",Msg::kInfo)<<"Finished main loop"<<endl; //print out the numbers of events lib.cnt.PrintMicroDST(); MSG("NuAnalysis",Msg::kInfo) <<" ** Finished MMTransition method **"<<endl; }

void NuDSTAna::NDOsc (   )

Definition at line 6390 of file NuDSTAna.cxx. References abs(), NuEvent::anaVersion, NuEvent::applyBeamWeight, NuReco::ApplyReweights(), NuEvent::beamWeight, NuEvent::beamWeightRunI, NuEvent::charge, NuLibrary::cnt, NuEvent::detectorWeightNM, NuEvent::detectorWeightNMB, NuEvent::detectorWeightNMBRunI, NuEvent::detectorWeightNMRunI, DoIO(), NuEvent::energy, NuEvent::energyMC, NuCounter::evtCounter, NuInputEvents::GetEntriesNuEvent(), NuReco::GetEvtEnergy(), NuInputEvents::GetNextNuEvent(), NuEvent::iaction, NuEvent::index, NuLibrary::Instance(), NuEvent::inu, IsGoodStdCuts(), MAXMSG, MSG, NuEvent::neuEnMC, NuCounter::nuNQCounter, NuCounter::nuPQCounter, NuUtilities::OscillationWeight(), NuBase::PrintLoopProgress(), NuCounter::PrintMicroDST(), NuLibrary::reco, NuUtilities::RecoBins(), NuInputEvents::ResetNuEventLoopPositionToStart(), NuEvent::rw, SanityCheckedAnaVersion(), NuEvent::shwEnWeight, NuEvent::shwEnWeightRunI, NuEvent::trkEnWeight, NuEvent::trkEnWeightRunI, NuEvent::Vz, and NuEvent::zTrkVtx. { NuInputEvents& input=this->DoIO(0,"",""); //get an instance of the code library NuLibrary& lib=NuLibrary::Instance(); //get an object to fill plots //const NuPlots* plots=0; //version to do reco/cuts with NuCuts::NuAnaVersion_t overrideAnaVersion = NuCuts::kNMB0325Bravo; //Binning scheme NuBinningScheme::NuBinningScheme_t binningScheme = NuBinningScheme::kNuMuBar0325Std2; const NuUtilities cuts; std::vector<Double_t> vReco = cuts.RecoBins(binningScheme); int nbins = vReco.size() - 1; Double_t *bins = &(vReco[0]); // Initialize the plots TH1D *gdist = new TH1D("gdist","#nu_{#mu} Distance Traveled",1000,0,2); TH1D *hdist = new TH1D("hdist","#bar{#nu}_{#mu} Distance Traveled",1000,0,2); TH1D *h[100]; TH1D *g[100]; TString num; for (int i = 0; i < 100; i++) { num.Form("%04i",i*20); h[i] = new TH1D("h"+num,"#Delta #bar{m}^{2} = "+num+"e-3 eV^{2}",nbins, bins); g[i] = new TH1D("g"+num,"#Delta m^{2} = "+num+"e-3 eV^{2}",nbins, bins); } double osc = 1.; double sn2 = 1.; double dm2 = 0; double dist = 0; double cm2km = 1./(100.*1000.); double m2km = 1./(1000.); input.ResetNuEventLoopPositionToStart(); cout<<endl <<"************************************************"<<endl <<"*** Starting main loop over snarls ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuEvent();++i) { //for (Int_t i=0;i<0;++i) { lib.cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuEvent(),1); NuEvent &nu=const_cast<NuEvent&>(input.GetNextNuEvent(Msg::kDebug)); //OVERRIDE //Selection nu.anaVersion=this->SanityCheckedAnaVersion (nu.anaVersion,overrideAnaVersion); //Reweighting nu.applyBeamWeight = true; nu.beamWeight = nu.beamWeightRunI; nu.trkEnWeight = nu.trkEnWeightRunI; nu.shwEnWeight = nu.shwEnWeightRunI; nu.detectorWeightNMB = nu.detectorWeightNMBRunI; nu.detectorWeightNM = nu.detectorWeightNMRunI; //RE-RECONSTRUCT the neutrino energy lib.reco.GetEvtEnergy(nu, false); lib.reco.ApplyReweights(nu); //make all the std cuts if (!this->IsGoodStdCuts(0,nu)) continue; osc = 1; for (int i = 0; i < 100; i++) { //check for CC nubars if (1 == nu.iaction && abs(nu.inu) == 14) { dm2 = i; dm2 *= 20.*1e-3; dist = (104000.0 - nu.Vz)*cm2km + (nu.zTrkVtx - 13.5)*m2km; osc = NuUtilities::OscillationWeight(nu.neuEnMC, dm2, sn2); } if (nu.charge == 1) { h[i]->Fill(nu.energy, nu.rw*osc); } else { g[i]->Fill(nu.energy, nu.rw*osc); } } if (nu.charge == 1) { hdist->Fill(dist, nu.rw); } else { gdist->Fill(dist, nu.rw); } if (nu.charge==-1) lib.cnt.nuNQCounter++; else if (nu.charge==+1) lib.cnt.nuPQCounter++; else cout<<"ahhh, bad charge (11)"<<endl; MAXMSG("NuDSTAna",Msg::kInfo,5) <<"Passed: index="<<nu.index <<", energy="<<nu.energy<<", energyMC="<<nu.energyMC<<endl; }//end of loop over summary tree MSG("NuAnalysis",Msg::kInfo)<<"Finished main loop"<<endl; //print out the numbers of events lib.cnt.PrintMicroDST(); MSG("NuAnalysis",Msg::kInfo) <<" ** Finished NDOsc method **"<<endl; }

void NuDSTAna::NDQPRB (  bool  cedar  )

Definition at line 7108 of file NuDSTAna.cxx. References NuEvent::anaVersion, NuEvent::applyBeamWeight, NuEvent::applyEnergyShifts, NuReco::ApplyReweights(), NuEvent::charge, NuLibrary::cnt, NuEvent::containmentFlag, DoIO(), NuCounter::evtCounter, NuZBeamReweight::ExtractZBeamReweight(), NuInputEvents::GetEntriesNuEvent(), NuReco::GetEvtEnergy(), NuInputEvents::GetNextNuEvent(), NuLibrary::Instance(), IsGoodPreSelectionCuts(), MSG, NuCounter::nuNQCounter, NuCounter::nuPQCounter, NuEvent::planeTrkVtx, plots(), NuBase::PrintLoopProgress(), NuCounter::PrintMicroDST(), NuEvent::qp, NuEvent::qp_rangebiased, NuLibrary::reco, NuInputEvents::ResetNuEventLoopPositionToStart(), NuEvent::runPeriod, NuEvent::rw, NuEvent::simFlag, NuEvent::trkEnMC, NuEvent::trkLength, NuEvent::xTrkEnd, NuEvent::xTrkVtx, NuEvent::yTrkEnd, NuEvent::yTrkVtx, NuLibrary::zBeamReweight, NuEvent::zTrkEnd, and NuEvent::zTrkVtx. { cout<<endl <<"***********************************************"<<endl <<"*** Starting NDQPRB() ***"<<endl <<"***********************************************"<<endl << endl;; NuInputEvents& input=this->DoIO(0,"",""); //get an instance of the code library NuLibrary& lib=NuLibrary::Instance(); input.ResetNuEventLoopPositionToStart(); const int Ncont = 4; TString contNames[] = {"cont1","cont2","cont3","cont4"}; TString varNames[99]; double varMin[99]; double varMax[99]; double vals[99]; int v = 0; varNames[0] = "trkEnMC"; varMin[v] = 0; varMax[v] = 50; v = 1; varNames[v] = "xTrkVtx"; varMin[v] = 0.5; varMax[v] = 2.5; v = 2; varNames[v] = "yTrkVtx"; varMin[v] = -0.75; varMax[v] = 1.25; v = 3; varNames[v] = "zTrkVtx"; varMin[v] = 0.5; varMax[v] = 4.5; v = 4; varNames[v] = "xTrkEnd"; varMin[v] = -2; varMax[v] = 3; v = 5; varNames[v] = "yTrkEnd"; varMin[v] = -2.5; varMax[v] = 2.5; v = 6; varNames[v] = "zTrkEnd"; varMin[v] = 7; varMax[v] = 17; v = 7; varNames[v] = "trkLength"; varMin[v] = 40; varMax[v] = 280; v = 8; varNames[v] = "qp"; varMin[v] = -1; varMax[v] = 1; v = 9; varNames[v] = "invqp"; varMin[v] = -200; varMax[v] = 200; v = 10; varNames[v] = "specLength"; varMin[v] = 0; varMax[v] = 180; const int Nvars = 11; int nbinsX = 250; int nbinsY = 500; double minY = -1; double maxY = 9; double valy; TH2D *plots[Nvars][Ncont]; for (int v = 0; v < Nvars; v++) { for (int c = 0; c < Ncont; c++) { plots[v][c] = new TH2D("h"+varNames[v]+"_"+contNames[c], contNames[c]+";"+varNames[v]+";Reco-True/True", nbinsX, varMin[v], varMax[v], nbinsY, minY, maxY); } } cout<<endl <<"************************************************"<<endl <<"*** Starting main loop over snarls ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuEvent();++i) { lib.cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuEvent(),1); if (i < 200) cout << "Debug: i=" << i << "/" << input.GetEntriesNuEvent() << endl;; NuEvent &nu=const_cast<NuEvent&>(input.GetNextNuEvent(Msg::kInfo)); if (nu.trkEnMC == 0) continue; // Only events with real track energy if (!cedar && nu.qp_rangebiased == 0) continue; // Only events with passed track if (cedar && nu.qp == 0) continue; // Only events with passed track // Only care about preselected nubars here nu.anaVersion = NuCuts::kNMB0325Bravo; if (!this->IsGoodPreSelectionCuts(0,nu)) continue; //OVERRIDE //RE-RECONSTRUCT the neutrino energy // Redo the beam weights if (nu.simFlag==SimFlag::kMC) { nu.runPeriod = 0; lib.zBeamReweight.ExtractZBeamReweight(nu); //Reweighting nu.applyBeamWeight = true; nu.applyEnergyShifts = false; nu.rw = 1; lib.reco.ApplyReweights(nu); } // First do nominal qp, nominal SKZP lib.reco.GetEvtEnergy(nu, false); int c = nu.containmentFlag - 1; vals[0] = nu.trkEnMC; vals[1] = nu.xTrkVtx; vals[2] = nu.yTrkVtx; vals[3] = nu.zTrkVtx; vals[4] = nu.xTrkEnd; vals[5] = nu.yTrkEnd; vals[6] = nu.zTrkEnd; vals[7] = nu.trkLength; if (cedar) { if (nu.qp == 0 || nu.trkEnMC == 0) continue; vals[8] = nu.qp; vals[9] = 1./nu.qp; valy = TMath::Abs(nu.qp*nu.trkEnMC) - 1.; } else { if (nu.qp_rangebiased == 0 || nu.trkEnMC == 0) continue; vals[8] = nu.qp_rangebiased; vals[9] = 1./nu.qp_rangebiased; valy = TMath::Abs(nu.qp_rangebiased*nu.trkEnMC) - 1.; } vals[10] = nu.trkLength - (118-nu.planeTrkVtx); for (int v = 0; v < Nvars; v++) { plots[v][c]->Fill(vals[v], valy, nu.rw); } if (nu.charge==-1) lib.cnt.nuNQCounter++; else if (nu.charge==+1) lib.cnt.nuPQCounter++; else cout<<"ahhh, bad charge (11)"<<endl; }//end of loop over summary tree MSG("NuAnalysis",Msg::kInfo)<<"Finished main loop"<<endl; //print out the numbers of events lib.cnt.PrintMicroDST(); cout<<endl <<"***********************************************"<<endl <<"*** Ending NDQPRB() ***"<<endl <<"***********************************************"<<endl << endl;; }

void NuDSTAna::NDTestAna (   )

Definition at line 2474 of file NuDSTAna.cxx. References NuEvent::anaVersion, NuEvent::applyBeamWeight, NuEvent::applyDetectorWeight, NuEvent::applyEnergyShifts, NuEvent::applyGeneratorWeight, NuReco::ApplyReweights(), NuEvent::beamWeight, NuEvent::charge, NuEvent::containmentFlag, NuEvent::cutOnDataQuality, NuConfig::detector, NuEvent::detectorWeight, DoIO(), NuEvent::energy, NuEvent::energyMC, NuEvent::evt, NuCounter::evtCounter, NuInputEvents::GetEntriesNuEvent(), GetEventND(), NuReco::GetEvtEnergy(), NuInputEvents::GetNextNuEvent(), NuReco::GetShowerEnergyCor(), NuEvent::index, NuLibrary::Instance(), IsGoodStdCuts(), MakeFinalPlots(), MAXMSG, MSG, NuEvent::nshw, NuCounter::nuNQCounter, NuCounter::nuPQCounter, NuBase::OpenTxtFile(), plots(), NuEvent::primshw, NuPlots::PrintEventInfo(), NuBase::PrintLoopProgress(), NuCounter::PrintMicroDST(), NuEvent::qp, NuLibrary::reco, NuInputEvents::ResetNuEventLoopPositionToStart(), NuEvent::run, NuConfig::run, SanityCheckedAnaVersion(), NuEvent::shwEn, NuEvent::shwEnCor, NuEvent::shwEnNoCor, NuEvent::shwEnNoCor1, NuEvent::shwEnNoCor2, NuEvent::shwEnNoCor3, NuEvent::shwEnNoCor4, NuEvent::shwEnWeight, NuEvent::snarl, NuEvent::trkEn, NuEvent::trkEnCorCurv1, NuEvent::trkEnCorCurv2, NuEvent::trkEnCorCurv3, NuEvent::trkEnCorRange1, NuEvent::trkEnCorRange2, NuEvent::trkEnCorRange3, NuEvent::trkEnCurv, NuEvent::trkEnRange, NuEvent::trkEnWeight, NuEvent::trkMomentumRange, NuEvent::xShwVtx1, NuEvent::xShwVtx2, NuEvent::xShwVtx3, NuEvent::xShwVtx4, NuEvent::xTrkVtx, NuEvent::yShwVtx1, NuEvent::yShwVtx2, NuEvent::yShwVtx3, NuEvent::yShwVtx4, NuEvent::yTrkVtx, NuEvent::zShwVtx1, NuEvent::zShwVtx2, NuEvent::zShwVtx3, NuEvent::zShwVtx4, and NuEvent::zTrkVtx. { NuInputEvents& input=this->DoIO(); //use config object to store info NuConfig config; config.detector=Detector::kFar; config.run=100; string sTxt="nmb"; ofstream& nmbTxt=*(this->OpenTxtFile(config,sTxt.c_str())); string sTxtNM="nm"; ofstream& nmTxt=*(this->OpenTxtFile(config,sTxtNM.c_str())); //string sTxtLINM="nmLI"; //ofstream& nmLITxt=*(this->OpenTxtFile(config,sTxtLINM.c_str())); //object to count events NuCounter cnt; static NuGeneral general; const NuPlots* plots=0; static NuCuts cuts; //static NuReco reco;//make a local one TH1F* hRecoEnDiff=new TH1F("hRecoEnDiff","hRecoEnDiff", 200000,-100,100); hRecoEnDiff->SetTitle("Reconstructed Energy Difference (GeV)"); hRecoEnDiff->GetXaxis()-> SetTitle("Reconstructed Energy Difference (GeV)"); hRecoEnDiff->GetXaxis()->CenterTitle(); hRecoEnDiff->GetYaxis()->SetTitle(""); hRecoEnDiff->GetYaxis()->CenterTitle(); hRecoEnDiff->SetFillColor(0); hRecoEnDiff->SetLineColor(1); //hRecoEnDiff->SetBit(TH1::kCanRebin); TH1F* hRecoEnDiffCurv=new TH1F("hRecoEnDiffCurv","hRecoEnDiffCurv", 200000,-100,100); hRecoEnDiffCurv->SetTitle("Reconstructed Energy Difference (GeV)"); hRecoEnDiffCurv->GetXaxis()-> SetTitle("Reconstructed Energy Difference (GeV)"); hRecoEnDiffCurv->GetXaxis()->CenterTitle(); hRecoEnDiffCurv->GetYaxis()->SetTitle(""); hRecoEnDiffCurv->GetYaxis()->CenterTitle(); hRecoEnDiffCurv->SetFillColor(0); hRecoEnDiffCurv->SetLineColor(1); //hRecoEnDiffCurv->SetBit(TH1::kCanRebin); TH1F* hRecoEnDiffRange=new TH1F("hRecoEnDiffRange","hRecoEnDiffRange", 200000,-100,100); hRecoEnDiffRange->SetTitle("Reconstructed Energy Difference (GeV)"); hRecoEnDiffRange->GetXaxis()-> SetTitle("Reconstructed Energy Difference (GeV)"); hRecoEnDiffRange->GetXaxis()->CenterTitle(); hRecoEnDiffRange->GetYaxis()->SetTitle(""); hRecoEnDiffRange->GetYaxis()->CenterTitle(); hRecoEnDiffRange->SetFillColor(0); hRecoEnDiffRange->SetLineColor(1); //hRecoEnDiffRange->SetBit(TH1::kCanRebin); TH1F* hRecoTrkEnDiff=new TH1F("hRecoTrkEnDiff","hRecoTrkEnDiff", 200000,-100,100); hRecoTrkEnDiff->SetTitle("Reconstructed Trk Energy Difference (GeV)"); hRecoTrkEnDiff->GetXaxis()-> SetTitle("Reconstructed Trk Energy Difference (GeV)"); hRecoTrkEnDiff->GetXaxis()->CenterTitle(); hRecoTrkEnDiff->GetYaxis()->SetTitle(""); hRecoTrkEnDiff->GetYaxis()->CenterTitle(); hRecoTrkEnDiff->SetFillColor(0); hRecoTrkEnDiff->SetLineColor(1); //hRecoTrkEnDiff->SetBit(TH1::kCanRebin); TH1F* hRecoTrkEnDiffCurv=new TH1F("hRecoTrkEnDiffCurv","hRecoTrkEnDiffCurv", 200000,-100,100); hRecoTrkEnDiffCurv->SetTitle("Reconstructed Trk Energy Difference (GeV)"); hRecoTrkEnDiffCurv->GetXaxis()-> SetTitle("Reconstructed Trk Energy Difference (GeV)"); hRecoTrkEnDiffCurv->GetXaxis()->CenterTitle(); hRecoTrkEnDiffCurv->GetYaxis()->SetTitle(""); hRecoTrkEnDiffCurv->GetYaxis()->CenterTitle(); hRecoTrkEnDiffCurv->SetFillColor(0); hRecoTrkEnDiffCurv->SetLineColor(1); //hRecoTrkEnDiffCurv->SetBit(TH1::kCanRebin); TH1F* hRecoTrkEnDiffRange=new TH1F("hRecoTrkEnDiffRange","hRecoTrkEnDiffRange", 200000,-100,100); hRecoTrkEnDiffRange->SetTitle("Reconstructed Trk Energy Difference (GeV)"); hRecoTrkEnDiffRange->GetXaxis()-> SetTitle("Reconstructed Trk Energy Difference (GeV)"); hRecoTrkEnDiffRange->GetXaxis()->CenterTitle(); hRecoTrkEnDiffRange->GetYaxis()->SetTitle(""); hRecoTrkEnDiffRange->GetYaxis()->CenterTitle(); hRecoTrkEnDiffRange->SetFillColor(0); hRecoTrkEnDiffRange->SetLineColor(1); //hRecoTrkEnDiffRange->SetBit(TH1::kCanRebin); TH1F* hRecoShwEnDiff=new TH1F("hRecoShwEnDiff","hRecoShwEnDiff", 200000,-100,100); hRecoShwEnDiff->SetTitle("Reconstructed Shw Energy Difference (GeV)"); hRecoShwEnDiff->GetXaxis()-> SetTitle("Reconstructed Shw Energy Difference (GeV)"); hRecoShwEnDiff->GetXaxis()->CenterTitle(); hRecoShwEnDiff->GetYaxis()->SetTitle(""); hRecoShwEnDiff->GetYaxis()->CenterTitle(); hRecoShwEnDiff->SetFillColor(0); hRecoShwEnDiff->SetLineColor(1); //hRecoShwEnDiff->SetBit(TH1::kCanRebin); TH1F* hRecoShwEnDiffCurv=new TH1F("hRecoShwEnDiffCurv","hRecoShwEnDiffCurv", 200000,-100,100); hRecoShwEnDiffCurv->SetTitle("Reconstructed Shw Energy Difference (GeV)"); hRecoShwEnDiffCurv->GetXaxis()-> SetTitle("Reconstructed Shw Energy Difference (GeV)"); hRecoShwEnDiffCurv->GetXaxis()->CenterTitle(); hRecoShwEnDiffCurv->GetYaxis()->SetTitle(""); hRecoShwEnDiffCurv->GetYaxis()->CenterTitle(); hRecoShwEnDiffCurv->SetFillColor(0); hRecoShwEnDiffCurv->SetLineColor(1); //hRecoShwEnDiffCurv->SetBit(TH1::kCanRebin); TH1F* hRecoShwEnDiffRange=new TH1F("hRecoShwEnDiffRange","hRecoShwEnDiffRange", 200000,-100,100); hRecoShwEnDiffRange->SetTitle("Reconstructed Shw Energy Difference (GeV)"); hRecoShwEnDiffRange->GetXaxis()-> SetTitle("Reconstructed Shw Energy Difference (GeV)"); hRecoShwEnDiffRange->GetXaxis()->CenterTitle(); hRecoShwEnDiffRange->GetYaxis()->SetTitle(""); hRecoShwEnDiffRange->GetYaxis()->CenterTitle(); hRecoShwEnDiffRange->SetFillColor(0); hRecoShwEnDiffRange->SetLineColor(1); //hRecoShwEnDiffRange->SetBit(TH1::kCanRebin); TH1F* hRecoEnOfDiff=new TH1F("hRecoEnOfDiff","hRecoEnOfDiff", 400,-100,100); hRecoEnOfDiff->SetTitle("Reconstructed Energy (GeV)"); hRecoEnOfDiff->GetXaxis()-> SetTitle("Reconstructed Energy (GeV)"); hRecoEnOfDiff->GetXaxis()->CenterTitle(); hRecoEnOfDiff->GetYaxis()->SetTitle(""); hRecoEnOfDiff->GetYaxis()->CenterTitle(); hRecoEnOfDiff->SetFillColor(0); hRecoEnOfDiff->SetLineColor(1); //hRecoEnOfDiff->SetBit(TH1::kCanRebin); TH1F* hRecoTrkEnOfDiff=new TH1F("hRecoTrkEnOfDiff","hRecoTrkEnOfDiff", 400,-100,100); hRecoTrkEnOfDiff->SetTitle("Reconstructed Trk Energy (GeV)"); hRecoTrkEnOfDiff->GetXaxis()-> SetTitle("Reconstructed Trk Energy (GeV)"); hRecoTrkEnOfDiff->GetXaxis()->CenterTitle(); hRecoTrkEnOfDiff->GetYaxis()->SetTitle(""); hRecoTrkEnOfDiff->GetYaxis()->CenterTitle(); hRecoTrkEnOfDiff->SetFillColor(0); hRecoTrkEnOfDiff->SetLineColor(1); //hRecoTrkEnOfDiff->SetBit(TH1::kCanRebin); TH1F* hRecoShwEnOfDiff=new TH1F("hRecoShwEnOfDiff","hRecoShwEnOfDiff", 400,-100,100); hRecoShwEnOfDiff->SetTitle("Reconstructed Shw Energy (GeV)"); hRecoShwEnOfDiff->GetXaxis()-> SetTitle("Reconstructed Shw Energy (GeV)"); hRecoShwEnOfDiff->GetXaxis()->CenterTitle(); hRecoShwEnOfDiff->GetYaxis()->SetTitle(""); hRecoShwEnOfDiff->GetYaxis()->CenterTitle(); hRecoShwEnOfDiff->SetFillColor(0); hRecoShwEnOfDiff->SetLineColor(1); //hRecoShwEnOfDiff->SetBit(TH1::kCanRebin); //get an instance of the code library const NuLibrary& lib=NuLibrary::Instance(); //version to do reco/cuts with NuCuts::NuAnaVersion_t overrideAnaVersion=NuCuts::kCC0325Std; input.ResetNuEventLoopPositionToStart(); cout<<endl <<"************************************************"<<endl <<"*** Starting main loop over snarls ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuEvent();++i) { cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuEvent(),1); NuEvent& nu=const_cast<NuEvent&>(input.GetNextNuEvent(Msg::kDebug)); //OVERRIDE //set the analysis version (could be kFullDST) nu.anaVersion=this->SanityCheckedAnaVersion (nu.anaVersion,overrideAnaVersion); nu.applyEnergyShifts=false; nu.applyBeamWeight=true; nu.applyDetectorWeight=false; nu.applyGeneratorWeight=false; nu.cutOnDataQuality=false; //RE-RECONSTRUCT the neutrino energy lib.reco.GetEvtEnergy(nu, false); lib.reco.ApplyReweights(nu); //make all the std cuts if (!this->IsGoodStdCuts(plots,nu)) continue; Bool_t printToScreen=true; const NuEvent* pnu=0; if (printToScreen && nu.charge==-1) pnu=this->GetEventND(nu); Float_t energyDiff=-1; Float_t trkEnDiff=-1; Float_t shwEnDiff=-1; if (printToScreen && pnu && nu.charge==-1) { const NuEvent& nui=*pnu; static NuReco reco; //reco.GetShowerEnergy(nu); energyDiff=nu.energy-nui.energy; trkEnDiff=nu.trkEn-nui.trkEn; shwEnDiff=nu.shwEn-nui.shwEn; Float_t rangeCurvDiff=nu.trkEnRange-nu.trkEnCurv; MAXMSG("NuDSTAna",Msg::kInfo,50) <<endl<<"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^"<<endl <<"Exists in map: run="<<nu.run <<", snarl="<<nu.snarl<<", evt="<<nu.evt <<endl <<"My energy="<<nu.energy<<", CC std energy="<<nui.energy <<", Ediff="<<energyDiff <<endl <<"My trkEn="<<nu.trkEn<<", CC std trkEn="<<nui.trkEn <<", trkEnDiff="<<trkEnDiff <<endl <<"My shwEn="<<nu.shwEn<<", CC std shwEn="<<nui.shwEn <<", shwEnDiff="<<shwEnDiff <<endl; if (TMath::Abs(energyDiff)>0.005*(Munits::GeV)) { Float_t p=-1; if (nu.qp) p=1./nu.qp; MAXMSG("NuDSTAna",Msg::kInfo,50) <<endl<<"************************"<<endl <<endl<<"************************"<<endl <<endl<<"************************"<<endl <<endl<<"************************"<<endl <<"run="<<nu.run<<", snarl="<<nu.snarl<<", evt="<<nu.evt <<endl <<"My energy="<<nu.energy<<", CC std energy="<<nui.energy <<", Ediff="<<energyDiff <<endl <<"My trkEn="<<nu.trkEn<<", CC std trkEn="<<nui.trkEn <<", trkEnDiff="<<trkEnDiff <<endl <<"My shwEn="<<nu.shwEn<<", CC std shwEn="<<nui.shwEn <<", shwEnDiff="<<shwEnDiff <<endl <<"shwEn="<<nu.shwEn <<", shwEnCor="<<nu.shwEnCor <<", shwEnNoCor="<<nu.shwEnNoCor <<", primshw="<<nu.primshw <<", nshw="<<nu.nshw <<endl <<"shwEnNoCor1="<<nu.shwEnNoCor1 <<", shwEnNoCor2="<<nu.shwEnNoCor2 <<", shwEnNOCor3="<<nu.shwEnNoCor3 <<", shwEnNoCor4="<<nu.shwEnNoCor4 <<endl <<"shower1 E="<<reco.GetShowerEnergyCor(nu.shwEnNoCor1,CandShowerHandle::kCC,nu) <<" : x,y,z="<<nu.xShwVtx1 <<","<<nu.yShwVtx1 <<","<<nu.zShwVtx1 <<endl <<"shower2 E="<<reco.GetShowerEnergyCor(nu.shwEnNoCor2,CandShowerHandle::kCC,nu) <<" : x,y,z="<<nu.xShwVtx2 <<","<<nu.yShwVtx2 <<","<<nu.zShwVtx2 <<endl <<"shower3 E="<<reco.GetShowerEnergyCor(nu.shwEnNoCor3,CandShowerHandle::kCC,nu) <<" : x,y,z="<<nu.xShwVtx3 <<","<<nu.yShwVtx3 <<","<<nu.zShwVtx3 <<endl <<"shower4 E="<<reco.GetShowerEnergyCor(nu.shwEnNoCor4,CandShowerHandle::kCC,nu) <<" : x,y,z="<<nu.xShwVtx4 <<","<<nu.yShwVtx4 <<","<<nu.zShwVtx4 <<endl <<"track x,y,z="<<nu.xTrkVtx <<","<<nu.yTrkVtx <<","<<nu.zTrkVtx <<endl <<"trkEnRange="<<nu.trkEnRange <<", trkEnCurv="<<nu.trkEnCurv <<", rng-crv="<<rangeCurvDiff <<endl <<"rangeNoCor="<<nu.trkMomentumRange <<", curvNoCor="<<p <<endl <<"trkEnCorRange1="<<nu.trkEnCorRange1 <<", trkEnCorRange2="<<nu.trkEnCorRange2 <<", trkEnCorRange3="<<nu.trkEnCorRange3 <<endl <<"trkEnCorCurv1="<<nu.trkEnCorCurv1 <<", trkEnCorCurv2="<<nu.trkEnCorCurv2 <<", trkEnCorCurv3="<<nu.trkEnCorCurv3 <<endl; hRecoEnOfDiff->Fill(nu.energy); hRecoTrkEnOfDiff->Fill(nu.trkEn); hRecoShwEnOfDiff->Fill(nu.shwEn); } hRecoEnDiff->Fill(energyDiff); hRecoTrkEnDiff->Fill(trkEnDiff); hRecoShwEnDiff->Fill(shwEnDiff); if (nu.containmentFlag==1 || nu.containmentFlag==3) { hRecoEnDiffRange->Fill(energyDiff); hRecoTrkEnDiffRange->Fill(trkEnDiff); hRecoShwEnDiffRange->Fill(shwEnDiff); } else if (nu.containmentFlag==2 || nu.containmentFlag==4) { hRecoEnDiffCurv->Fill(energyDiff); hRecoTrkEnDiffCurv->Fill(trkEnDiff); hRecoShwEnDiffCurv->Fill(shwEnDiff); } else cout<<"Ahhhhh"<<endl; } //only pass the ones that aren't in trish's sample //if (pnu) continue; //if (nu.snarl>=140344) continue; if (nu.snarl>=56595) continue; if (nu.charge==-1) { plots->PrintEventInfo(nmTxt,nu); cnt.nuNQCounter++; } else if (nu.charge==+1) { plots->PrintEventInfo(nmbTxt,nu); cnt.nuPQCounter++; } else cout<<"ahhh, bad charge (2)"<<endl; MAXMSG("NuDSTAna",Msg::kInfo,50) <<"Weights before: beam="<<nu.beamWeight <<", det="<<nu.detectorWeight <<", trk="<<nu.trkEnWeight <<", shw="<<nu.shwEnWeight <<endl; Float_t beamWeightBefore=nu.beamWeight; //lib.zBeamReweight.ExtractZBeamReweight(nu); Float_t beamDiff=nu.beamWeight-beamWeightBefore; MAXMSG("NuDSTAna",Msg::kInfo,50) <<"Weights after: beam="<<nu.beamWeight <<", det="<<nu.detectorWeight <<", trk="<<nu.trkEnWeight <<", shw="<<nu.shwEnWeight <<", bdiff="<<beamDiff <<endl; //make the final plots this->MakeFinalPlots(plots,nu); MAXMSG("NuDSTAna",Msg::kInfo,5) <<"Passed: index="<<nu.index <<", energy="<<nu.energy<<", energyMC="<<nu.energyMC<<endl; }//end of loop over summary tree MSG("NuAnalysis",Msg::kInfo)<<"Finished main loop"<<endl; //print out the numbers of events cnt.PrintMicroDST(); MSG("NuAnalysis",Msg::kInfo) <<" ** Finished FDTestAna method **"<<endl; }

void NuDSTAna::NewFieldAna (  std::string  sOutputFileName = ""  )

Definition at line 6276 of file NuDSTAna.cxx. References NuEvent::anaVersion, NuEvent::applyBeamWeight, NuReco::ApplyReweights(), NuEvent::beamWeight, NuEvent::beamWeightRunI, NuEvent::charge, NuLibrary::cnt, NuEvent::detector, NuEvent::detectorWeightNM, NuEvent::detectorWeightNMB, NuEvent::detectorWeightNMBRunI, NuEvent::detectorWeightNMRunI, DoIO(), NuCounter::evtCounter, NuHistos::FillMatrixMethodHistos(), NuInputEvents::GetEntriesNuEvent(), NuReco::GetEvtEnergy(), NuInputEvents::GetNextNuEvent(), NuLibrary::hist, NuEvent::iaction, NuInputEvents::InitialiseNuEventBranch(), NuLibrary::Instance(), NuEvent::inu, IsGoodStdCuts(), MakeFinalPlots(), MSG, NuCounter::nuNQCounter, NuCounter::nuPQCounter, plots(), NuBase::PrintLoopProgress(), NuCounter::PrintMicroDST(), NuEvent::qp, NuLibrary::reco, NuUtilities::RecoBins(), NuInputEvents::ResetNuEventLoopPositionToStart(), NuEvent::run, NuEvent::rw, SanityCheckedAnaVersion(), NuEvent::shwEnWeight, NuEvent::shwEnWeightRunI, NuEvent::trkEnCurv, NuEvent::trkEnWeight, NuEvent::trkEnWeightRunI, and NuUtilities::TrueBins(). { NuInputEvents& input=this->DoIO(0,"",sOutputFileName); //get an instance of the code library NuLibrary& lib = NuLibrary::Instance(); //get an object to fill plots const NuPlots* plots=0; //version to do reco/cuts with NuCuts::NuAnaVersion_t overrideAnaVersion = static_cast<NuCuts::NuAnaVersion_t>(NuCuts::kJJE2); //Binning scheme NuBinningScheme::NuBinningScheme_t binningScheme = static_cast<NuBinningScheme::NuBinningScheme_t>(3); const NuUtilities cuts; std::vector<Double_t> vReco = cuts.RecoBins(binningScheme); std::vector<Double_t> vTrue = cuts.TrueBins(binningScheme); TH1::AddDirectory(true); TH1D * hqp_numu = new TH1D("hqp_numu","qp for NuMus", 200, -5, 5); TH1D * hqp_nubar = new TH1D("hqp_nubar","qp for NuBars", 200, -5, 5); TH1D * htrken_numu = new TH1D("htrken_numu","Track Energy for NuMus", 200, 0, 20); TH1D * htrken_nubar = new TH1D("htrken_nubar","Track Energy for NuBars", 200, 0, 20); input.InitialiseNuEventBranch(); input.ResetNuEventLoopPositionToStart(); cout<<endl <<"************************************************"<<endl <<"*** Starting main loop over snarls ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuEvent();++i) { //for (Int_t i=0;i<0;++i) { lib.cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuEvent(),1); NuEvent &nu=const_cast<NuEvent&>(input.GetNextNuEvent(Msg::kDebug)); // Select only the right runs if (nu.detector == Detector::kFar && nu.run > 21037019) continue; if (nu.detector == Detector::kNear && nu.run > 13037009) continue; //OVERRIDE //Selection nu.anaVersion=this->SanityCheckedAnaVersion (nu.anaVersion,overrideAnaVersion); //Reweighting nu.applyBeamWeight = true; nu.beamWeight = nu.beamWeightRunI; nu.trkEnWeight = nu.trkEnWeightRunI; nu.shwEnWeight = nu.shwEnWeightRunI; nu.detectorWeightNMB = nu.detectorWeightNMBRunI; nu.detectorWeightNM = nu.detectorWeightNMRunI; //RE-RECONSTRUCT the neutrino energy lib.reco.GetEvtEnergy(nu, false); lib.reco.ApplyReweights(nu); // CC-only if (nu.iaction==1) { if (nu.inu == -14) { hqp_nubar->Fill(nu.qp, nu.rw); htrken_nubar->Fill(nu.trkEnCurv, nu.rw); } else if (nu.inu == 14) { hqp_numu->Fill(nu.qp, nu.rw); htrken_numu->Fill(nu.trkEnCurv, nu.rw); } } if (!this->IsGoodStdCuts(plots,nu)) continue; if (nu.charge==-1) lib.cnt.nuNQCounter++; else if (nu.charge==+1) lib.cnt.nuPQCounter++; else cout<<"ahhh, bad charge (10)"<<endl; //make the final plots this->MakeFinalPlots(plots,nu); //fill matrix method histos lib.hist.FillMatrixMethodHistos(nu, binningScheme); } MSG("NuAnalysis",Msg::kInfo)<<"Finished main loop"<<endl; //print out the numbers of events lib.cnt.PrintMicroDST(); MSG("NuAnalysis",Msg::kInfo) <<" ** Finished NewFieldAna method **"<<endl; }

void NuDSTAna::NMBAna (   )

Definition at line 87 of file NuDSTAna.cxx. References NuEvent::anaVersion, NuEvent::beamWeight, CopyAcrossHistos(), NuEvent::detectorWeight, NuEvent::dirCosNu, NuEvent::energy, NuEvent::energyMC, NuEvent::energyRw, NuPlots::FillDPIdSigmaQPFailDpIDCutPlots(), NuPlots::FillDPIdSigmaQPFailProbCutPlots(), NuPlots::FillDPIdSigmaQPFailSigQPCutPlots(), NuPlots::FillDPIdSigmaQPPassDpIDCutPlots(), NuPlots::FillDPIdSigmaQPPassSigQPCutPlots(), NuPlots::FillEnergyBinHistos(), NuEvent::generatorWeight, NuInputEvents::GetEntriesNuEvent(), NuInputEvents::GetFirstRunNumberNuEvent(), NuBase::GetInputFileName(), NuInputEvents::GetNextNuEvent(), NuEvent::iaction, NuEvent::index, NuInputEvents::InitialiseChains(), NuInputEvents::InitialiseNuEventBranch(), NuInputEvents::InputFileName(), NuCuts::IsGoodAbID(), NuCuts::IsGoodFitChi2PerNdof(), NuCuts::IsGoodFitProb(), NuCuts::IsGoodSigmaQP_QP(), NuCuts::IsGoodTrackFitPass(), NuCuts::IsInCylindricalVolume(), NuCuts::IsInFidVolTrk(), MakeFinalPlots(), MakePostPreSelectionPlots(), MAXMSG, NuEvent::nshw, NuEvent::ntrk, NuBase::OpenFile(), NuInputEvents::OpenInputFile(), NuGeneral::OscWeight(), plots(), NuEvent::primshw, NuEvent::primtrk, NuBase::PrintLoopProgress(), NuEvent::q2, NuEvent::qp, NuInputEvents::ResetNuEventLoopPositionToStart(), NuEvent::rw, SanityCheckedAnaVersion(), NuEvent::shwEn, NuEvent::shwEnCor1, NuEvent::shwEnCor2, NuEvent::shwEnCor3, NuEvent::shwEnCor4, NuEvent::shwEnCor5, NuEvent::shwEnRw, NuEvent::shwExists, NuEvent::shwExists1, NuEvent::shwExists2, NuEvent::shwExists3, NuEvent::trkEn, NuEvent::trkEnCorCurv1, NuEvent::trkEnCorCurv2, NuEvent::trkEnCorCurv3, NuEvent::trkEnCorRange1, NuEvent::trkEnCorRange2, NuEvent::trkEnCorRange3, NuEvent::trkEnRw, NuEvent::trkExists, NuEvent::trkExists1, NuEvent::trkExists2, NuEvent::trkExists3, NuEvent::trkfitpass, NuEvent::trkMomentumRange, NuEvent::usedCurv, NuEvent::w2, NuEvent::x, NuEvent::xTrkVtx, NuEvent::y, NuEvent::yTrkVtx, and NuEvent::zTrkVtx. { //open the input file with the tree in it string inputFileName=this->GetInputFileName(); NuInputEvents* fpInput=new NuInputEvents(); NuInputEvents& input=*fpInput; input.InputFileName(inputFileName); input.InitialiseChains(); input.InitialiseNuEventBranch(); TDirectory* dirInput=input.OpenInputFile(); Int_t firstRunNumber=input.GetFirstRunNumberNuEvent(); //open the output file for histos etc string sFilePrefix="NMBSumAna"; fOutFile=this->OpenFile(firstRunNumber,sFilePrefix.c_str()); TDirectory* dirOutput=gDirectory; cout<<"After opening output file:"<<endl; dirOutput->Print(); //copy across histos such hDetector, hSimFlag, and POT ones this->CopyAcrossHistos(dirInput,dirOutput); cout<<"Before creating histos output file:"<<endl; gDirectory->Print(); static NuGeneral general; static NuPlots* plots; static NuCuts cuts; //version to do reco/cuts with NuCuts::NuAnaVersion_t overrideAnaVersion=NuCuts::kNMB0325Bravo; //draw detailed distance to edge plot //static NuReco reco; //reco.TestGetSmallestDeepDistToEdge(); input.ResetNuEventLoopPositionToStart(); for (Int_t i=0;i<input.GetEntriesNuEvent();++i) { this->PrintLoopProgress(i,input.GetEntriesNuEvent(),1); NuEvent& nu=const_cast<NuEvent&>(input.GetNextNuEvent(Msg::kDebug)); //set the analysis version (could be kFullDST) nu.anaVersion=this->SanityCheckedAnaVersion (nu.anaVersion,overrideAnaVersion); //OVERRIDE nu.rw=nu.beamWeight*nu.detectorWeight*nu.generatorWeight; nu.trkEn=nu.trkEnRw; nu.shwEn=nu.shwEnRw; nu.energy=nu.energyRw; //const Float_t beamzerox=1.4885*(Munits::m); const Float_t beamzerox=1.4828*(Munits::m);//new for 2.5 analysis //const Float_t beamzerox=1.2*(Munits::m); //const Float_t beamzeroy=0.1397*(Munits::m); const Float_t beamzeroy=0.2384*(Munits::m);//new for 2.5 analysis //const Float_t beamzeroy=0.0*(Munits::m); const Float_t minZ=1.0*(Munits::m); const Float_t maxZ=4.0*(Munits::m); const Float_t maxR=0.5*(Munits::m); //additional cut on x position to remove coil hole //if (nu.xTrkVtx<0.7) continue; Bool_t passFid=cuts.IsInCylindricalVolume(nu.xTrkVtx,nu.yTrkVtx, nu.zTrkVtx, beamzerox,beamzeroy, minZ,maxZ,maxR); if (!passFid) continue; //if (nu.containmentFlagPitt>=3) continue;//got to downstream //if (nu.containmentFlagPitt<=2) continue;//only got to upstream //override the anaVersion //nu.anaVersion=NuCuts::kNMB0325Bravo; //check if the trk is in the fiducial volume if (!cuts.IsInFidVolTrk(nu)) continue; //require a good trk fit if (!cuts.IsGoodTrackFitPass(nu)) continue; //make the post-preselection plots this->MakePostPreSelectionPlots(plots,nu); //cut on the PID //if (!cuts.IsGoodDpID(nu)) { if (!cuts.IsGoodAbID(nu)) { plots->FillDPIdSigmaQPFailDpIDCutPlots(nu); continue; } plots->FillDPIdSigmaQPPassDpIDCutPlots(nu); plots->FillEnergyBinHistos(nu);//just PID cut //cut on the fractional track momentum and sign error if (!cuts.IsGoodSigmaQP_QP(nu)) { plots->FillDPIdSigmaQPFailSigQPCutPlots(nu); continue; } plots->FillDPIdSigmaQPPassSigQPCutPlots(nu); //cut on the chi2 if (!cuts.IsGoodFitChi2PerNdof(nu)) continue; //was here //plots->FillEnergyBinHistos(nu); //cut on the track fit probability if (!cuts.IsGoodFitProb(nu)) { plots->FillDPIdSigmaQPFailProbCutPlots(nu); continue; } if (nu.trkEn<0.5) { Float_t momCurv=-1; if (nu.qp!=0) momCurv=1./nu.qp; MAXMSG("NuReco",Msg::kInfo,10) <<endl <<"DST:" <<" nshw="<<nu.nshw <<", ntrk="<<nu.ntrk <<", primshw="<<nu.primshw <<", primtrk="<<nu.primtrk <<", shwExists="<<nu.shwExists<<"," <<", trkExists="<<nu.trkExists<<"," <<endl <<"shwExists1,2,3="<<nu.shwExists1<<"," <<nu.shwExists2<<","<<nu.shwExists3 <<", trkExists1,2,3="<<nu.trkExists1<<"," <<nu.trkExists2<<","<<nu.trkExists3<<endl <<"E="<<nu.energy<<", trkEn="<<nu.trkEn<<", shwEn="<<nu.shwEn <<endl <<"trkMomentumRange="<<nu.trkMomentumRange <<", momCurv="<<momCurv <<", usedCurv="<<nu.usedCurv<<", fitpass="<<nu.trkfitpass <<endl <<"dircosnu="<<nu.dirCosNu <<", y="<<nu.y<<", q2="<<nu.q2 <<", w2="<<nu.w2<<", x="<<nu.x <<endl <<"shwEn1="<<nu.shwEnCor1 <<", shw2="<<nu.shwEnCor2 <<", shw3="<<nu.shwEnCor3 <<", shw4="<<nu.shwEnCor4 <<", shw5="<<nu.shwEnCor5 //<<", shw6="<<nu.shwEnCor6 //<<", shw7="<<nu.shwEnCor7 <<endl <<"trkCv1="<<nu.trkEnCorCurv1 <<", trkCv2="<<nu.trkEnCorCurv2 <<", trkCv3="<<nu.trkEnCorCurv3 <<endl <<"trkRg1="<<nu.trkEnCorRange1 <<", trkRg2="<<nu.trkEnCorRange2 <<", trkRg3="<<nu.trkEnCorRange3 <<endl; } //extra cuts to test //if (nu.dpID<+0.1) continue; //if (nu.dpID<+0.4) continue; //if (nu.dpID<+0.4 && nu.charge>0) continue; //if (nu.prob<0.1) continue; //if (nu.sigqp_qp>0.3) continue; //Bool_t weightForOsc=true; Bool_t weightForOsc=false; if (weightForOsc){ //get the weight for the event Double_t weight=nu.rw; //apply the oscillation weight to CC events if (nu.iaction==1) { Float_t dm2=2.7e-3; Double_t oscWeight=general.OscWeight(dm2,1, nu.energyMC); weight*=oscWeight; } nu.rw=weight; } //if (nu.containedTrk && nu.rTrkEnd<0.3) { //MAXMSG("NuDSTAna",Msg::kInfo,200) //<<"nu.rTrkEnd="<<nu.rTrkEnd<<endl; //} //if (nu.rTrkEnd>0.3) continue; //if (nu.xTrkEnd<-0.2 && nu.planeTrkEnd<=120 && nu.containmentFlag==1) { //MAXMSG("NuDSTAna",Msg::kInfo,200) //<<"xTrkEnd="<<nu.xTrkEnd //<<", y="<<nu.yTrkEnd //<<", r="<<nu.rTrkEnd //<<", plTrkEnd"<<nu.planeTrkEnd //<<", con="<<nu.containedTrk //<<", flag="<<nu.containmentFlag //<<endl; //} //make the final plots this->MakeFinalPlots(plots,nu); MAXMSG("NuDSTAna",Msg::kInfo,5) <<"NMBSummaryTreeAna: NuEvent: index="<<nu.index <<", energy="<<nu.energy<<", energyMC="<<nu.energyMC<<endl; }//end of loop over summary tree }

void NuDSTAna::Oscillate (  NuMCEvent &  nu, const NuXMLConfig *  xmlConfig )  const [protected]

Definition at line 7669 of file NuDSTAna.cxx. References NuUtilities::DecayWeightCC(), NuUtilities::DecayWeightNC(), NuUtilities::DecoherenceWeight(), NuMCEvent::detector, NuXMLConfig::DM2Bar(), NuXMLConfig::DM2Nu(), NuMCEvent::iaction, NuMCEvent::inu, NuMCEvent::inunoosc, MAXMSG, NuMCEvent::neuEnMC, NuXMLConfig::OscillationModel(), OscillationWeight(), NuMCEvent::rw, NuMCEvent::simFlag, NuXMLConfig::SN2Bar(), and NuXMLConfig::SN2Nu(). { if (!xmlConfig){return;} if (SimFlag::kData == mc.simFlag){ MAXMSG("NuDSTAna",Msg::kInfo,1) << "Not applying fake oscillations to data" << endl; return; } if (Detector::kFar != mc.detector){ MAXMSG("NuDSTAna",Msg::kInfo,1) << "Not applying fake oscillations to ND MC" << endl; return; } if (xmlConfig->DM2Nu() < 0.0 || xmlConfig->SN2Nu() < 0.0 || xmlConfig->DM2Bar() < 0.0 || xmlConfig->SN2Bar() < 0.0){ MAXMSG("NuDSTAna",Msg::kInfo,1) << "Not applying fake oscillations due to xml configuration" << endl; return; } if (1 != mc.iaction && (16 == mc.inu || -16 == mc.inu)){ mc.rw=0; MAXMSG("NuDSTAna",Msg::kInfo,1) <<"Removing MC NC from Tau file"<<endl; return; } if(xmlConfig->OscillationModel() == 1){ switch(mc.iaction){ case 0: mc.rw *= NuUtilities::DecayWeightNC(mc.neuEnMC, xmlConfig->DM2Nu(), xmlConfig->SN2Nu()); return; case 1: mc.rw *= NuUtilities::DecayWeightCC(mc.neuEnMC, xmlConfig->DM2Nu(), xmlConfig->SN2Nu()); return; default: assert(0 && "Unknown iaction"); } } if(xmlConfig->OscillationModel() == 2){ mc.rw *= NuUtilities::DecoherenceWeight(mc.neuEnMC, xmlConfig->DM2Nu(), xmlConfig->SN2Nu()); return; } // It's not decay or decoherence, so it must be oscillations assert(xmlConfig->OscillationModel() == 0); if (1 != mc.iaction){ MAXMSG("NuDSTAna",Msg::kInfo,1) << "NCs don't oscillate" << endl; return; } if (!(14 == mc.inu || -14 == mc.inu) || 16 == mc.inu || -16 == mc.inu){ MAXMSG("NuDSTAna",Msg::kInfo,1) << "Not oscillating non-muon(tau) (anti)neutino" << endl; return; } if( (mc.inunoosc == 12 ||mc.inunoosc==-12) && (mc.inu==16 || mc.inu==-16)){ mc.rw=0; MAXMSG("NuDSTAna",Msg::kInfo,1) <<"beam nue already don't oscillate to tau" <<endl; return; } mc.rw *= this->OscillationWeight(mc.neuEnMC,mc.inu,xmlConfig); return; }

void NuDSTAna::Oscillate (  NuEvent &  nu, const NuXMLConfig *  xmlConfig )  const [protected]

Definition at line 7563 of file NuDSTAna.cxx. References NuUtilities::DecayWeightCC(), NuUtilities::DecayWeightNC(), NuUtilities::DecoherenceWeight(), NuEvent::detector, NuXMLConfig::DM2Bar(), NuXMLConfig::DM2Nu(), NuEvent::iaction, NuEvent::inu, NuEvent::inunoosc, MAXMSG, NuEvent::neuEnMC, NuXMLConfig::OscillationModel(), OscillationWeight(), NuEvent::rw, NuEvent::simFlag, NuXMLConfig::SN2Bar(), and NuXMLConfig::SN2Nu(). Referenced by MakeMicroDST(), MakeMicroDstFakeData(), MMRereco(), and MMTransition(). { //check that the xmlConfig object exists if (!xmlConfig) return; //don't oscillate real data if (SimFlag::kData == nu.simFlag){ MAXMSG("NuDSTAna",Msg::kInfo,1) << "Not applying fake oscillations to data" << endl; return; } //don't oscillate the ND data if (Detector::kFar != nu.detector){ MAXMSG("NuDSTAna",Msg::kInfo,1) << "Not applying fake oscillations to ND MC" << endl; return; } //check for !CC (i.e. NC) if (1 != nu.iaction && (16 == nu.inu || -16 == nu.inu)){ nu.rw=0; MAXMSG("NuDSTAna",Msg::kInfo,1) <<"Removing NC events from tau file (nu.rw set to zero)"<<endl; return; } if(xmlConfig->OscillationModel() == 1){ switch(nu.iaction){ case 0: nu.rw *= NuUtilities::DecayWeightNC(nu.neuEnMC, xmlConfig->DM2Nu(), xmlConfig->SN2Nu()); return; case 1: nu.rw *= NuUtilities::DecayWeightCC(nu.neuEnMC, xmlConfig->DM2Nu(), xmlConfig->SN2Nu()); return; default: assert(0 && "Unknown iaction"); } } if(xmlConfig->OscillationModel() == 2){ nu.rw *= NuUtilities::DecoherenceWeight(nu.neuEnMC, xmlConfig->DM2Nu(), xmlConfig->SN2Nu()); return; } // It's not decay or decoherence, so it must be oscillations assert(xmlConfig->OscillationModel() == 0); if (1 != nu.iaction){ MAXMSG("NuDSTAna",Msg::kInfo,1) << "NCs don't oscillate" << endl; return; } //select everything that is not NuMu(bar) or NuTau(bar) //i.e. true if nue(bar) if (!(14 == nu.inu || -14 == nu.inu || 16 == nu.inu || -16 == nu.inu)){ MAXMSG("NuDSTAna",Msg::kInfo,1) <<"Not oscillating nue events (non-muon/tau (anti)neutinos)"<<endl; return; } //select events that started as nues and were turned in to nutaus //we can ignore these if((nu.inunoosc == 12 || nu.inunoosc==-12) && (nu.inu==16 || nu.inu==-16)){ nu.rw=0; MAXMSG("NuDSTAna",Msg::kInfo,1) <<"Removing beam nue events from tau file (nu.rw set to zero)" <<endl; return; } //Do this last, so that taus and nue's are still properly //reweighted, even in the no-oscillation case //For example, in the no-osc case the nutaus are given a weight of 0 //so have to explictly just not touch them if (xmlConfig->DM2Nu() < 0.0 || xmlConfig->SN2Nu() < 0.0 || xmlConfig->DM2Bar() < 0.0 || xmlConfig->SN2Bar() < 0.0){ MAXMSG("NuDSTAna",Msg::kInfo,1) <<"Not applying fake oscillations due to xml configuration"<<endl; return; } //include the oscillation weight in the general nu.rw variable nu.rw *= this->OscillationWeight(nu.neuEnMC,nu.inu,xmlConfig); MAXMSG("NuDSTAna",Msg::kInfo,10) <<"Oscillating with dm2="<<xmlConfig->DM2Nu() <<"; weight="<<this->OscillationWeight(nu.neuEnMC,nu.inu,xmlConfig) <<"; energy="<<nu.neuEnMC <<endl; return; }

void NuDSTAna::OscillateOrTransition (  NuEvent &  nu, const NuXMLConfig *  xmlConfig, NuTransition *  transition )  const [protected]

const Float_t NuDSTAna::OscillationWeight (  const Float_t  energy, const Int_t  inu, const NuXMLConfig *  xmlConfig )  const [protected]

Definition at line 7754 of file NuDSTAna.cxx. References NuUtilities::OscillationWeight(). Referenced by Oscillate(). { if (14==inu){ return NuUtilities::OscillationWeight(energy, xmlConfig->DM2Nu(), xmlConfig->SN2Nu()); } else if (-14==inu){ return NuUtilities::OscillationWeight(energy, xmlConfig->DM2Bar(), xmlConfig->SN2Bar()); } if (16==inu){ return 1-NuUtilities::OscillationWeight(energy, xmlConfig->DM2Nu(), xmlConfig->SN2Nu()); } else if (-16==inu){ return 1-NuUtilities::OscillationWeight(energy, xmlConfig->DM2Bar(), xmlConfig->SN2Bar()); } else return 1; // Doesn't oscillate }

void NuDSTAna::OverwriteCoilDataInNtuple (  NuEvent &  nu  )  [protected]

Definition at line 4675 of file NuDSTAna.cxx. References NuEvent::coilIsOk, and MAXMSG. { MAXMSG("NuDSTAna",Msg::kWarning,100) <<"Overwriting coil data in NuEvent (ntuple)"<<endl; //just assume that it's true nu.coilIsOk=true; }

void NuDSTAna::OverwriteSntpBeamDataInNtuple (  NuEvent &  nu  )  [protected]

Definition at line 4646 of file NuDSTAna.cxx. References NuEvent::goodBeam, NuEvent::goodBeamSntp, MAXMSG, NuEvent::pot, NuEvent::potDB, NuEvent::potSinceLastEvt, NuEvent::potSinceLastEvtBad, NuEvent::potSinceLastEvtBadDB, NuEvent::potSinceLastEvtDB, NuEvent::potSinceLastEvtGood, and NuEvent::potSinceLastEvtGoodDB. { //lib.ext.ExtractBeamInfoDB(nu); //static Int_t lastSnarl=-1; //static Float_t potCounter=0; //Bool_t goodBeam=lib.cuts.IsGoodBeam(nu); //if (nu.snarl!=lastSnarl && goodBeam) { //potCounter+=nu.potSinceLastEvtDB; //} //lastSnarl=nu.snarl; //MAXMSG("NuDSTAna",Msg::kInfo,100) //<<"Pot from DB="<<nu.potDB<<", snarl="<<nu.snarl //<<", running total="<<potCounter<<endl; MAXMSG("NuDSTAna",Msg::kWarning,100) <<"Overwriting beam data in NuEvent (ntuple)"<<endl; //use the values from the beam nu.goodBeamSntp=nu.goodBeam; nu.pot=nu.potDB; nu.potSinceLastEvt=nu.potSinceLastEvtDB; nu.potSinceLastEvtGood=nu.potSinceLastEvtGoodDB; nu.potSinceLastEvtBad=nu.potSinceLastEvtBadDB; }

void NuDSTAna::QPStudy (   )

Definition at line 6954 of file NuDSTAna.cxx. References NuEvent::anaVersion, NuEvent::applyBeamWeight, NuEvent::applyEnergyShifts, NuReco::ApplyReweights(), NuEvent::charge, NuLibrary::cnt, NuEvent::containmentFlag, DoIO(), NuEvent::energy, NuCounter::evtCounter, NuZBeamReweight::ExtractZBeamReweight(), NuPlots::FillSelPlots(), NuPlots::FillSpectra(), NuUtilities::FixDogwoodQP(), NuInputEvents::GetEntriesNuEvent(), NuReco::GetEvtEnergy(), NuInputEvents::GetNextNuEvent(), NuLibrary::Instance(), IsGoodPreSelectionCuts(), NuCut::MakeCuts(), MSG, NuCounter::nuNQCounter, NuCounter::nuPQCounter, NuCut::Passed(), NuCut::PassedExcept(), plots(), NuBase::PrintLoopProgress(), NuCounter::PrintMicroDST(), NuEvent::qp, NuEvent::qp_rangebiased, NuLibrary::reco, NuInputEvents::ResetNuEventLoopPositionToStart(), NuEvent::runPeriod, NuEvent::rw, NuEvent::simFlag, and NuLibrary::zBeamReweight. { cout<<endl <<"************************************************"<<endl <<"*** Starting QPStudy() ***"<<endl <<"************************************************"<<endl << endl;; NuInputEvents& input=this->DoIO(0,"",""); //get an instance of the code library NuLibrary& lib=NuLibrary::Instance(); //get an object to fill plots const NuPlots* plots=new NuPlots(); NuCutImps::Bravo bravoCut(plots); input.ResetNuEventLoopPositionToStart(); TString post[] = {"_nom_skzp", "_nom_norw", "_qpfix_skzp", "_qpfix_norw"}; TString cont; cout<<endl <<"************************************************"<<endl <<"*** Starting main loop over snarls ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuEvent();++i) { lib.cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuEvent(),1); if (i < 200) cout << "Debug: i=" << i << "/" << input.GetEntriesNuEvent() << endl;; NuEvent &nu=const_cast<NuEvent&>(input.GetNextNuEvent(Msg::kInfo)); // Only care about preselected nubars here nu.anaVersion = NuCuts::kNMB0325Bravo; if (!this->IsGoodPreSelectionCuts(plots,nu)) continue; //OVERRIDE //RE-RECONSTRUCT the neutrino energy // Redo the beam weights if (nu.simFlag==SimFlag::kMC) { nu.runPeriod = 0; lib.zBeamReweight.ExtractZBeamReweight(nu); //Reweighting nu.applyBeamWeight = true; nu.applyEnergyShifts = false; nu.rw = 1; lib.reco.ApplyReweights(nu); } double rwprev = nu.rw; if (i < 200) { cout << "nu.charge = " << nu.charge << endl << "nu.qp_rangebiased = " << nu.qp_rangebiased << endl << "nu.qp = " << nu.qp << endl << "nu.energy = " << nu.energy << endl; } // First do nominal qp, nominal SKZP lib.reco.GetEvtEnergy(nu, false); if (nu.containmentFlag==1 || nu.containmentFlag==3) cont = "Cont"; else cont = "Exit"; for (int i = 0; i < 4; i++) { if (i % 2 == 0) nu.rw = rwprev; else nu.rw = 1; if (i == 2) NuUtilities::FixDogwoodQP(nu); bravoCut.MakeCuts(nu); plots->FillSpectra(nu, "Presel"+post[i]); plots->FillSpectra(nu, cont+"Presel"+post[i]); plots->FillSelPlots(nu, "RoID", "Presel"+post[i]); plots->FillSelPlots(nu, "RoID", cont+"Presel"+post[i]); plots->FillSelPlots(nu, "SigmaQP_QP", "Presel"+post[i]); plots->FillSelPlots(nu, "SigmaQP_QP", cont+"Presel"+post[i]); plots->FillSelPlots(nu, "DpID", "Presel"+post[i]); plots->FillSelPlots(nu, "DpID", cont+"Presel"+post[i]); plots->FillSelPlots(nu, "RelativeAngle", "Presel"+post[i]); plots->FillSelPlots(nu, "RelativeAngle", cont+"Presel"+post[i]); plots->FillSelPlots(nu, "TrackLength", "Presel"+post[i]); plots->FillSelPlots(nu, "TrackLength", cont+"Presel"+post[i]); if (nu.charge == 1) { if (bravoCut.PassedExcept("SigmaQP_QP")) { plots->FillSelPlots(nu, "SigmaQP_QP", "NotSigqp"+post[i]); plots->FillSelPlots(nu, "SigmaQP_QP", cont+"NotSigqp"+post[i]); plots->FillSelPlots(nu, "TrackLength", "NotSigqp"+post[i]); plots->FillSelPlots(nu, "TrackLength", cont+"NotSigqp"+post[i]); plots->FillSpectra(nu, "NotSigqp"+post[i]); plots->FillSpectra(nu, cont+"NotSigqp"+post[i]); } if (bravoCut.PassedExcept("DpID")) { plots->FillSelPlots(nu, "DpID", "NotDpID"+post[i]); plots->FillSelPlots(nu, "DpID", cont+"NotDpID"+post[i]); plots->FillSelPlots(nu, "TrackLength", "NotDpID"+post[i]); plots->FillSelPlots(nu, "TrackLength", cont+"NotDpID"+post[i]); plots->FillSpectra(nu, "NotDpID"+post[i]); plots->FillSpectra(nu, cont+"NotDpID"+post[i]); } if (bravoCut.PassedExcept("RelativeAngle")) { plots->FillSelPlots(nu, "RelativeAngle", "NotRelativeAngle"+post[i]); plots->FillSelPlots(nu, "RelativeAngle", cont+"NotRelativeAngle"+post[i]); plots->FillSelPlots(nu, "TrackLength", "NotRelativeAngle"+post[i]); plots->FillSelPlots(nu, "TrackLength", cont+"NotRelativeAngle"+post[i]); plots->FillSpectra(nu, "NotRelativeAngle"+post[i]); plots->FillSpectra(nu, cont+"NotRelativeAngle"+post[i]); } } if (bravoCut.Passed()) { plots->FillSelPlots(nu, "TrackLength", "Selected"+post[i]); plots->FillSelPlots(nu, "TrackLength", cont+"Selected"+post[i]); plots->FillSpectra(nu, "Selected"+post[i]); plots->FillSpectra(nu, cont+"Selected"+post[i]); } } if (nu.charge==-1) lib.cnt.nuNQCounter++; else if (nu.charge==+1) lib.cnt.nuPQCounter++; else cout<<"ahhh, bad charge (11)"<<endl; }//end of loop over summary tree MSG("NuAnalysis",Msg::kInfo)<<"Finished main loop"<<endl; //print out the numbers of events lib.cnt.PrintMicroDST(); cout<<endl <<"************************************************"<<endl <<"*** Ending QPStudy() ***"<<endl <<"************************************************"<<endl << endl;; }

void NuDSTAna::RHCTest (   )

Definition at line 6524 of file NuDSTAna.cxx. References NuEvent::anaVersion, NuEvent::applyBeamWeight, NuEvent::applyEnergyShifts, NuReco::ApplyReweights(), NuEvent::beamType, NuEvent::charge, NuLibrary::cnt, NuEvent::cutOnDataQuality, DoIO(), NuEvent::energy, NuEvent::energyMC, NuCounter::evtCounter, NuZBeamReweight::ExtractZBeamReweight(), NuInputEvents::GetEntriesNuEvent(), NuReco::GetEvtEnergy(), NuInputEvents::GetNextNuEvent(), NuZBeamReweight::GetWeightHelium(), NuEvent::hornIsReverse, NuEvent::iaction, NuEvent::index, NuLibrary::Instance(), NuEvent::inu, IsGoodStdCuts(), MAXMSG, MSG, NuCounter::nuNQCounter, NuCounter::nuPQCounter, NuBase::PrintLoopProgress(), NuCounter::PrintMicroDST(), NuLibrary::reco, NuInputEvents::ResetNuEventLoopPositionToStart(), NuEvent::runPeriod, NuEvent::rw, SanityCheckedAnaVersion(), NuEvent::shwEn, NuEvent::simFlag, NuEvent::tpx, NuEvent::tpy, NuEvent::tpz, NuEvent::trkEn, NuEvent::useDBForDataQuality, and NuLibrary::zBeamReweight. { NuInputEvents& input=this->DoIO(0,"",""); //get an instance of the code library NuLibrary& lib=NuLibrary::Instance(); //get an object to fill plots //const NuPlots* plots=0; //version to do reco/cuts with NuCuts::NuAnaVersion_t overrideAnaVersion = NuCuts::kRHC; const NuUtilities cuts; TH1D *hRecoEnergy_PQ = new TH1D("hRecoEnergy_PQ","Reconstructed RHC Spectrum (+ve charge)",200,0,50); TH1D *hRecoEnergy_NQ = new TH1D("hRecoEnergy_NQ","Reconstructed RHC Spectrum (-ve charge)",200,0,50); TH1D *hRecoEnergy_rw_PQ = new TH1D("hRecoEnergy_rw_PQ","SKZP Reconstructed RHC Spectrum (+ve charge)",200,0,50); TH1D *hRecoEnergy_rw_NQ = new TH1D("hRecoEnergy_rw_NQ","SKZP Reconstructed RHC Spectrum (-ve charge)",200,0,50); TH1D *hRecoEnergy_he_PQ = new TH1D("hRecoEnergy_he_PQ","He Reconstructed RHC Spectrum (+ve charge)",200,0,50); TH1D *hRecoEnergy_he_NQ = new TH1D("hRecoEnergy_he_NQ","He Reconstructed RHC Spectrum (-ve charge)",200,0,50); TH1D *hShowerEnergy_PQ = new TH1D("hShowerEnergy_PQ","Shower RHC Spectrum (+ve charge)",200,0,50); TH1D *hShowerEnergy_NQ = new TH1D("hShowerEnergy_NQ","Shower RHC Spectrum (-ve charge)",200,0,50); TH1D *hShowerEnergy_rw_PQ = new TH1D("hShowerEnergy_rw_PQ","SKZP Shower RHC Spectrum (+ve charge)",200,0,50); TH1D *hShowerEnergy_rw_NQ = new TH1D("hShowerEnergy_rw_NQ","SKZP Shower RHC Spectrum (-ve charge)",200,0,50); TH1D *hShowerEnergy_he_PQ = new TH1D("hShowerEnergy_he_PQ","He Shower RHC Spectrum (+ve charge)",200,0,50); TH1D *hShowerEnergy_he_NQ = new TH1D("hShowerEnergy_he_NQ","He Shower RHC Spectrum (-ve charge)",200,0,50); TH1D *hTrackEnergy_PQ = new TH1D("hTrackEnergy_PQ","Track RHC Spectrum (+ve charge)",200,0,50); TH1D *hTrackEnergy_NQ = new TH1D("hTrackEnergy_NQ","Track RHC Spectrum (-ve charge)",200,0,50); TH1D *hTrackEnergy_rw_PQ = new TH1D("hTrackEnergy_rw_PQ","SKZP Track RHC Spectrum (+ve charge)",200,0,50); TH1D *hTrackEnergy_rw_NQ = new TH1D("hTrackEnergy_rw_NQ","SKZP Track RHC Spectrum (-ve charge)",200,0,50); TH1D *hTrackEnergy_he_PQ = new TH1D("hTrackEnergy_he_PQ","He Track RHC Spectrum (+ve charge)",200,0,50); TH1D *hTrackEnergy_he_NQ = new TH1D("hTrackEnergy_he_NQ","He Track RHC Spectrum (-ve charge)",200,0,50); TH1D *hRecoEnergy_numu = new TH1D("hRecoEnergy_numu","Reconstructed RHC Spectrum (numu)",200,0,50); TH1D *hRecoEnergy_nubar = new TH1D("hRecoEnergy_nubar","Reconstructed RHC Spectrum (nubar)",200,0,50); TH1D *hRecoEnergy_rw_numu = new TH1D("hRecoEnergy_rw_numu","SKZP Reconstructed RHC Spectrum (numu)",200,0,50); TH1D *hRecoEnergy_rw_nubar = new TH1D("hRecoEnergy_rw_nubar","SKZP Reconstructed RHC Spectrum (nubar)",200,0,50); TH1D *hRecoEnergy_he_numu = new TH1D("hRecoEnergy_he_numu","He Reconstructed RHC Spectrum (numu)",200,0,50); TH1D *hRecoEnergy_he_nubar = new TH1D("hRecoEnergy_he_nubar","He Reconstructed RHC Spectrum (nubar)",200,0,50); TH1D *hShowerEnergy_numu = new TH1D("hShowerEnergy_numu","Shower RHC Spectrum (numu)",200,0,50); TH1D *hShowerEnergy_nubar = new TH1D("hShowerEnergy_nubar","Shower RHC Spectrum (nubar)",200,0,50); TH1D *hShowerEnergy_rw_numu = new TH1D("hShowerEnergy_rw_numu","SKZP Shower RHC Spectrum (numu)",200,0,50); TH1D *hShowerEnergy_rw_nubar = new TH1D("hShowerEnergy_rw_nubar","SKZP Shower RHC Spectrum (nubar)",200,0,50); TH1D *hShowerEnergy_he_numu = new TH1D("hShowerEnergy_he_numu","He Shower RHC Spectrum (numu)",200,0,50); TH1D *hShowerEnergy_he_nubar = new TH1D("hShowerEnergy_he_nubar","He Shower RHC Spectrum (nubar)",200,0,50); TH1D *hTrackEnergy_numu = new TH1D("hTrackEnergy_numu","Track RHC Spectrum (numu)",200,0,50); TH1D *hTrackEnergy_nubar = new TH1D("hTrackEnergy_nubar","Track RHC Spectrum (nubar)",200,0,50); TH1D *hTrackEnergy_rw_numu = new TH1D("hTrackEnergy_rw_numu","SKZP Track RHC Spectrum (numu)",200,0,50); TH1D *hTrackEnergy_rw_nubar = new TH1D("hTrackEnergy_rw_nubar","SKZP Track RHC Spectrum (nubar)",200,0,50); TH1D *hTrackEnergy_he_numu = new TH1D("hTrackEnergy_he_numu","He Track RHC Spectrum (numu)",200,0,50); TH1D *hTrackEnergy_he_nubar = new TH1D("hTrackEnergy_he_nubar","He Track RHC Spectrum (nubar)",200,0,50); TH1D *hRecoEnergy_rw_PQ_ws = new TH1D("hRecoEnergy_rw_PQ_ws","SKZP Reconstructed RHC Spectrum Wrong Sign (+ve charge)",200,0,50); TH1D *hRecoEnergy_rw_NQ_ws = new TH1D("hRecoEnergy_rw_NQ_ws","SKZP Reconstructed RHC Spectrum Wrong Sign (+ve charge)",200,0,50); TH1D *hRecoEnergy_rw_PQ_nc = new TH1D("hRecoEnergy_rw_PQ_nc","SKZP Reconstructed RHC Spectrum Neutral Current (+ve charge)",200,0,50); TH1D *hRecoEnergy_rw_NQ_nc = new TH1D("hRecoEnergy_rw_NQ_nc","SKZP Reconstructed RHC Spectrum Neutral Current (+ve charge)",200,0,50); TH1D *hShowerEnergy_rw_PQ_ws = new TH1D("hShowerEnergy_rw_PQ_ws","SKZP Shower RHC Spectrum Wrong Sign (+ve charge)",200,0,50); TH1D *hShowerEnergy_rw_NQ_ws = new TH1D("hShowerEnergy_rw_NQ_ws","SKZP Shower RHC Spectrum Wrong Sign (+ve charge)",200,0,50); TH1D *hShowerEnergy_rw_PQ_nc = new TH1D("hShowerEnergy_rw_PQ_nc","SKZP Shower RHC Spectrum Neutral Current (+ve charge)",200,0,50); TH1D *hShowerEnergy_rw_NQ_nc = new TH1D("hShowerEnergy_rw_NQ_nc","SKZP Shower RHC Spectrum Neutral Current (+ve charge)",200,0,50); TH1D *hTrackEnergy_rw_PQ_ws = new TH1D("hTrackEnergy_rw_PQ_ws","SKZP Track RHC Spectrum Wrong Sign (+ve charge)",200,0,50); TH1D *hTrackEnergy_rw_NQ_ws = new TH1D("hTrackEnergy_rw_NQ_ws","SKZP Track RHC Spectrum Wrong Sign (+ve charge)",200,0,50); TH1D *hTrackEnergy_rw_PQ_nc = new TH1D("hTrackEnergy_rw_PQ_nc","SKZP Track RHC Spectrum Neutral Current (+ve charge)",200,0,50); TH1D *hTrackEnergy_rw_NQ_nc = new TH1D("hTrackEnergy_rw_NQ_nc","SKZP Track RHC Spectrum Neutral Current (+ve charge)",200,0,50); int bins2d = 100; TH2D* ptpz_nubar = new TH2D("ptpz_PQ","pt vz. pz for nubar",bins2d,0,120,bins2d,0,1); TH2D* ptpz_numu = new TH2D("ptpz_NQ","pt vz. pz for numu",bins2d,0,120,bins2d,0,1); TProfile2D* skzp_nubar = new TProfile2D("skzp_PQ","SKZP weights for nubar",bins2d,0,120,bins2d,0,1); TProfile2D* skzp_numu = new TProfile2D("skzp_NQ","SKZP weights for numu",bins2d,0,120,bins2d,0,1); input.ResetNuEventLoopPositionToStart(); cout<<endl <<"************************************************"<<endl <<"*** Starting main loop over snarls ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuEvent();++i) { //for (Int_t i=0;i<0;++i) { lib.cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuEvent(),1); NuEvent &nu=const_cast<NuEvent&>(input.GetNextNuEvent(Msg::kDebug)); if (nu.simFlag == SimFlag::kMC) { // Force some parameters: nu.runPeriod = 4; nu.hornIsReverse = true; nu.beamType = BeamType::kL010z185i_rev; // Redo the beam weights lib.zBeamReweight.ExtractZBeamReweight(nu); //Reweighting nu.applyBeamWeight = true; nu.applyEnergyShifts = false; nu.rw = 1; lib.reco.ApplyReweights(nu); } nu.cutOnDataQuality = nu.useDBForDataQuality; //OVERRIDE //Selection nu.anaVersion=this->SanityCheckedAnaVersion (nu.anaVersion,overrideAnaVersion); //RE-RECONSTRUCT the neutrino energy lib.reco.GetEvtEnergy(nu, false); //make all the std cuts //if (!lib.cuts.IsGoodQP(nu)) continue; if (!this->IsGoodStdCuts(0,nu)) continue; //hRecoEnergy_unosc->Fill(nu.energy, nu.rw); //this->Oscillate(nu,xmlConfig); double recoE = nu.energy; double showerE = nu.shwEn; double trackE = nu.trkEn; double hew = lib.zBeamReweight.GetWeightHelium(nu); if (nu.charge == +1) { // Reco NuBar hRecoEnergy_PQ->Fill(recoE, 1); hRecoEnergy_rw_PQ->Fill(recoE, nu.rw); hRecoEnergy_he_PQ->Fill(recoE, nu.rw*hew); hShowerEnergy_PQ->Fill(showerE, 1); hShowerEnergy_rw_PQ->Fill(showerE, nu.rw); hShowerEnergy_he_PQ->Fill(showerE, nu.rw*hew); hTrackEnergy_PQ->Fill(trackE, 1); hTrackEnergy_rw_PQ->Fill(trackE, nu.rw); hTrackEnergy_he_PQ->Fill(trackE, nu.rw*hew); if (nu.simFlag == SimFlag::kMC) { if (nu.iaction != 1) { hRecoEnergy_rw_PQ_nc->Fill(recoE, nu.rw); hShowerEnergy_rw_PQ_nc->Fill(showerE, nu.rw); hTrackEnergy_rw_PQ_nc->Fill(trackE, nu.rw); } else if (nu.inu != -14) { hRecoEnergy_rw_PQ_ws->Fill(recoE, nu.rw); hShowerEnergy_rw_PQ_ws->Fill(showerE, nu.rw); hTrackEnergy_rw_PQ_ws->Fill(trackE, nu.rw); } } } else { // Reco NuMu hRecoEnergy_NQ->Fill(recoE, 1); hRecoEnergy_rw_NQ->Fill(recoE, nu.rw); hRecoEnergy_he_NQ->Fill(recoE, nu.rw*hew); hShowerEnergy_NQ->Fill(showerE, 1); hShowerEnergy_rw_NQ->Fill(showerE, nu.rw); hShowerEnergy_he_NQ->Fill(showerE, nu.rw*hew); hTrackEnergy_NQ->Fill(trackE, 1); hTrackEnergy_rw_NQ->Fill(trackE, nu.rw); hTrackEnergy_he_NQ->Fill(trackE, nu.rw*hew); if (nu.simFlag == SimFlag::kMC) { if (nu.iaction != 1) { hRecoEnergy_rw_NQ_nc->Fill(recoE, nu.rw); hShowerEnergy_rw_NQ_nc->Fill(showerE, nu.rw); hTrackEnergy_rw_NQ_nc->Fill(trackE, nu.rw); } else if (nu.inu != 14) { hRecoEnergy_rw_NQ_ws->Fill(recoE, nu.rw); hShowerEnergy_rw_NQ_ws->Fill(showerE, nu.rw); hTrackEnergy_rw_NQ_ws->Fill(trackE, nu.rw); } } } if (nu.simFlag == SimFlag::kMC) { if (nu.iaction == 1) { if (nu.inu == -14) { // True NuBar double tpt = sqrt(nu.tpx*nu.tpx+nu.tpy*nu.tpy); ptpz_nubar->Fill(nu.tpz, tpt); skzp_nubar->Fill(nu.tpz, tpt, nu.rw); hRecoEnergy_nubar->Fill(recoE, 1); hRecoEnergy_rw_nubar->Fill(recoE, nu.rw); hRecoEnergy_he_nubar->Fill(recoE, nu.rw*hew); hShowerEnergy_nubar->Fill(showerE, 1); hShowerEnergy_rw_nubar->Fill(showerE, nu.rw); hShowerEnergy_he_nubar->Fill(showerE, nu.rw*hew); hTrackEnergy_nubar->Fill(trackE, 1); hTrackEnergy_rw_nubar->Fill(trackE, nu.rw); hTrackEnergy_he_nubar->Fill(trackE, nu.rw*hew); } else if (nu.inu == 14){ // True NuMu double tpt = sqrt(nu.tpx*nu.tpx+nu.tpy*nu.tpy); ptpz_numu->Fill(nu.tpz, tpt); skzp_numu->Fill(nu.tpz, tpt, nu.rw); hRecoEnergy_numu->Fill(recoE, 1); hRecoEnergy_rw_numu->Fill(recoE, nu.rw); hRecoEnergy_he_numu->Fill(recoE, nu.rw*hew); hShowerEnergy_numu->Fill(showerE, 1); hShowerEnergy_rw_numu->Fill(showerE, nu.rw); hShowerEnergy_he_numu->Fill(showerE, nu.rw*hew); hTrackEnergy_numu->Fill(trackE, 1); hTrackEnergy_rw_numu->Fill(trackE, nu.rw); hTrackEnergy_he_numu->Fill(trackE, nu.rw*hew); } } } if (nu.charge==-1) lib.cnt.nuNQCounter++; else if (nu.charge==+1) lib.cnt.nuPQCounter++; else cout<<"ahhh, bad charge (11)"<<endl; MAXMSG("NuDSTAna",Msg::kInfo,5) <<"Passed: index="<<nu.index <<", energy="<<recoE<<", energyMC="<<nu.energyMC<<endl; }//end of loop over summary tree MSG("NuAnalysis",Msg::kInfo)<<"Finished main loop"<<endl; //print out the numbers of events lib.cnt.PrintMicroDST(); MSG("NuAnalysis",Msg::kInfo) <<" ** Finished RHCTest method **"<<endl; }

void NuDSTAna::SanityCheckAnaVersionSameAsPrevious (  Int_t  anaVersion  )  const [protected]

Definition at line 5131 of file NuDSTAna.cxx. References NuCuts::AsString(), NuLibrary::cuts, NuLibrary::Instance(), and MSG. Referenced by ConcatenateDSTs(). { //sanity check that the same analysis version is used in all //the files to be concatenated... could be nasty otherwise //Note: can't use SanityCheckedAnaVersion() due to kFull //get an instance of the code library const NuLibrary& lib=NuLibrary::Instance(); static const Int_t firstAnaVersion=anaVersion; if (anaVersion!=firstAnaVersion) { MSG("NuDSTAna",Msg::kError) <<"Different analysis version found, anaVersion=" <<lib.cuts.AsString(static_cast<NuCuts::NuAnaVersion_t> (anaVersion)) <<", first version=" <<lib.cuts.AsString(static_cast<NuCuts::NuAnaVersion_t> (firstAnaVersion)) <<endl<<"Aborting..."<<endl; assert(false); } }

Int_t NuDSTAna::SanityCheckedAnaVersion (  Int_t  anaVersion, Int_t  overrideAnaVersion )  const [protected]

Definition at line 5156 of file NuDSTAna.cxx. Referenced by BRevAna(), Contamination(), DPSystematic(), FDTestAna(), FluxComponents(), JeffsTestAna(), MakeFCTree(), MakeMicroDst2010(), MakeMicroDstFakeData(), MakeMicroDstForCSSSystematics(), MakeMicroDstHe(), MakeMicroDstJJEPresel(), MakeMicroDstWithStdCCRecoAndCuts(), MakeSelMicroDST(), MMRereco(), MMTransition(), NDOsc(), NDTestAna(), NewFieldAna(), NMBAna(), RHCTest(), StdCCAna(), StdNMBAna(), and VsTime(). { //get an instance of the code library //const NuLibrary& lib=NuLibrary::Instance(); //sanity check that the right DST was used if (!(anaVersion==overrideAnaVersion || anaVersion==NuCuts::kFullDST)) { //give up on this for now... trust the users... and pray //MAXMSG("NuDSTAna",Msg::kError,5) //<<"Note: the DSTs were reconstructed with a different" //<<" analysis version, anaVersion=" //<<lib.cuts.AsString(static_cast<NuCuts::NuAnaVersion_t> // (anaVersion))<<endl //<<"Only FullDSTs or micro DSTs with anaVersion=" // <<lib.cuts.AsString(static_cast<NuCuts::NuAnaVersion_t> // (overrideAnaVersion)) //<<" should be used here, aborting..."<<endl; //assert(false); } //return the analysis version (could be kFullDST) return overrideAnaVersion; }

void NuDSTAna::SelectorTable (   )

Definition at line 6783 of file NuDSTAna.cxx. References NuEvent::anaVersion, NuEvent::charge, NuLibrary::cnt, DoIO(), NuCounter::evtCounter, NuPlots::FillSelPlots(), NuPlots::FillSpectra(), NuUtilities::FixDogwoodQP(), NuInputEvents::GetEntriesNuEvent(), NuInputEvents::GetNextNuEvent(), NuLibrary::Instance(), IsGoodPreSelectionCuts(), NuCut::MakeCuts(), MSG, NuCounter::nuNQCounter, NuCounter::nuPQCounter, NuCut::Passed(), NuCut::PassedExcept(), plots(), NuBase::PrintLoopProgress(), NuCounter::PrintMicroDST(), and NuInputEvents::ResetNuEventLoopPositionToStart(). { NuInputEvents& input=this->DoIO(0,"",""); //get an instance of the code library NuLibrary& lib=NuLibrary::Instance(); //get an object to fill plots const NuPlots* plots=new NuPlots(); TString bravoCutNames[] = {"DpID","SigmaQP_QP","RelativeAngle"}; TString charlieCutNames[] = {"RoID","MajorityCurv","TrackLength"}; //TString catNames[] = {"Signal","NC","WrongSign"}; input.ResetNuEventLoopPositionToStart(); NuCutImps::Bravo bravoCut(plots); NuCutImps::BravoPrime bravoPrimeCut(plots); NuCutImps::Charlie charlieCut(plots); cout<<endl <<"************************************************"<<endl <<"*** Starting main loop over snarls ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuEvent();++i) { //for (Int_t i=0;i<0;++i) { lib.cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuEvent(),1); NuEvent &nu=const_cast<NuEvent&>(input.GetNextNuEvent(Msg::kDebug)); // Only care about preselected nubars here nu.anaVersion = NuCuts::kNMB0325Bravo; if (!this->IsGoodPreSelectionCuts(plots,nu)) continue; //OVERRIDE //RE-RECONSTRUCT the neutrino energy NuUtilities::FixDogwoodQP(nu); //lib.reco.GetEvtEnergy(nu); bravoCut.MakeCuts(nu); bravoPrimeCut.MakeCuts(nu); charlieCut.MakeCuts(nu); // Fill Preselection spectra plots->FillSpectra(nu, "Presel"); for (int i = 0; i < 3; i++) { // Fill Preselection Selector Plots plots->FillSelPlots(nu, bravoCutNames[i], "BravoPre"); plots->FillSelPlots(nu, bravoCutNames[i], "BravoPrimePre"); plots->FillSelPlots(nu, charlieCutNames[i], "CharliePre"); if (nu.charge == 1) { // Fill N-1 Selector Plots if (bravoCut.PassedExcept(bravoCutNames[i])) plots->FillSelPlots(nu, bravoCutNames[i], "BravoN_1"); if (bravoPrimeCut.PassedExcept(bravoCutNames[i])) plots->FillSelPlots(nu, bravoCutNames[i], "BravoPrimeN_1"); if (charlieCut.PassedExcept(charlieCutNames[i])) plots->FillSelPlots(nu, charlieCutNames[i], "CharlieN_1"); // Fill individual selector spectra if (bravoCut.Passed(bravoCutNames[i])) plots->FillSpectra(nu, "Bravo_"+bravoCutNames[i]); if (bravoPrimeCut.Passed(bravoCutNames[i])) plots->FillSpectra(nu, "BravoPrime_"+bravoCutNames[i]); if (charlieCut.Passed(charlieCutNames[i])) plots->FillSpectra(nu, "Charlie_"+charlieCutNames[i]); // Fill N-1 spectra if (bravoCut.PassedExcept(bravoCutNames[i])) plots->FillSpectra(nu, "BravoN_1_"+bravoCutNames[i]); if (bravoPrimeCut.PassedExcept(bravoCutNames[i])) plots->FillSpectra(nu, "BravoPrimeN_1_"+bravoCutNames[i]); if (charlieCut.PassedExcept(charlieCutNames[i])) plots->FillSpectra(nu, "CharlieN_1_"+charlieCutNames[i]); } } // Fill full selection spectra if (bravoCut.Passed()) plots->FillSpectra(nu, "Bravo"); if (bravoPrimeCut.Passed()) plots->FillSpectra(nu, "BravoPrime"); if (charlieCut.Passed()) plots->FillSpectra(nu, "Charlie"); // // // // nu.anaVersion = NuCuts::kNMB0325Bravo; // if (bravoCut.Passed() != IsGoodStdCuts(0,nu)) { // MSG("NuDSTAna",Msg::kWarning) << "Bravo disagrees." << endl; // for (int i = 1; i < 4; i++) cout << " " << bravoCutNames[i] << ": " << bravoCutVals[i] << endl; // bravoCut.PrintCurrent(); // } // nu.anaVersion = NuCuts::kNMB0325Charlie; // if (charlieCut.Passed() != IsGoodStdCuts(0,nu)) { // MAXMSG("NuDSTAna",Msg::kWarning,100) << "Charlie disagrees." << endl; // for (int i = 1; i < 4; i++) cout << " " << charlieCutNames[i] << ": " << charlieCutVals[i] << endl; // charlieCut.PrintCurrent(); // } // if (nu.charge==-1) lib.cnt.nuNQCounter++; else if (nu.charge==+1) lib.cnt.nuPQCounter++; else cout<<"ahhh, bad charge (11)"<<endl; }//end of loop over summary tree // // double allBravo[5][2]; // double allCharlie[5][2]; // // double effBravo[5][2]; // double cNCBravo[5][2]; // double cWSBravo[5][2]; // // double effCharlie[5][2]; // double cNCCharlie[5][2]; // double cWSCharlie[5][2]; // // for (int k = 0; k < 2; k++) { // for (int i = 0; i < 5; i++) { // for (int j = 0; j < 3; j++) { // cout << "bravoCounts[" << i << "][" << j << "][" << k << "] =" << bravoCounts[i][j][k] << endl; // cout << "charlieCounts[" << i << "][" << j << "][" << k << "] =" << charlieCounts[i][j][k] << endl; // } // } // } // // // for (int en = 0; en < 2; en++) { // if (en == 0) cout << "Below 5 GeV: " << endl; // else cout << "Above 5 GeV: " << endl; // for (int i = 0; i < 5; i++) { // allBravo[i][en] = bravoCounts[i][0][en] + bravoCounts[i][1][en] + bravoCounts[i][2][en]; // allCharlie[i][en] = charlieCounts[i][0][en] + charlieCounts[i][1][en] + charlieCounts[i][2][en]; // // effBravo[i][en] = bravoCounts[i][0][en] / bravoCounts[0][0][en]; // cNCBravo[i][en] = bravoCounts[i][1][en] / allBravo[i][en]; // cWSBravo[i][en] = bravoCounts[i][2][en] / allBravo[i][en]; // // effCharlie[i][en] = charlieCounts[i][0][en] / charlieCounts[0][0][en]; // cNCCharlie[i][en] = charlieCounts[i][1][en] / allCharlie[i][en]; // cWSCharlie[i][en] = charlieCounts[i][2][en] / allCharlie[i][en]; // } // // cout << endl << "Bravo: " << endl; // cout << "Cut" << "\t" << "Eff" << "\t" << "NC" << "\t" << "WS" << endl; // for (int i = 0; i < 5; i++) // cout << bravoCutNames[i] << "\t" << effBravo[i][en] // << "\t" << cNCBravo[i][en] // << "\t" << cWSBravo[i][en] << endl; // // cout << endl << "Charlie: " << endl; // cout << "Cut" << "\t" << "Eff" << "\t" << "NC" << "\t" << "WS" << endl; // for (int i = 0; i < 5; i++) // cout << charlieCutNames[i] << "\t" << effCharlie[i][en] // << "\t" << cNCCharlie[i][en] // << "\t" << cWSCharlie[i][en] << endl; // cout << endl; // } MSG("NuAnalysis",Msg::kInfo)<<"Finished main loop"<<endl; //print out the numbers of events lib.cnt.PrintMicroDST(); MSG("NuAnalysis",Msg::kInfo) <<" ** Finished SelectorTable method **"<<endl; }

void NuDSTAna::StdCCAna (   )

Definition at line 5185 of file NuDSTAna.cxx. References NuMCEvent::anaVersion, NuEvent::anaVersion, NuReco::ApplyReweights(), NuEvent::charge, NuLibrary::cnt, NuLibrary::cuts, NuConfig::detector, DoIO(), NuEvent::energy, NuMCEvent::energyMC, NuEvent::energyMC, NuCounter::evtCounter, NuHistos::FillMatrixMethodHistos(), NuPlots::FillTrueFidEnergySpect(), NuPlots::FillTrueFidEnergySpectSpecial(), NuInputEvents::GetEntriesNuEvent(), NuInputEvents::GetEntriesNuMCEvent(), NuReco::GetEvtEnergy(), NuInputEvents::GetNextNuEvent(), NuInputEvents::GetNextNuMCEvent(), NuLibrary::hist, NuEvent::index, NuInputEvents::InitialiseNuMCEventBranch(), NuLibrary::Instance(), IsGoodStdCuts(), NuCuts::IsInFidVolTrueEvt(), MakeFinalPlots(), MAXMSG, MSG, NuCounter::nuNQCounter, NuCounter::nuPQCounter, NuBase::OpenTxtFile(), plots(), NuPlots::PrintEventInfo(), NuBase::PrintLoopProgress(), NuCounter::PrintMicroDST(), NuLibrary::reco, NuInputEvents::ResetNuEventLoopPositionToStart(), NuInputEvents::ResetNuMCEventLoopPositionToStart(), NuConfig::run, and SanityCheckedAnaVersion(). { NuInputEvents& input=this->DoIO(); //use config object to store info NuConfig config; config.detector=Detector::kFar; config.run=100; //text files to store info for evts passing cuts string sTxt="nmb";//nubars ofstream& nmbTxt=*(this->OpenTxtFile(config,sTxt.c_str())); string sTxtNM="nm";//neutrinos ofstream& nmTxt=*(this->OpenTxtFile(config,sTxtNM.c_str())); //get an instance of the code library NuLibrary& lib=NuLibrary::Instance(); //get an object to fill plots const NuPlots* plots=new NuPlots(); //version to do reco/cuts with //NuCuts::NuAnaVersion_t overrideAnaVersion=NuCuts::kCC0250Std; NuCuts::NuAnaVersion_t overrideAnaVersion=NuCuts::kCC0325Std; input.ResetNuEventLoopPositionToStart(); cout<<endl <<"************************************************"<<endl <<"*** Starting main loop over snarls ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuEvent();++i) { lib.cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuEvent(),1); NuEvent& nu=const_cast<NuEvent&>(input.GetNextNuEvent(Msg::kDebug)); //set ana version nu.anaVersion=this->SanityCheckedAnaVersion (nu.anaVersion,overrideAnaVersion); //RE-RECONSTRUCT the neutrino energy lib.reco.GetEvtEnergy(nu, false);//this re-reconstructs the neutrino energy lib.reco.ApplyReweights(nu); //make all the std cuts if (!this->IsGoodStdCuts(plots,nu)) continue; if (nu.charge==-1) { plots->PrintEventInfo(nmTxt,nu); lib.cnt.nuNQCounter++; } else if (nu.charge==+1) { plots->PrintEventInfo(nmbTxt,nu); lib.cnt.nuPQCounter++; } else cout<<"ahhh, bad charge (7)"<<endl; //make the final plots this->MakeFinalPlots(plots,nu); //fill matrix method histos lib.hist.FillMatrixMethodHistos(nu); MAXMSG("NuDSTAna",Msg::kInfo,5) <<"Passed: index="<<nu.index <<", energy="<<nu.energy<<", energyMC="<<nu.energyMC<<endl; }//end of loop over summary tree input.InitialiseNuMCEventBranch(); input.ResetNuMCEventLoopPositionToStart(); cout<<endl <<"************************************************"<<endl <<"*** Starting loop over truth info ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuMCEvent();++i) { lib.cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuMCEvent(),1); NuMCEvent& mc=const_cast<NuMCEvent&>(input.GetNextNuMCEvent (Msg::kDebug)); //set ana version mc.anaVersion=this->SanityCheckedAnaVersion (mc.anaVersion,overrideAnaVersion); MAXMSG("NuDSTAna",Msg::kInfo,5) <<"energyMC="<<mc.energyMC<<endl; //make fid vol cut if (!lib.cuts.IsInFidVolTrueEvt(mc)) continue; //fill plots plots->FillTrueFidEnergySpect(mc); plots->FillTrueFidEnergySpectSpecial(mc); } MSG("NuAnalysis",Msg::kInfo)<<"Finished main loop"<<endl; //print out the numbers of events lib.cnt.PrintMicroDST(); MSG("NuAnalysis",Msg::kInfo) <<" ** Finished StdCCAna method **"<<endl; }

void NuDSTAna::StdNMBAna (  TString  xmlFileName = ""  )

this method runs the standard NuMuBar (NMB) analysis Definition at line 2877 of file NuDSTAna.cxx. References NuEvent::anaVersion, NuMCEvent::anaVersion, NuReco::ApplyReweights(), NuEvent::charge, NuLibrary::cnt, NuLibrary::cuts, NuConfig::detector, DoIO(), NuEvent::energy, NuEvent::energyMC, NuMCEvent::energyMC, NuCounter::evtCounter, NuTransition::Fill(), NuHistos::FillMatrixMethodHistos(), NuPlots::FillTrueFidEnergySpect(), NuPlots::FillTrueFidEnergySpectSpecial(), NuInputEvents::GetEntriesNuEvent(), NuInputEvents::GetEntriesNuMCEvent(), NuReco::GetEvtEnergy(), NuInputEvents::GetNextNuEvent(), NuInputEvents::GetNextNuMCEvent(), NuLibrary::hist, NuEvent::index, NuInputEvents::InitialiseNuMCEventBranch(), NuLibrary::Instance(), IsGoodStdCuts(), NuCuts::IsInFidVolTrueEvt(), MakeFinalPlots(), MAXMSG, MSG, NuCounter::nuNQCounter, NuCounter::nuPQCounter, NuBase::OpenTxtFile(), plots(), NuPlots::PrintEventInfo(), NuBase::PrintLoopProgress(), NuCounter::PrintMicroDST(), NuLibrary::reco, NuInputEvents::ResetNuEventLoopPositionToStart(), NuInputEvents::ResetNuMCEventLoopPositionToStart(), NuTransition::Reweight(), NuConfig::run, and SanityCheckedAnaVersion(). { NuInputEvents& input=this->DoIO(); //use config object to store info NuConfig config; config.detector=Detector::kFar; config.run=100; // If we have been given an XML file, then we want to use it for // oscillation. Read it in (and put it in the output file) NuXMLConfig *xmlConfig = 0; if (!xmlFileName.IsNull()) { xmlConfig = new NuXMLConfig(xmlFileName); xmlConfig->Write(); } //text files to store info for evts passing cuts string sTxt="nmb";//nubars ofstream& nmbTxt=*(this->OpenTxtFile(config,sTxt.c_str())); string sTxtNM="nm";//neutrinos ofstream& nmTxt=*(this->OpenTxtFile(config,sTxtNM.c_str())); //get an instance of the code library NuLibrary& lib=NuLibrary::Instance(); //get an object to fill plots const NuPlots* plots=new NuPlots(); //create the object that gathers the information for transitions reweighting cout << "**** About to construct NuTransition object" << endl; NuTransition * transition = new NuTransition(xmlConfig); cout << "**** Done" << endl; //version to do reco/cuts with //NuCuts::NuAnaVersion_t overrideAnaVersion=NuCuts::kJJH1; NuCuts::NuAnaVersion_t overrideAnaVersion=NuCuts::kNMB0325Bravo; input.InitialiseNuMCEventBranch(); input.ResetNuMCEventLoopPositionToStart(); cout<<endl <<"************************************************"<<endl <<"*** Starting loop over truth info ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuMCEvent();++i) { lib.cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuMCEvent(),1); NuMCEvent& mc = const_cast<NuMCEvent&>(input.GetNextNuMCEvent (Msg::kDebug)); //set the analysis version (could be kFullDST) mc.anaVersion=this->SanityCheckedAnaVersion (mc.anaVersion,overrideAnaVersion); MAXMSG("NuDSTAna",Msg::kInfo,5) <<"energyMC="<<mc.energyMC<<endl; //make fid vol cut if (!lib.cuts.IsInFidVolTrueEvt(mc)) continue; //store the information needed for transitions reweighting transition->Fill(mc); //fill plots plots->FillTrueFidEnergySpect(mc); plots->FillTrueFidEnergySpectSpecial(mc); } MSG("NuAnalysis",Msg::kInfo)<<"Finished truth loop"<<endl; input.ResetNuEventLoopPositionToStart(); cout<<endl <<"************************************************"<<endl <<"*** Starting main loop over snarls ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuEvent();++i) { lib.cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuEvent(),1); NuEvent& nu=const_cast<NuEvent&>(input.GetNextNuEvent(Msg::kDebug)); //set the analysis version (could be kFullDST) nu.anaVersion=this->SanityCheckedAnaVersion (nu.anaVersion,overrideAnaVersion); //RE-RECONSTRUCT the neutrino energy lib.reco.GetEvtEnergy(nu, false);//this re-reconstructs the neutrino energy lib.reco.ApplyReweights(nu); // Reweight for systematics, oscillations and transitions transition->Reweight(nu); //make all the std cuts if (!this->IsGoodStdCuts(plots,nu)) continue; if (nu.charge==-1) { plots->PrintEventInfo(nmTxt,nu); lib.cnt.nuNQCounter++; } else if (nu.charge==+1) { plots->PrintEventInfo(nmbTxt,nu); lib.cnt.nuPQCounter++; } else cout<<"ahhh, bad charge (3)"<<endl; //make the final plots this->MakeFinalPlots(plots,nu); //fill matrix method histos lib.hist.FillMatrixMethodHistos(nu);//might override file ones MAXMSG("NuDSTAna",Msg::kInfo,5) <<"Passed: index="<<nu.index <<", energy="<<nu.energy<<", energyMC="<<nu.energyMC<<endl; }//end of loop over summary tree MSG("NuAnalysis",Msg::kInfo)<<"Finished main loop"<<endl; //print out the numbers of events lib.cnt.PrintMicroDST(); MSG("NuAnalysis",Msg::kInfo) <<" ** Finished StdAna method **"<<endl; }

void NuDSTAna::TestNuSyst (   )

Definition at line 7782 of file NuDSTAna.cxx. References NuEvent::charge, DoIO(), NuInputEvents::GetEntriesNuEvent(), NuInputEvents::GetNextNuEvent(), NuEvent::iaction, NuEvent::inu, NuCut::MakeCuts(), NuCut::Passed(), NuBase::PrintLoopProgress(), NuSystematic::PrintState(), NuSystematic::Randomize(), NuInputEvents::ResetNuEventLoopPositionToStart(), NuEvent::rw, NuSystematic::SetNuBarSelector(), NuSystematic::SetShiftsAsSigmas(), NuSystematic::SetShiftsAsValues(), and NuSystematic::Shift(). { NuInputEvents& input=this->DoIO(); input.ResetNuEventLoopPositionToStart(); NuSystematic syst; cout << "Initial: " << endl; syst.PrintState(1); std::map<TString, double> shifts; //shifts["ShowerEnergyScaleBoth"] = 1; //shifts["DecayPipe"] = 1; //shifts["NuMuBarXSecSum"] = 1; cout << "Setting Shifts as Values" << endl; shifts["AllBackgroundsScaleBoth"] = 1.25; shifts["TrackEnergyRange"] = 1.04; syst.SetShiftsAsValues(shifts); syst.PrintState(); cout << "Randomize: " << endl; syst.Randomize(); syst.PrintState(); cout << "Setting Shifts to 1 Sigma" << endl; shifts["AllBackgroundsScaleBoth"] = 1; shifts["TrackEnergyRange"] = 1; syst.SetShiftsAsSigmas(shifts); cout << "One Sigma: " << endl; syst.PrintState(); //NuCutter cutter(9); NuCutImps::Bravo bravoCut; syst.SetNuBarSelector(&bravoCut); return; //get an instance of the code library //NuLibrary& lib=NuLibrary::Instance(); int selCount = 0; int cutCount = 0; cout<<endl <<"************************************************"<<endl <<"*** Starting main loop over snarls ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuEvent();++i) { //for (Int_t i=0;i<0;++i) { this->PrintLoopProgress(i,input.GetEntriesNuEvent(),1); NuEvent &nu=const_cast<NuEvent&>(input.GetNextNuEvent(Msg::kWarning)); if (nu.charge == -1) continue; bravoCut.MakeCuts(nu); if (nu.iaction == 0 || nu.inu == 14) { if (bravoCut.Passed()) { selCount++; } else { cutCount++; } cout << "Event #" << i << ": " << endl; cout << " passed = " << (bravoCut.Passed() ? "Yes" : "No") << endl //<< " contained = " << (nu.usedRange ? "Yes" : "No") << endl << " pre rw = " << nu.rw << endl; //<< " pre E = " << nu.energy << endl; syst.Shift(nu); cout << " post rw = " << nu.rw << endl; //<< " post E = " << nu.energy << endl; } if (selCount > 10 && cutCount > 10) { break; } } cout << "Done." << endl;; }

void NuDSTAna::UpdatePotSinceLastEvt (  NuEvent &  nu, Bool_t  newEvt )  const [protected]

Definition at line 3059 of file NuDSTAna.cxx. References NuEvent::potSinceLastEvt, NuEvent::potSinceLastEvtBad, NuEvent::potSinceLastEvtBadDB, NuEvent::potSinceLastEvtDB, NuEvent::potSinceLastEvtGood, and NuEvent::potSinceLastEvtGoodDB. Referenced by MakeDstPQ(), MakeMicroDST(), MakeMicroDst2010(), MakeMicroDstFakeData(), MakeMicroDstForCSSSystematics(), MakeMicroDstHe(), MakeMicroDstJJEPresel(), MakeMicroDstWithStdCCRecoAndCuts(), MakeSelMicroDST(), and VsTime(). { //count the pots since the last evt was written to file static Float_t potSinceLastEvt=0; static Float_t potSinceLastEvtGood=0; static Float_t potSinceLastEvtBad=0;//this is always zero here static Float_t potSinceLastEvtDB=0; static Float_t potSinceLastEvtGoodDB=0; static Float_t potSinceLastEvtBadDB=0; if (newEvt) { //write out the pots since the last evt nu.potSinceLastEvt=potSinceLastEvt; nu.potSinceLastEvtGood=potSinceLastEvtGood; nu.potSinceLastEvtBad=potSinceLastEvtBad; nu.potSinceLastEvtDB=potSinceLastEvtDB; nu.potSinceLastEvtGoodDB=potSinceLastEvtGoodDB; nu.potSinceLastEvtBadDB=potSinceLastEvtBadDB; potSinceLastEvt=0;//reset this for the next loop potSinceLastEvtGood=0; potSinceLastEvtBad=0; potSinceLastEvtDB=0; potSinceLastEvtGoodDB=0; potSinceLastEvtBadDB=0; } else { potSinceLastEvt+=nu.potSinceLastEvt; potSinceLastEvtGood+=nu.potSinceLastEvtGood; potSinceLastEvtBad+=nu.potSinceLastEvtBad; potSinceLastEvtDB+=nu.potSinceLastEvtDB; potSinceLastEvtGoodDB+=nu.potSinceLastEvtGoodDB; potSinceLastEvtBadDB+=nu.potSinceLastEvtBadDB; } }

void NuDSTAna::VsTime (   )

this method makes plots of various quantities vs time Note: this should only be run on one microDST, not several at once The Definition at line 4686 of file NuDSTAna.cxx. References NuEvent::anaVersion, NuEvent::charge, NuLibrary::cnt, NuEvent::coilIsOk, NuLibrary::cuts, DoIO(), NuEvent::energy, NuEvent::energyMC, NuCounter::evtCounter, NuTime::FillVsTimeHistos(), NuTime::FillVsTimeHistos2(), NuInputEvents::GetEntriesNuEvent(), NuInputEvents::GetNextNuEvent(), NuEvent::goodBeam, NuEvent::goodBeamSntp, NuEvent::index, NuLibrary::Instance(), NuCuts::IsGoodNumberOfTracks(), NuCuts::IsGoodPID(), IsGoodStdCuts(), NuCuts::IsGoodTimeToNearestSpill(), NuCuts::IsInFidVolTrk(), NuCuts::IsLI(), MAXMSG, MSG, NuCounter::nuNQCounter, NuCounter::nuPQCounter, plots(), NuEvent::potSinceLastEvtGood, NuEvent::potSinceLastEvtGoodDB, NuBase::PrintLoopProgress(), NuCounter::PrintMicroDST(), SanityCheckedAnaVersion(), NuCounter::totalPot, NuCounter::totalPotDB, and UpdatePotSinceLastEvt(). { NuInputEvents& input=this->DoIO(NULL,"VsTime"); //get an instance of the code library NuLibrary& lib=NuLibrary::Instance(); //get objects to fill plots const NuPlots* plots=new NuPlots(); NuTime time; //get the earliest and latest times in order to define the time range TH1I* hNtupleEarliestTime= (TH1I*)gROOT->FindObject("hNtupleEarliestTime"); TH1I* hNtupleLatestTime= (TH1I*)gROOT->FindObject("hNtupleLatestTime"); Int_t earliestTime=1; Int_t latestTime=1; if (hNtupleLatestTime && hNtupleEarliestTime) { earliestTime=static_cast<Int_t>(hNtupleEarliestTime->Integral()); latestTime=static_cast<Int_t>(hNtupleLatestTime->Integral()); MAXMSG("NuDSTAna",Msg::kInfo,100) <<"Ntuple: earliestTime="<<earliestTime <<", latestTime="<<latestTime<<endl; } else { MSG("NuDSTAna",Msg::kError) <<"Ahhh, no earliest and latest time histos, aborting..."<<endl; assert(false); } //version to do reco/cuts with //NuCuts::NuAnaVersion_t overrideAnaVersion=NuCuts::kCC0250Std NuCuts::NuAnaVersion_t overrideAnaVersion=NuCuts::kNMB0325Bravo; cout<<endl <<"************************************************"<<endl <<"*** Starting main loop over snarls ***"<<endl <<"************************************************"<<endl; for (Int_t i=0;i<input.GetEntriesNuEvent();++i) { //for (Int_t i=0;i<0;++i) { lib.cnt.evtCounter++; this->PrintLoopProgress(i,input.GetEntriesNuEvent(),1); NuEvent& nu=const_cast<NuEvent&>(input.GetNextNuEvent(Msg::kDebug)); //OVERRIDE nu.anaVersion=this->SanityCheckedAnaVersion (nu.anaVersion,overrideAnaVersion); //only do this if you absolutely have to //and don't commit the code without these commented out //this->OverwriteCoilDataInNtuple(nu); //this->OverwriteSntpBeamDataInNtuple(nu); //nu.potSinceLastEvtGoodDB=nu.potSinceLastEvtDB;//Good not written to file //count up the good pots in the file (according to the sntp data or the database) if (nu.goodBeamSntp && nu.coilIsOk) lib.cnt.totalPot+=nu.potSinceLastEvtGood; if (nu.goodBeam && nu.coilIsOk) lib.cnt.totalPotDB+=nu.potSinceLastEvtGoodDB; //RE-RECONSTRUCT the neutrino energy //lib.reco.GetEvtEnergy(nu); //lib.reco.ApplyReweights(nu); //count up the pots Bool_t newEvt=false; this->UpdatePotSinceLastEvt(nu,newEvt); //fill vs time histos with just minimum number of cuts if (lib.cuts.IsGoodNumberOfTracks(nu) && lib.cuts.IsInFidVolTrk(nu) && !lib.cuts.IsLI(nu) && lib.cuts.IsGoodTimeToNearestSpill(nu) && lib.cuts.IsGoodPID(nu)) { MAXMSG("NuDSTAna",Msg::kDebug,5) <<"Filling timeAll..."<<endl; //copy pots since last event to ntuple for this new evt newEvt=true; this->UpdatePotSinceLastEvt(nu,newEvt); //fill the vs time histos time.FillVsTimeHistos2(nu,earliestTime,latestTime,"All"); } //make the preselection cuts //if (!this->IsGoodPreSelectionCuts(plots,nu)) continue; //make all the std cuts if (!this->IsGoodStdCuts(plots,nu)) continue; if (nu.charge==-1) { lib.cnt.nuNQCounter++; } else if (nu.charge==+1) { lib.cnt.nuPQCounter++; } else cout<<"ahhh, bad charge (5)"<<endl; //fill the vs time histos time.FillVsTimeHistos(nu,earliestTime,latestTime); MAXMSG("NuDSTAna",Msg::kInfo,5) <<"Passed: index="<<nu.index <<", energy="<<nu.energy<<", energyMC="<<nu.energyMC<<endl; }//end of loop over summary tree MSG("NuAnalysis",Msg::kInfo)<<"Finished main loop"<<endl; //print out the numbers of events lib.cnt.PrintMicroDST(); MSG("NuAnalysis",Msg::kInfo) <<" ** Finished VsTime method **"<<endl; }

---

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

• NuDSTAna.h
• NuDSTAna.cxx

---