NCExtrapolationModule Class Reference

Job module to perform extrapolations and fits. More...

#include <NCExtrapolationModule.h>

List of all members.

Public Member Functions
	NCExtrapolationModule ()
virtual	~NCExtrapolationModule ()
const Registry &	DefaultConfig () const
void	Config (const Registry &r)
void	Run ()
void	SetMCExposureForBeam (NCBeam::Info beam, double pot)
virtual void	AddEventToExtrapolations (bool fakeDataSet)
	Add event held in fEventInfo to all extrapolations.
Static Public Member Functions
void	AddExtrapolation (NCExtrapolationFactory *e)
Private Types
typedef std::map< NCBeam::Info, TChain * >	ChainMap
typedef std::map< NCBeam::Info, double >	POTMap
Private Member Functions
TH1 *	CreateSpecialPlot (int k, TString type) const
void	PrepareForExtrapolation ()
void	GetListOfShifts (std::vector< bool * > &useParameters, std::vector< std::vector< double > > &adjustedValues) const
void	AddShiftedEventToExtrapolations (NCEventInfo eventInfo, bool useMCAsData, NCType::EFileType fileType, NC::RunUtil::ERunType runType, NCBeam::Info beamInfo)
void	AddFilesToChain (ChainMap &chainMap, Detector::Detector_t det, NCType::EFileType fileType, NCType::EDataMC dataMC)
	Add relevant files for some spectrum to chainMap.
void	ExtrapolateNearToFar ()
	Add the FD events to the extrapolations and run the fit for each one.
void	FillDataQualityPlotsSpecial (std::vector< TH1 * > &dq, bool osc)
void	DoMockExperiments ()
void	SystematicsFromRegistry (bool *systematicsToUse, std::vector< double > &systematicsAdjust)
void	ApplySystematicShifts (NC::RunUtil::ERunType runType)
double	GetMCScaleFactor (Detector::Detector_t det, NCType::EFileType fileType, NCBeam::Info info)
	Get the factor to scale the MC by to match the data. Will be zero for beams which have no data.
double	GetScaleFactorFromMaps (POTMap &potData, POTMap &potMC, NCBeam::Info info)
	Helper for GetMCScaleFactor.
void	SetEventWeight (BeamType::BeamType_t beamType, NC::RunUtil::ERunType runType, bool fakeDataSet)
bool	FinalEventCheck ()
	any last checks.
void	SetEnergies ()
	Set reco.nuEnergy and reco.showerEnergy to the appropriate NC or CC variant.
void	DrawDataQualityPlots ()
void	DrawDataQualityPlotsSpecial ()
void	CreateExtrapolations (TString extrapolations)
Static Private Member Functions
std::vector< NCExtrapolationFactory * > &	GetExtrapolationFactories ()
	The various extrapolations that have registered themselves.
Private Attributes
NC::OscProb::OscPars *	fTrueOscPars
std::vector< TH1 * >	fDQNearMCTotalSpecial
TString	fDataMCPath
	path to uDST for data and MC files
TString	fFileName
	name of output file
bool	fUseMCAsData
	use the MC as data for testing purposes
NCType::EOscModel	fOscillationModel
	model to use in the fit
NCType::EExtraction	fExtractionType
	the extraction to use
bool	fUseMockData
	are you using mock data for the data?
std::vector< BeamType::BeamType_t >	fBeamIndex
	index of beams to use
bool	fUsePIDCustomCut
	Use custom cut.
double	fPIDCustomCut
	Custom cut value.
bool	fShiftedBeams
	If set then AddShiftedEventToExtrapolations is called.
bool	fSimpleShiftedBeams
	Controls whether to generate a simpler set of shifted beams.
int	fSingleShiftedBeam
	Controls if only a single shifted beam is made.
bool	fMakeDQPlotsSpecial
	Ask Alex...
NCEventInfo	fEventInfo
std::vector< NCExtrapolation * >	fExtrapolations
std::vector< NC::FitMaster * >	fFitMasters
TString	fExtrapolationsList
	A space-separated list of extrapolations to use, from job macro.
TString	fLoadExtrapolationsFile
	Filename to load extrapolation objects from. Empty string -> no loading.
bool	fIncludeDataFromLoadedExtrapolations
	If fLoadExtrapolationsFile then load data part of spectrum too.
TString	fSaveExtrapolationsFile
	Filename to save extrapolation objects to. Empty string -> no saving.
bool	fSingleSpectrum
	use a single spectrum
std::vector< NC::RunUtil::ERunType >	fRunsToUse
	define which runs to use
POTMap	fDataPOTNear
POTMap	fDataPOTFar
POTMap	fMCPOTNear
POTMap	fMCPOTFar
POTMap	fMCPOTFarTau
POTMap	fMCPOTFarElectron
int	fNumMockExperiments
	Zero if fake experiments are not to be carried out (default).
int	fMockExperimentsSeed
std::vector< NCEventInfo * >	fFDMCSample
NCPOTCounter *	fPOTCount
std::vector< Registry * >	fMockFits
Registry	fConfig

---

Detailed Description

Job module to perform extrapolations and fits.

Definition at line 61 of file NCExtrapolationModule.h.

---

Member Typedef Documentation

typedef std::map<NCBeam::Info, TChain*> NCExtrapolationModule::ChainMap [private]

Definition at line 85 of file NCExtrapolationModule.h. Referenced by Run().

typedef std::map<NCBeam::Info, double> NCExtrapolationModule::POTMap [private]

Definition at line 86 of file NCExtrapolationModule.h. Referenced by GetMCScaleFactor().

---

Constructor & Destructor Documentation

NCExtrapolationModule::NCExtrapolationModule (   )

Definition at line 46 of file NCExtrapolationModule.cxx. References NCEventInfo::analysis, NCEventInfo::beam, CreateSpecialPlot(), fDQNearMCTotalSpecial, fEventInfo, fPOTCount, NCEventInfo::header, MSG, NCEventInfo::reco, and NCEventInfo::truth. : fTrueOscPars(0), fNumMockExperiments(0), fPOTCount(0) { MSG("JobC", Msg::kDebug) << "NCExtrapolationModule::Constructor" << endl; // "Special" means studying systematic shifts. // These are the TOm selection variables. for(int k = 3; k < 6; ++k){ fDQNearMCTotalSpecial.push_back(CreateSpecialPlot(k, "NearMCTotalSpecial")); } fEventInfo.header = new ANtpHeaderInfo; fEventInfo.beam = new ANtpBeamInfo; fEventInfo.reco = new ANtpRecoInfo; fEventInfo.analysis = new ANtpAnalysisInfo; fEventInfo.truth = new ANtpTruthInfoBeam; fPOTCount = new NCPOTCounter; }

NCExtrapolationModule::~NCExtrapolationModule (   )  [virtual]

Definition at line 111 of file NCExtrapolationModule.cxx. References NCEventInfo::analysis, NCEventInfo::beam, fEventInfo, fExtrapolations, fFDMCSample, fFitMasters, fMockFits, NCEventInfo::header, MSG, NCEventInfo::reco, NCEventInfo::reco_nom, and NCEventInfo::truth. { MSG("JobC", Msg::kDebug) << "NCExtrapolationModule::Destructor" << endl; for(unsigned int n = 0; n < fExtrapolations.size(); ++n) delete fExtrapolations[n]; for(unsigned int n = 0; n < fFitMasters.size(); ++n) delete fFitMasters[n]; if(fEventInfo.header) delete fEventInfo.header; if(fEventInfo.beam) delete fEventInfo.beam; if(fEventInfo.reco) delete fEventInfo.reco; if(fEventInfo.reco_nom) delete fEventInfo.reco_nom; if(fEventInfo.truth) delete fEventInfo.truth; if(fEventInfo.analysis) delete fEventInfo.analysis; if(fTrueOscPars) delete fTrueOscPars; if(fPOTCount) delete fPOTCount; for(unsigned int n = 0; n < fFDMCSample.size(); ++n){ delete fFDMCSample[n]->header; delete fFDMCSample[n]->beam; delete fFDMCSample[n]->reco; delete fFDMCSample[n]->reco_nom; delete fFDMCSample[n]->truth; delete fFDMCSample[n]->analysis; delete fFDMCSample[n]; } for(unsigned int n = 0; n < fMockFits.size(); ++n) delete fMockFits[n]; }

---

Member Function Documentation

void NCExtrapolationModule::AddEventToExtrapolations (  bool  fakeDataSet  )  [virtual]

Add event held in fEventInfo to all extrapolations. This is the callback used by NC::IEventAdder Warning - as a side-effect may modify the details of the event although we do take care to restore the event weight properly Note: virtual function for testability Definition at line 954 of file NCExtrapolationModule.cxx. References AddShiftedEventToExtrapolations(), NCEventInfo::analysis, NCEventInfo::beam, ANtpBeamInfo::beamType, ANtpHeaderInfo::dataType, NCEventInfo::DeepCopy(), ANtpHeaderInfo::detector, fDQNearMCTotalSpecial, fEventInfo, fExtrapolations, fFDMCSample, FillDataQualityPlotsSpecial(), FinalEventCheck(), NCType::FindFileType(), NC::RunUtil::FindRunType(), fNumMockExperiments, fPIDCustomCut, fUsePIDCustomCut, NCEventInfo::header, ANtpTruthInfo::interactionType, ANtpAnalysisInfo::isCC, ANtpAnalysisInfo::isNC, ANtpTruthInfoBeam::nonOscNuFlavor, NCEventInfo::reco, ANtpAnalysisInfo::separationParameter, ANtpAnalysisInfo::separationParameterCut, SetEnergies(), SetEventWeight(), SimFlag::SimFlag_t, NCEventInfo::truth, and ANtpRecoInfo::weight. Referenced by NC::MockDataAdder::AddEventsToExtrapolations(), NC::RealDataAdder::AddEventsToExtrapolations(), NC::SplitFakeDataAdder::AddEventsToExtrapolations(), and NC::FakeDataAdder::AddEventsToExtrapolations(). { // This is pretty much immediately after the event comes off disk. Call // SetEnergies here, as early as possible, so showerEnergy and trackEnergy // are set to the right NC/CC variants. This is certainly needed for getting // systematic shifts right, and maybe other reasons. SetEnergies(); SimFlag::SimFlag_t sim = SimFlag::SimFlag_t(fEventInfo.header->dataType); //Use PID custom selection cut if so desired if(fUsePIDCustomCut && TMath::Abs(fPIDCustomCut-fEventInfo.analysis->separationParameterCut) > 1e-3){ fEventInfo.analysis->separationParameterCut = fPIDCustomCut; fEventInfo.analysis->isNC = int(fEventInfo.analysis->separationParameter < fPIDCustomCut); fEventInfo.analysis->isCC = int(fEventInfo.analysis->separationParameter >= fPIDCustomCut); } //check for any extra cuts you may want to apply, eg good shower cut if(!FinalEventCheck()) return; //check if the event is from a tau file. const NCType::EFileType fileType = NCType::FindFileType(fEventInfo.header); const NC::RunUtil::ERunType runType = NC::RunUtil::FindRunType(fEventInfo.header, fEventInfo.reco); if(fileType == NCType::kTauFile || fileType == NCType::kElectronFile){ //dont add in NC tau or nue appearance //events as you cant distinguish flavor //with NC events. NCEnergyBin wouldnt //accept the event anyway. also reject //events from these files that start off as //nue...just say they dont oscillate as //they dont contribute much anyway if(fEventInfo.truth->interactionType == NCType::kNC || TMath::Abs(fEventInfo.truth->nonOscNuFlavor) == 12) return; } else if(fileType == NCType::kUnknownFile) return; // Single spectrum fitting if(fSingleSpectrum){ fEventInfo.analysis->isNC = 0; fEventInfo.analysis->isCC = 1; } if(sim == SimFlag::kData || fileType == NCType::kMockFile) fEventInfo.truth = 0; // Mock data should have simflag set to data if (fileType == NCType::kMockFile) fEventInfo.header->dataType=SimFlag::kData; //-------------------------------------------------------------------------------- //put in for testing purposes, should be commented out for real fits //if(TMath::Abs(fEventInfo.truth->nuFlavor) == 12) continue; // fEventInfo.analysis->isNC = 0; // fEventInfo.analysis->isCC = 0; // if(fEventInfo.truth->interactionType < 1) fEventInfo.analysis->isNC = 1; // else if(fEventInfo.truth->interactionType > 0) fEventInfo.analysis->isCC = 1; // fEventInfo.reco->nuEnergy = truthInfo->nuEnergy; //-------------------------------------------------------------------------------- // TODO - correct if statement? if(sim == SimFlag::kMC && fakeDataSet && fEventInfo.header->detector == Detector::kFar && fNumMockExperiments > 0){ NCEventInfo* evt = new NCEventInfo; evt->DeepCopy(&fEventInfo); fFDMCSample.push_back(evt); } const BeamType::BeamType_t beamType = (BeamType::BeamType_t)(fEventInfo.beam->beamType); const NCBeam::Info beamInfo(beamType, runType); const NCBeam::Info infoAll(beamType, NC::RunUtil::kRunAll); //add event to each extrapolation for(unsigned int i = 0; i < fExtrapolations.size(); ++i){ if(sim==SimFlag::kMC){ SetEventWeight(beamType, runType, fakeDataSet); // If we have MC for this beam but not data, SetEventWeight // will have set the weight to zero, so don't add it at // all. This ensures that the MC beams that have events added // to them are the ones that were selected in the RunsToUse // registry key *and* have data available if(fEventInfo.reco->weight!=0){ //NCBeam::Info info=NCBeam::Info(beamType, thisRunType); fExtrapolations[i]->AddEvent(fEventInfo, fakeDataSet, fileType, beamInfo); // Also add it to the RunAll beam fExtrapolations[i]->AddEvent(fEventInfo, fakeDataSet, fileType, infoAll); if(fShiftedBeams){ AddShiftedEventToExtrapolations(fEventInfo, fakeDataSet, fileType, runType, beamInfo); AddShiftedEventToExtrapolations(fEventInfo, fakeDataSet, fileType, runType, infoAll); } }// end if non-zero weight }// end if MC else{ SetEnergies(); // Data/mock data goes in whatever run it really is... fExtrapolations[i]->AddEvent(fEventInfo, fakeDataSet, fileType, beamInfo); // ...and RunAll fExtrapolations[i]->AddEvent(fEventInfo, fakeDataSet, fileType, infoAll); } }//end loop over extrapolation objects if(fMakeDQPlotsSpecial){ if(fEventInfo.header->dataType == int(SimFlag::kMC)){ if(fEventInfo.header->detector == int(Detector::kNear)){ FillDataQualityPlotsSpecial(fDQNearMCTotalSpecial, false); } } } }

void NCExtrapolationModule::AddExtrapolation (  NCExtrapolationFactory *  e  )  [static]

Definition at line 340 of file NCExtrapolationModule.cxx. References NCExtrapolationFactory::GetCodeName(), and GetExtrapolationFactories(). { std::vector<NCExtrapolationFactory*>& facts = GetExtrapolationFactories(); for(unsigned int n = 0; n < facts.size(); ++n){ // If this happens it means that extrapolations have got registered // twice somehow. Check your environment, and rebuild stuff, including // the macro. assert(e->GetCodeName() != facts[n]->GetCodeName()); } facts.push_back(e); }

void NCExtrapolationModule::AddFilesToChain (  ChainMap &  chainMap, Detector::Detector_t  det, NCType::EFileType  fileType, NCType::EDataMC  dataMC )  [private]

Add relevant files for some spectrum to chainMap. Parameters: chainMap  chain to add the files to det  detector the chain represents fileType  is only relevant for MC - should be kBeamFile otherwise dataMC  whether chainMap is holding a data or MC spectrum - getting the correct fake/mock data files is taken care of by NCPOTCounter Definition at line 499 of file NCExtrapolationModule.cxx. References BeamType::AsString(), det, fDataMCPath, files, NCType::FileTypeAsString(), fPOTCount, NCBeam::Info::GetBeamType(), NCPOTCounter::GetListOfFiles(), and MSG. Referenced by Run(). { MSG("NCExtrapolationModule", Msg::kInfo) << "fDataMCPath = " << fDataMCPath << endl; for(ChainMap::iterator it=chainMap.begin(); it != chainMap.end(); ++it){ const NCBeam::Info info=it->first; const TString beamType=BeamType::AsString(info.GetBeamType()); vector<TString> files = fPOTCount->GetListOfFiles(info, fileType, det, dataMC); for(unsigned int de = 0; de < files.size(); ++de) { it->second->Add(fDataMCPath+beamType+"/"+files[de]); MSG("NCExtrapolationModule", Msg::kInfo) << "Adding " << fDataMCPath+beamType << "/"+files[de] << " to " << NCType::FileTypeAsString(fileType) << " chain" << endl; }//end loop over files in directory }//end loop over map }

void NCExtrapolationModule::AddShiftedEventToExtrapolations (  NCEventInfo  eventInfo, bool  useMCAsData, NCType::EFileType  fileType, NC::RunUtil::ERunType  runType, NCBeam::Info  beamInfo )  [private]

Shift eventInfo according to all the different variations given by GetListOfShifts and each time add it to all the extrapolations. Definition at line 1157 of file NCExtrapolationModule.cxx. References ANtpHeaderInfo::dataType, NCEventInfo::DeepCopy(), det, ANtpHeaderInfo::detector, Detector::Detector_t, fEventInfo, fExtrapolations, FinalEventCheck(), fSingleShiftedBeam, GetListOfShifts(), GetMCScaleFactor(), NCEventInfo::header, NCEventInfo::reco, SetEnergies(), NCEventInfo::SetEventWeight(), NCBeam::Info::SetSystShifts(), and ANtpRecoInfo::weight. Referenced by AddEventToExtrapolations(). { // No point adding/shifting data events if(eventInfo.header->dataType == NCType::kData || useMCAsData) return; Detector::Detector_t det = Detector::Detector_t(fEventInfo.header->detector); // On the assumption that the contents of the registry don't change between // successive calls to us, then save time by only working out what shifts // to do once. static vector<bool*> useParameters; static vector<vector<double> > adjustedValues; static bool once = true; if(once){ once = false; GetListOfShifts(useParameters, adjustedValues); } NC::OscProb::OscPars* noosc = new NC::OscProb::NoOscillations; for(unsigned int i = 0; i < useParameters.size(); ++i){ if(fSingleShiftedBeam >= 0 && int(i) != fSingleShiftedBeam) continue; static NCEventInfo backup; // Suspect that construction is expensive backup.DeepCopy(&eventInfo); fEventInfo = eventInfo; beamInfo.SetSystShifts(useParameters[i], &adjustedValues[i][0]); if(FinalEventCheck()){ for(unsigned int j = 0; j < fExtrapolations.size(); ++j){ // This function applies weight and syst shifts too to the // object (that it happens to ~ own) fEventInfo.SetEventWeight(useParameters[i], adjustedValues[i], noosc, 0, runType, true, false); fEventInfo.reco->weight *= GetMCScaleFactor(det, fileType, beamInfo); // SetEventWeight will (indirectly) have altered nuEnergy and // showerEnergy, so make sure they're set right SetEnergies(); fExtrapolations[j]->AddEvent(eventInfo, useMCAsData, fileType, beamInfo); } } eventInfo.DeepCopy(&backup); } // end for i delete noosc; }

void NCExtrapolationModule::ApplySystematicShifts (  NC::RunUtil::ERunType  runType  )  [private]

Apply systematic shifts to fEventInfo appropriate to when it is being used as fake data Definition at line 729 of file NCExtrapolationModule.cxx. References fEventInfo, fTrueOscPars, NCEventInfo::reco, NCEventInfo::SetEventWeight(), SystematicsFromRegistry(), and ANtpRecoInfo::weight. Referenced by SetEventWeight(). { static bool systematicsToUse[NCType::kNumSystematicParameters]; static vector<double> systematicsAdjust; static bool once = true; if(once){ once = false; SystematicsFromRegistry(systematicsToUse, systematicsAdjust); } // always use the nue values when finding the event weight because // the size of the nue contrib is passed in by the macro fEventInfo.SetEventWeight(systematicsToUse, systematicsAdjust, fTrueOscPars, 0, runType, true, true); if(TMath::Abs(fEventInfo.reco->weight) < 5.e-2 && fEventInfo.reco->weight < 0.) fEventInfo.reco->weight = 0.; }

void NCExtrapolationModule::Config (  const Registry &  r  )

Definition at line 431 of file NCExtrapolationModule.cxx. References NCType::BeamListFromString(), NCPOTCounter::Config(), NCType::EExtraction, NCType::EOscModel, fBeamIndex, fConfig, fDataMCPath, fExtractionType, fExtrapolationsList, fFileName, fIncludeDataFromLoadedExtrapolations, fLoadExtrapolationsFile, fMakeDQPlotsSpecial, fMockExperimentsSeed, fNumMockExperiments, fOscillationModel, fPIDCustomCut, fPOTCount, fRunsToUse, fSaveExtrapolationsFile, fShiftedBeams, fSimpleShiftedBeams, fSingleShiftedBeam, fSingleSpectrum, fTrueOscPars, fUseMCAsData, fUseMockData, fUsePIDCustomCut, Registry::Get(), gSystem(), and NC::Utility::ParseNumberList(). Referenced by run(). { fConfig = r; int tmpb; // a temp bool. int tmpi; // a temp int. double tmpd; // a temp double. const char* tmps; // a temp string if (r.Get("DataMCPath", tmps)){ //for some reason the TSystemDirectory constructor can't resolve //environmental variables, so just take care of it here TString temp = tmps; // Assume the form $ENVVAR/path if(temp.Contains("$")){ int pos = temp.Index("/"); // find the first / temp.Resize(pos); // and truncate at it temp.Remove(TString::kLeading, '$'); // drop the $ off the front fDataMCPath = tmps; // Copy the original string // and then replace the part that we think is the environment variable fDataMCPath.Replace(0, pos, gSystem->Getenv(temp)); } else fDataMCPath = temp; // Add a trailing slash so that concatenating the path later will work if(!fDataMCPath.EndsWith("/")) fDataMCPath += "/"; } if(r.Get("FileName", tmps)) fFileName = tmps; if(r.Get("OscillationModel", tmpi)) fOscillationModel = NCType::EOscModel(tmpi); if(r.Get("UseMCAsData", tmpb)) fUseMCAsData = tmpb; if(r.Get("ExtractionType", tmpi)) fExtractionType = NCType::EExtraction(tmpi); if(r.Get("SingleSpectrum", tmpb)) fSingleSpectrum = tmpb; if(r.Get("ExtrapolationsList", tmps)) fExtrapolationsList = tmps; if(r.Get("UseMockData", tmpb)) fUseMockData = tmpb; if(r.Get("UsePIDCustomCut", tmpb)) fUsePIDCustomCut = tmpb; if(r.Get("PIDCustomCut", tmpd)) fPIDCustomCut = tmpd; if(r.Get("MakeShiftedBeams", tmpb)) fShiftedBeams = tmpb; if(r.Get("ShiftedBeamsSimpleOnly", tmpb)) fSimpleShiftedBeams = tmpb; if(r.Get("SingleShiftedBeam", tmpi)) fSingleShiftedBeam = tmpi; if(r.Get("RunsToUse", tmps)){ fRunsToUse.clear(); vector<int> runs = NC::Utility::ParseNumberList(tmps); for(unsigned int n = 0; n < runs.size(); ++n) fRunsToUse.push_back(NC::RunUtil::ERunType(runs[n])); } if(r.Get("NumMockExperiments", tmpi)) fNumMockExperiments = tmpi; if(r.Get("MockExperimentsSeed", tmpi)) fMockExperimentsSeed = tmpi; if(r.Get("LoadExtrapolationsFile", tmps)) fLoadExtrapolationsFile = tmps; if(r.Get("IncludeDataFromLoadedExtrapolations", tmpb)) fIncludeDataFromLoadedExtrapolations = tmpb; if(r.Get("SaveExtrapolationsFile", tmps)) fSaveExtrapolationsFile = tmps; if(r.Get("MakeDQPlotsSpecial", tmpb)) fMakeDQPlotsSpecial = tmpb; assert(sizeof(NC::OscProb::OscPars*) == sizeof(int)); if(r.Get("OscPars", tmpi)) fTrueOscPars = (NC::OscProb::OscPars*)(tmpi); if (r.Get("BeamType", tmps)) fBeamIndex = NCType::BeamListFromString(tmps); fPOTCount->Config(r, fBeamIndex, fRunsToUse); }

void NCExtrapolationModule::CreateExtrapolations (  TString  extrapolations  )  [private]

Takes a space separated string of NCExtrapolation code names and adds the relevant objects to fExtrapolations Definition at line 911 of file NCExtrapolationModule.cxx. References NCExtrapolationFactory::Create(), fExtrapolations, fLoadExtrapolationsFile, NCExtrapolationFactory::GetCodeName(), GetExtrapolationFactories(), MSG, NC::Utility::ParseStringList(), and NCExtrapolation::Reset(). Referenced by Run(). { MSG("NCExtrapolationModule", Msg::kInfo) << "Registered extrapolations:\n"; const vector<TString> extrapArgNames = NC::Utility::ParseStringList(extraps); for(unsigned int n = 0; n < GetExtrapolationFactories().size(); ++n){ NCExtrapolationFactory* ex = GetExtrapolationFactories()[n]; const TString codeName = ex->GetCodeName(); MSG("NCExtrapolationModule", Msg::kInfo) << " " << codeName << " - "; bool inExtraps = false; for(unsigned int i = 0; i < extrapArgNames.size(); ++i) if(extrapArgNames[i] == codeName) inExtraps = true; if(inExtraps){ if(fLoadExtrapolationsFile != ""){ MSG("NCExtrapolationModule", Msg::kInfo) << "Loading from file\n"; TDirectory* curDir = gDirectory; TFile f(fLoadExtrapolationsFile); NCExtrapolation* e = (NCExtrapolation*)f.Get("NCExtrapolation"+codeName); assert(e); fExtrapolations.push_back(e); f.Close(); curDir->cd(); // Restoring data spectra from the file is not generally useful. if(!fIncludeDataFromLoadedExtrapolations) e->Reset(true, true, false, false); } else{ MSG("NCExtrapolationModule", Msg::kInfo) << "Creating\n"; fExtrapolations.push_back(ex->Create()); } // end if fLoadExtrapolationsFile } else{ MSG("NCExtrapolationModule", Msg::kInfo) << "Not creating\n"; } // end if inExtraps } // end for n }

TH1 * NCExtrapolationModule::CreateSpecialPlot (  int  k, TString  type )  const [private]

Duplicate sufficient logic from NCDataQualityPlot so that fDQNearMCTotalSpecial can be created - breaking circular dependency with DataQuality Definition at line 75 of file NCExtrapolationModule.cxx. References kDQVars. Referenced by NCExtrapolationModule(). { assert(k >= 3 && k < 6); // Definition of a data quality plot: name, title, binning struct DQDef { // Order of elements is important, this is how we are initialised TString name; TString title; int bins; double start; double end; }; const DQDef kDQVars[6] = { {"?", "?", -1, -1, -1}, {"?", "?", -1, -1, -1}, {"?", "?", -1, -1, -1}, {"eventLength", "Event Length (planes)", 50, 0, 500}, {"numTracks", "Number of Tracks", 10, 0, 10}, {"trackExtension", "Track Extension (planes)", 50, -30, 20} }; TH1* ret = new TH1D(kDQVars[k].name+type, "", kDQVars[k].bins, kDQVars[k].start, kDQVars[k].end); ret->GetXaxis()->SetTitle(kDQVars[k].title); ret->GetYaxis()->SetTitle("Events"); ret->GetXaxis()->CenterTitle(); ret->GetYaxis()->CenterTitle(); return ret; }

const Registry & NCExtrapolationModule::DefaultConfig (   )  const

Definition at line 359 of file NCExtrapolationModule.cxx. References Plot::Format(), GetExtrapolationFactories(), Registry::LockValues(), Registry::Merge(), Registry::Set(), and Registry::UnLockValues(). Referenced by run(). { static Registry r; r.UnLockValues(); r.Set("DataMCPath", "dataFiles/*.root"); r.Set("FarDataPath", "dataFiles/*.root"); r.Set("FileName", "extrapolationFile.root"); r.Set("OscillationModel", NCType::kSterileFraction); r.Set("UseMCAsData", false); r.Set("SplitMC", false); r.Set("SplitMCSeed", -1); r.Set("ExtractionType", NCType::kNCCCExtractionCuts); r.Set("SingleSpectrum", false); r.Set("ExtrapolationsList", ""); r.Set("BeamType", "L010z185i"); r.Set("UseMockData", false); r.Set("MockDataSet", "F21910001"); TString runsToUse; for(int n = 0; n <= NC::RunUtil::kMaxRun; ++n) runsToUse += TString::Format("%d ", n); r.Set("RunsToUse", runsToUse); r.Set("OscPars", 0); r.Set("NumMockExperiments", 0); r.Set("MockExperimentsSeed", 0); r.Set("LoadExtrapolationsFile", ""); r.Set("IncludeDataFromLoadedExtrapolations", false); r.Set("SaveExtrapolationsFile", ""); r.Set("MakeDQPlotsSpecial", false); // Get the default configurations for all the registered extrapolations vector<NCExtrapolationFactory*> facts = GetExtrapolationFactories(); for(unsigned int n = 0; n < facts.size(); ++n) r.Merge(facts[n]->DefaultConfig()); //PID sensitivity study r.Set("UsePIDCustomCut", false); r.Set("PIDCustomCut", 0.0); r.Set("MakeShiftedBeams", false); r.Set("ShiftedBeamsSimpleOnly", false); r.Set("SingleShiftedBeam", -1); //set the defaults for the systematic parameters //set them all off for fitting and changing mc by default TString adjust = "Adjust"; TString mcAsData = "ChangeMCAsData"; TString fit = "Fit"; for(int i = 0; i < NCType::kNumSystematicParameters; ++i){ r.Set(NCType::kParams[i].name, false); r.Set(mcAsData + NCType::kParams[i].name, false); r.Set(adjust + NCType::kParams[i].name, 0); // measured in sigma r.Set(fit + NCType::kParams[i].name, false); } // Add all the configuration that NCExtrapolation knows how to read r.Merge(NCExtrapolation::DefaultConfig()); r.Merge(NC::FitMaster::DefaultConfig()); r.Merge(NC::EventAdderDefaultConfig()); r.LockValues(); return r; }

void NCExtrapolationModule::DoMockExperiments (   )  [private]

Definition at line 627 of file NCExtrapolationModule.cxx. References NCEventInfo::beam, ANtpBeamInfo::beamType, fEventInfo, fExtrapolations, fFDMCSample, NCExtrapolation::FindChiSqrForPars(), fMockExperimentsSeed, fMockFits, fTrueOscPars, NC::FitMaster::GetBestFitPointAsRegistry(), MSG, NC::FitMaster::Prepare(), NCEventInfo::reco, reg, NC::FitMaster::Run(), s(), Registry::Set(), NC::FitMaster::SetFixedValuesForMarginalization(), and ANtpRecoInfo::weight. Referenced by Run(). { if(fMockExperimentsSeed == 0) MSG("NCExtrapolationModule", Msg::kWarning) << "DoMockExperiments: random seed not set, using default (0)" << endl; TRandom3 r; for(int n = 0; n < fNumMockExperiments; ++n){ // Reset everyone's FD data for(unsigned int i = 0; i < fExtrapolations.size(); ++i) fExtrapolations[i]->Reset(false, true, false, false); r.SetSeed(fMockExperimentsSeed); r.SetSeed(n+r.Integer(UInt_t(-1))); for(unsigned int n = 0; n < fFDMCSample.size(); ++n){ NCEventInfo* s = fFDMCSample[n]; for(unsigned int i = 0; i < fExtrapolations.size(); ++i){ double tmp_weight = s->reco->weight; s->reco->weight = r.Poisson(s->reco->weight); // Is this way faster? // s->reco->weight = (s->reco->weight > r.Uniform()) ? 1 : 0; BeamType::BeamType_t beamType = (BeamType::BeamType_t)(fEventInfo.beam->beamType); NCBeam::Info beamInfo(beamType, NC::RunUtil::kRunI); if(s->reco->weight){ fExtrapolations[i]->AddEvent(*s, true, NCType::kBeamFile, // TODO is kBeamFile right? beamInfo); } s->reco->weight = tmp_weight; }//end loop over extrapolation objects } for(unsigned int i = 0; i < fExtrapolations.size(); ++i){ NCExtrapolation* extrap = fExtrapolations[i]; // extrap->CombineRuns(Detector::kFar); NC::FitMaster fm(extrap); Registry r = fConfig; // Counteract the "preciseParams" scaling normally done in the // initial fit. This is a bit ugly, would be better to disable the // scaling instead of fighting it. // Changed my mind, we need to be fair to the real fit // r.UnLockValues(); // r.Set("PrecScale", 0.01); fm.Prepare(r); fm.SetFixedValuesForMarginalization(fTrueOscPars); fm.Run(0); const double trueChi = extrap->FindChiSqrForPars(fTrueOscPars, NC::SystPars()); // Slight problem here in that we don't distinguish which extrapolation // this result came from, so there's no way to tell in the output file. // Isn't a problem if you only run one extrapolation, which is the common // use case. Registry* reg = fm.GetBestFitPointAsRegistry(); reg->Set("true_chisq", trueChi); fMockFits.push_back(reg); } } }

void NCExtrapolationModule::DrawDataQualityPlots (   )  [private]

Definition at line 143 of file NCExtrapolationModule.cxx. References DrawDataQualityPlotsSpecial(). Referenced by Run(). { // get a pointer to the current directory // this is one of the output files TDirectory* saveDir = gDirectory; //loop over the data quality histograms //make folders for data/mc and subfolders for near/far TDirectory* dir = saveDir->mkdir("DataQuality", "DataQuality"); dir->cd(); TDirectory* near = dir->mkdir("NearDetector", "NearDetector"); near->cd(); if(fMakeDQPlotsSpecial) DrawDataQualityPlotsSpecial(); saveDir->cd(); }

void NCExtrapolationModule::DrawDataQualityPlotsSpecial (   )  [private]

Definition at line 164 of file NCExtrapolationModule.cxx. References fDQNearMCTotalSpecial. Referenced by DrawDataQualityPlots(). { for(int dist = 0; dist < 3; ++dist){ fDQNearMCTotalSpecial[dist]->Write(); TString canvName = fDQNearMCTotalSpecial[dist]->GetName(); // int index = canvName.Index("MC"); canvName += "Canv"; TCanvas *canv = new TCanvas(canvName, canvName, 150, 10, 900, 600); TLegend *leg = new TLegend(0.75, 0.75, 0.95, 0.95); leg->SetBorderSize(0); fDQNearMCTotalSpecial[dist]->Draw(""); leg->AddEntry(fDQNearMCTotalSpecial[dist], "MC Total", "l"); leg->Draw(); gDirectory->Append(canv); }//end loop over dists }

void NCExtrapolationModule::ExtrapolateNearToFar (   )  [private]

Add the FD events to the extrapolations and run the fit for each one. Definition at line 596 of file NCExtrapolationModule.cxx. References fConfig, fExtrapolations, fFitMasters, fTrueOscPars, MSG, NC::FitMaster::Prepare(), and NC::FitMaster::Run(). Referenced by Run(). { /* const bool loadingExtrapolations = fLoadExtrapolationsFile != ""; // Ugh - should instead break this function down so we can select parts of it if(fLoadExtrapolationsFile != ""){ for(unsigned int i = 0; i < fExtrapolations.size(); ++i){ NC::FitMaster* fm = new NC::FitMaster(fExtrapolations[i]); fm->Prepare(fConfig); fm->Run(fTrueOscPars); fFitMasters.push_back(fm); } return; } */ MSG("NCExtrapolationModule", Msg::kInfo) << "ExtrapolateNearToFar" << endl; //predict the far detector and make sure to combine any running conditions for(unsigned int i = 0; i < fExtrapolations.size(); ++i){ fExtrapolations[i]->DoneFilling(); NC::FitMaster* fm = new NC::FitMaster(fExtrapolations[i]); fm->Prepare(fConfig); fm->Run(fTrueOscPars); fFitMasters.push_back(fm); } }

void NCExtrapolationModule::FillDataQualityPlotsSpecial (  std::vector< TH1 * > &  dq, bool  osc )  [private]

Definition at line 531 of file NCExtrapolationModule.cxx. References ANtpHeaderInfo::detector, ANtpRecoInfo::eventLength, fEventInfo, NC::RunUtil::FindRunType(), NCEventInfo::header, ANtpRecoInfo::inFiducialVolume, ANtpRecoInfo::isSimpleCutsClean, kDQEventLength, kDQNumTracks, kDQTrackExtension, ANtpRecoInfo::numberTracks, NCEventInfo::reco, ANtpRecoInfo::showerEnergyNC, ANtpRecoInfo::trackExtension, ANtpRecoInfo::weight, ANtpRecoInfo::weightRunII, and ANtpRecoInfo::weightRunIII. Referenced by AddEventToExtrapolations(). { osc=false; //dont bother with events outside the fiducial volume if(fEventInfo.reco->inFiducialVolume < 1) return; double weight; switch(NC::RunUtil::FindRunType(fEventInfo.header)){ case NC::RunUtil::kRunI: weight=fEventInfo.reco->weight; break; case NC::RunUtil::kRunII: weight=fEventInfo.reco->weightRunII; break; case NC::RunUtil::kRunIII: weight=fEventInfo.reco->weightRunIII; break; default: assert(0 && "Unknown runtype"); } double trackExtension = -1.*fEventInfo.reco->trackExtension; double showerEnergy = fEventInfo.reco->showerEnergyNC; if(fEventInfo.header->detector == int(Detector::kNear) && fEventInfo.reco->isSimpleCutsClean< 1 ) return; dq[kDQEventLength-3]->Fill(fEventInfo.reco->eventLength, weight); dq[kDQNumTracks-3]->Fill(fEventInfo.reco->numberTracks, weight); if(fEventInfo.reco->numberTracks > 0 && fEventInfo.reco->trackExtension > -9000. && showerEnergy > 0.0) dq[kDQTrackExtension-3]->Fill(trackExtension, weight); // cout << "Weight: " << weight << endl // << "eventLength: " << fEventInfo.reco->eventLength // << " histo: " << dq[0]->GetBinContent(15) << endl // << "NumTracks: " << fEventInfo.reco->numberTracks // << " histo: " << dq[1]->GetBinContent(2) << endl // << "TrackExtension: " << trackExtension << " " << showerEnergy // << " histo: " << dq[2]->GetBinContent(30) << endl // << endl; }

bool NCExtrapolationModule::FinalEventCheck (   )  [private]

any last checks. Definition at line 900 of file NCExtrapolationModule.cxx. References fEventInfo, NCEventInfo::FinalEventCheck(), NCEventInfo::header, and ANtpHeaderInfo::isGoodData. Referenced by AddEventToExtrapolations(), and AddShiftedEventToExtrapolations(). { //check any final cuts here if(!fEventInfo.FinalEventCheck() && !fSingleSpectrum) return false; return fEventInfo.header->isGoodData; }

std::vector< NCExtrapolationFactory * > & NCExtrapolationModule::GetExtrapolationFactories (   )  [static, private]

The various extrapolations that have registered themselves. Definition at line 1217 of file NCExtrapolationModule.cxx. Referenced by AddExtrapolation(), CreateExtrapolations(), and DefaultConfig(). { // Looks like we were falling foul of some variant of the // "static initialization order fiasco". Apply the workaround from // http://www.parashift.com/c++-faq-lite/ctors.html#faq-10.13 static std::vector<NCExtrapolationFactory*> facts; return facts; }

void NCExtrapolationModule::GetListOfShifts (  std::vector< bool * > &  useParameters, std::vector< std::vector< double > > &  adjustedValues )  const [private]

Return descriptions for all the different combinations of systematically shifted beam required by AddShiftedEventToExtrapolations Definition at line 1089 of file NCExtrapolationModule.cxx. References fConfig, fSimpleShiftedBeams, NC::CoordinateConverter::IsFit(), and NC::CoordinateConverter::Prepare(). Referenced by AddShiftedEventToExtrapolations(). { assert(useParameters.empty() && adjustedValues.empty()); // This allows us to find out if a particular variable is in the fit NC::CoordinateConverter cc; cc.Prepare(fConfig, true); // First work out all the combinations of systematics we need. We use // every combination of nominal and plus/minus one sigma. ie we should // add each event 3^n-1 times (we don't do the completely nominal case) // We start with the nominal arrangement - ie no shifts enabled, and all // set to their default values useParameters.resize(1); adjustedValues.resize(1); useParameters[0] = new bool[NCType::kNumSystematicParameters]; adjustedValues[0].resize(NCType::kNumSystematicParameters); for(int n = 0; n < NCType::kNumSystematicParameters; ++n){ useParameters[0][n] = false; adjustedValues[0][n] = NCType::kParams[n].defaultVal; } // For every possible systematic for(unsigned int syst = 0; syst < NCType::kNumSystematicParameters; ++syst){ // We check if we're fitting for it if(!cc.IsFit(NCType::EFitParam(syst))) continue; // and if so, duplicate all the configurations we have so far in two // more modes, for plus/minus one sigma in this new parameter. // If the option for simple shifted beams is on then we only base our // shifting on the nominal beam -> 2n shifted beams const unsigned int N = fSimpleShiftedBeams ? 1 : useParameters.size(); for(unsigned int n = 0; n < N; ++n){ bool* up = new bool[NCType::kNumSystematicParameters]; for(int i = 0; i < NCType::kNumSystematicParameters; ++i) up[i] = useParameters[n][i]; vector<double> av = adjustedValues[n]; up[syst] = true; av[syst] -= NCType::kParams[syst].sigma; useParameters.push_back(up); adjustedValues.push_back(av); // Add twice the shift to cancel out the previous shift the other way av[syst] += 2*NCType::kParams[syst].sigma; useParameters.push_back(up); adjustedValues.push_back(av); } } // Remove the nominal case that we started with delete[] useParameters[0]; useParameters.erase(useParameters.begin()); adjustedValues.erase(adjustedValues.begin()); // Check that we didn't lose track somewhere assert(useParameters.size() == adjustedValues.size()); }

double NCExtrapolationModule::GetMCScaleFactor (  Detector::Detector_t  det, NCType::EFileType  fileType, NCBeam::Info  info )  [private]

Get the factor to scale the MC by to match the data. Will be zero for beams which have no data. The rationale for the default value is to allow a check (in AddEventToExtrapolations) to ensure that the MC beams that have events added to them are the ones that were selected in the RunsToUse registry key *and* have data available Definition at line 789 of file NCExtrapolationModule.cxx. References GetScaleFactorFromMaps(), POTMap, and NCBeam::Info::SetSystShifts(). Referenced by AddShiftedEventToExtrapolations(), and SetEventWeight(). { // Choose the appropriate pot maps for this event and scale // down the event to match the data POT. POTMap* potData=0; POTMap* potMC=0; switch(det){ case Detector::kNear: potData=&fDataPOTNear; potMC=&fMCPOTNear; break; case Detector::kFar: potData=&fDataPOTFar; switch(fileType){ case NCType::kTauFile: potMC=&fMCPOTFarTau; break; case NCType::kElectronFile: potMC=&fMCPOTFarElectron; break; default: potMC=&fMCPOTFar; } break; default: assert(0 && "Unknown detector. This shouldn't happen"); } double tmp=GetScaleFactorFromMaps(*potData, *potMC, info); if(tmp>0) return tmp; // ...otherwise try to find the same beam with no syst shifts const vector<NCType::EFitParam> adj; const vector<double> vals; info.SetSystShifts(adj, vals); return GetScaleFactorFromMaps(*potData, *potMC, info); }

double NCExtrapolationModule::GetScaleFactorFromMaps (  POTMap &  potData, POTMap &  potMC, NCBeam::Info  info )  [private]

Helper for GetMCScaleFactor. Gets the MC scale factor for beam info from the maps potData and potMC. Tries the nominal (no systematics) beam if not found, and asserts if there is data for this beam but no MC Definition at line 831 of file NCExtrapolationModule.cxx. References MSG. Referenced by GetMCScaleFactor(). { // See if we actually found the beam in both... const bool foundData = potData.find(info) != potData.end(); const bool foundMC = potMC.find(info) != potMC.end(); // If we have data POTs for this beam, we'd better have some MC to go with it. if(foundData && !foundMC){ MSG("NCExtrapolationModule", Msg::kError) << "Found data POT but not MC for " << info << endl; MSG("NCExtrapolationModule", Msg::kError) << "Data POTs: " << endl; for(POTMap::iterator it=potData.begin(); it!=potData.end(); ++it) MSG("NCExtrapolationModule", Msg::kError) << it->first << ": " << it->second << endl; MSG("NCExtrapolationModule", Msg::kError) << "MC POTs: " << endl; for(POTMap::iterator it=potMC.begin(); it!=potMC.end(); ++it) MSG("NCExtrapolationModule", Msg::kError) << it->first << ": " << it->second << endl; exit(1); } // If we have no data, return 0; if(!foundData) return 0; // Otherwise return the actual scale factor return potData.find(info)->second/potMC.find(info)->second; }

void NCExtrapolationModule::PrepareForExtrapolation (   )  [private]

Prepare all extrapolation objects by passing the config Registry to them and adding the near detector events from the chains passed Definition at line 581 of file NCExtrapolationModule.cxx. References fConfig, fExtrapolations, and MSG. Referenced by Run(). { MSG("NCExtrapolationModule", Msg::kInfo) << "PrepareForExtrapolation" << endl; //pass the module registry into the extrapolations to prepare them for(unsigned int i = 0; i < fExtrapolations.size(); ++i) fExtrapolations[i]->Prepare(fConfig); }

void NCExtrapolationModule::Run (   )

Definition at line 188 of file NCExtrapolationModule.cxx. References NC::IEventAdder::AddEvents(), AddFilesToChain(), ChainMap, CreateExtrapolations(), DoMockExperiments(), DrawDataQualityPlots(), NC::EventAdderBuilder(), ExtrapolateNearToFar(), fBeamIndex, fConfig, fDataPOTFar, fDataPOTNear, fEventInfo, fExtrapolations, fExtrapolationsList, fFileName, fFitMasters, fMCPOTFar, fMCPOTFarElectron, fMCPOTFarTau, fMCPOTNear, fMockFits, fNumMockExperiments, fPOTCount, fRunsToUse, fSaveExtrapolationsFile, fTrueOscPars, fUseMCAsData, fUseMockData, MSG, PrepareForExtrapolation(), Registry::Print(), runPeriod, NCEventInfo::SetChainBranches(), and NCPOTCounter::SetPOTValues(). Referenced by run(). { fConfig.Print(); // Print out the configuration in use. assert(fTrueOscPars); //get the pot for the different beams const NCType::EFileType fileType = fUseMockData ? NCType::kMockFile : NCType::kBeamFile; //use following map for FD MC fPOTCount->SetPOTValues(fDataPOTNear, Detector::kNear, NCType::kBeamFile, NCType::kData); fPOTCount->SetPOTValues(fMCPOTNear, Detector::kNear, NCType::kBeamFile, NCType::kMC); fPOTCount->SetPOTValues(fDataPOTFar, Detector::kFar, fileType, NCType::kData); fPOTCount->SetPOTValues(fMCPOTFar, Detector::kFar, NCType::kBeamFile, NCType::kMC); fPOTCount->SetPOTValues(fMCPOTFarTau, Detector::kFar, NCType::kTauFile, NCType::kMC); fPOTCount->SetPOTValues(fMCPOTFarElectron, Detector::kFar, NCType::kElectronFile, NCType::kMC); MSG("NCExtrapolationModule", Msg::kInfo) << "Done setting POT values" << endl; ChainMap dataND; ChainMap mcND; ChainMap dataFD; ChainMap mcFD; ChainMap mcTauFD; ChainMap mcElectronFD; // The beamtype/runperiod pairs we're using vector<NCBeam::Info> infos; for(unsigned int bidx = 0; bidx < fBeamIndex.size(); ++bidx){ const BeamType::BeamType_t bt = fBeamIndex[bidx]; for(unsigned int runPidx=0; runPidx < fRunsToUse.size(); ++runPidx){ const NC::RunUtil::ERunType runPeriod = fRunsToUse[runPidx]; const NCBeam::Info info(bt, runPeriod); infos.push_back(info); } } for(unsigned int i=0; i<infos.size(); ++i){ NCBeam::Info info=infos[i]; dataND[info] = new TChain("uDST"); mcND[info] = new TChain("uDST"); dataFD[info] = new TChain("uDST"); mcFD[info] = new TChain("uDST"); mcTauFD[info] = new TChain("uDST"); mcElectronFD[info] = new TChain("uDST"); } AddFilesToChain(dataND, Detector::kNear, NCType::kBeamFile, NCType::kData); AddFilesToChain(mcND, Detector::kNear, NCType::kBeamFile, NCType::kMC); AddFilesToChain(dataFD, Detector::kFar, fileType, NCType::kData); AddFilesToChain(mcFD, Detector::kFar, NCType::kBeamFile, NCType::kMC); AddFilesToChain(mcTauFD, Detector::kFar, NCType::kTauFile, NCType::kMC); AddFilesToChain(mcElectronFD, Detector::kFar, NCType::kElectronFile, NCType::kMC); const TString ext = NCType::kExtractionNames[fExtractionType]; for(unsigned int i=0; i<infos.size(); ++i){ NCBeam::Info info=infos[i]; fEventInfo.SetChainBranches(dataND[info], ext, fUseMCAsData); fEventInfo.SetChainBranches(dataFD[info], ext, fUseMCAsData); fEventInfo.SetChainBranches(mcND[info], ext, true); fEventInfo.SetChainBranches(mcFD[info], ext, true); fEventInfo.SetChainBranches(mcTauFD[info], ext, true); fEventInfo.SetChainBranches(mcElectronFD[info], ext, true); } CreateExtrapolations(fExtrapolationsList); PrepareForExtrapolation(); NC::IEventAdder* eventAdder = NC::EventAdderBuilder(fConfig); for(unsigned int i=0; i<infos.size(); ++i){ NCBeam::Info info=infos[i]; eventAdder->AddEvents(this, &fEventInfo, dataND[info], mcND[info], dataFD[info], mcFD[info], mcTauFD[info], mcElectronFD[info]); } delete eventAdder; ExtrapolateNearToFar(); if(fNumMockExperiments > 0) DoMockExperiments(); //make a file and the trees to go into the file MSG("NCExtrapolationModule", Msg::kInfo) << "fFileName = " << fFileName << endl; TFile ntpFile(fFileName, "RECREATE"); ntpFile.cd(); for(unsigned int k = 0; k < fExtrapolations.size(); ++k){ TDirectory* saveDir = gDirectory; TString plotName = "plots"+fExtrapolations[k]->GetShortName(); TDirectory* newDir = gDirectory->mkdir(plotName, plotName); // In case we failed to make the new directory then this way // probably gives us the best chance of rescuing the plots if(newDir) newDir->cd(); fFitMasters[k]->WriteResources(); if(newDir) newDir->cd(); fExtrapolations[k]->WriteResources(fTrueOscPars); saveDir->cd(); } if(!fUseMCAsData && !fUseMockData) DrawDataQualityPlots(); ntpFile.cd(); fConfig.SetName("config_registry"); fConfig.Write(); if(!fMockFits.empty()){ ntpFile.cd(); gDirectory->mkdir("mock_expts")->cd(); for(unsigned int n = 0; n < fMockFits.size(); ++n){ Registry* r = fMockFits[n]; r->SetName(TString::Format("expt_%d", n)); r->Write(); } ntpFile.cd(); } MSG("NCExtrapolationModule", Msg::kInfo) << "Writing Final File!" << endl; ntpFile.Write(); ntpFile.Close(); if(fSaveExtrapolationsFile != ""){ TFile saveFile(fSaveExtrapolationsFile, "RECREATE"); for(unsigned int k = 0; k < fExtrapolations.size(); ++k) fExtrapolations[k]->Write(); saveFile.Close(); } }

void NCExtrapolationModule::SetEnergies (   )  [private]

Set reco.nuEnergy and reco.showerEnergy to the appropriate NC or CC variant. Definition at line 751 of file NCExtrapolationModule.cxx. References NCEventInfo::analysis, fEventInfo, ANtpAnalysisInfo::isCC, ANtpAnalysisInfo::isNC, ANtpRecoInfo::nuEnergy, ANtpRecoInfo::nuEnergyCC, ANtpRecoInfo::nuEnergyNC, NCEventInfo::reco, NCEventInfo::reco_nom, ANtpRecoInfo::showerEnergy, ANtpRecoInfo::showerEnergyCC, and ANtpRecoInfo::showerEnergyNC. Referenced by AddEventToExtrapolations(), AddShiftedEventToExtrapolations(), and SetEventWeight(). { if(fEventInfo.analysis->isCC > 0){ // The RHSs here *should* be reco and not reco_nom, because we // want the shifted value of (nu|shower)EnergyCC if it has been // shifted fEventInfo.reco->nuEnergy = fEventInfo.reco->nuEnergyCC; fEventInfo.reco->showerEnergy = fEventInfo.reco->showerEnergyCC; // We need to do this because (inter alia) the calculation of the // ND cleaning syst relies on showerEnergy being set to the right // one. We're safe from considerations of whether things have been // systematically shifted because reco_nom is never systematically // shifted fEventInfo.reco_nom->nuEnergy = fEventInfo.reco_nom->nuEnergyCC; fEventInfo.reco_nom->showerEnergy = fEventInfo.reco_nom->showerEnergyCC; } else if(fEventInfo.analysis->isNC > 0){ fEventInfo.reco->nuEnergy = fEventInfo.reco->showerEnergyNC; fEventInfo.reco->showerEnergy = fEventInfo.reco->showerEnergyNC; // See comment above fEventInfo.reco_nom->nuEnergy = fEventInfo.reco_nom->nuEnergyNC; fEventInfo.reco_nom->showerEnergy = fEventInfo.reco_nom->showerEnergyNC; // (PAR) This used to be set here, but that breaks FindEventWeight // for NC events if we're using CC energy for those. But // NCExtrapolation::DrawBestFitSpectra relies on (shower+track) // giving the NC or CC energy appropriate to the classification, // so setting track energy to zero is now done in NCEnergyBin::AddEventToBin //fEventInfo.reco->muEnergy = 0.; } // Energies < 0 occur when there's no shower and we get a default value if(fEventInfo.reco->showerEnergy < 0.) fEventInfo.reco->showerEnergy = 0.; }

void NCExtrapolationModule::SetEventWeight (  BeamType::BeamType_t  beamType, NC::RunUtil::ERunType  runType, bool  fakeDataSet )  [private]

Set the event weight appropriately for its type and run, including scaling MC to match the data POTs. If fakeDataSet is true, also apply systematic shifts and rescaling appropriate to fake data Definition at line 865 of file NCExtrapolationModule.cxx. References ApplySystematicShifts(), ANtpHeaderInfo::dataType, det, ANtpHeaderInfo::detector, Detector::Detector_t, fEventInfo, NCType::FindFileType(), GetMCScaleFactor(), NCEventInfo::GetSKZPWeight(), NCEventInfo::header, NCEventInfo::reco, SetEnergies(), SimFlag::SimFlag_t, and ANtpRecoInfo::weight. Referenced by AddEventToExtrapolations(). { Detector::Detector_t det = Detector::Detector_t(fEventInfo.header->detector); SimFlag::SimFlag_t sim = SimFlag::SimFlag_t(fEventInfo.header->dataType); NCType::EFileType fileType = NCType::FindFileType(fEventInfo.header); // Data events don't get scaled or systematically shifted if(sim==SimFlag::kData){ SetEnergies(); return; } else if(sim==SimFlag::kMC){ if(fakeDataSet){ // This includes SKZP via NCEventInfo::GetEventWeight ApplySystematicShifts(runType); } else{ // Just apply the SKZP weight fEventInfo.reco->weight=fEventInfo.GetSKZPWeight(runType); } const NCBeam::Info info=NCBeam::Info(beamType, runType); fEventInfo.reco->weight *= GetMCScaleFactor(det, fileType, info); // ApplySystematicShifts will (indirectly) have altered nuEnergy and // showerEnergy, so make sure they're set right SetEnergies(); } else{ assert(0 && "This shouldn't happen"); } }

void NCExtrapolationModule::SetMCExposureForBeam (  NCBeam::Info  beam, double  pot )

Definition at line 353 of file NCExtrapolationModule.cxx. References fPOTCount, and NCPOTCounter::SetMCExposureForBeam(). Referenced by set_mc_exposure_for_beam(). { fPOTCount->SetMCExposureForBeam(beam, pot); }

void NCExtrapolationModule::SystematicsFromRegistry (  bool *  systematicsToUse, std::vector< double > &  systematicsAdjust )  [private]

Definition at line 699 of file NCExtrapolationModule.cxx. References fConfig, Registry::Get(), and MAXMSG. Referenced by ApplySystematicShifts(). { //get the parameters to be altered int tmpb; // a temp bool. See comment under DefaultConfig... double tmpd; // a temp double. //set the defaults for the systematic parameters from the config //set the adjustment to be an actual value, the macro should have //passed in a number of sigma for(int i = 0; i < NCType::kNumSystematicParameters; ++i){ if(fConfig.Get("ChangeMCAsData" + NCType::kParams[i].name, tmpb)) systematicsToUse[i] = tmpb; if(fConfig.Get("Adjust" + NCType::kParams[i].name, tmpd)) systematicsAdjust.push_back(NCType::kParams[i].defaultVal + tmpd*NCType::kParams[i].sigma); if(systematicsToUse[i]){ MAXMSG("NCExtrapolationModule", Msg::kInfo, NCType::kNumSystematicParameters) << "Using MC As Data: " << NCType::kParams[i].name << " adjusted to " << systematicsAdjust[i] << endl; } } }

---

Member Data Documentation

std::vector<BeamType::BeamType_t> NCExtrapolationModule::fBeamIndex [private]

index of beams to use Definition at line 187 of file NCExtrapolationModule.h. Referenced by Config(), and Run().

Registry NCExtrapolationModule::fConfig [private]

Definition at line 246 of file NCExtrapolationModule.h. Referenced by Config(), ExtrapolateNearToFar(), GetListOfShifts(), PrepareForExtrapolation(), Run(), and SystematicsFromRegistry().

TString NCExtrapolationModule::fDataMCPath [private]

path to uDST for data and MC files Definition at line 180 of file NCExtrapolationModule.h. Referenced by AddFilesToChain(), and Config().

POTMap NCExtrapolationModule::fDataPOTFar [private]

Definition at line 231 of file NCExtrapolationModule.h. Referenced by Run().

POTMap NCExtrapolationModule::fDataPOTNear [private]

Definition at line 230 of file NCExtrapolationModule.h. Referenced by Run().

std::vector<TH1*> NCExtrapolationModule::fDQNearMCTotalSpecial [private]

Definition at line 178 of file NCExtrapolationModule.h. Referenced by AddEventToExtrapolations(), DrawDataQualityPlotsSpecial(), and NCExtrapolationModule().

NCEventInfo NCExtrapolationModule::fEventInfo [private]

Definition at line 208 of file NCExtrapolationModule.h. Referenced by AddEventToExtrapolations(), AddShiftedEventToExtrapolations(), ApplySystematicShifts(), DoMockExperiments(), FillDataQualityPlotsSpecial(), FinalEventCheck(), NCExtrapolationModule(), Run(), SetEnergies(), SetEventWeight(), and ~NCExtrapolationModule().

NCType::EExtraction NCExtrapolationModule::fExtractionType [private]

the extraction to use Definition at line 185 of file NCExtrapolationModule.h. Referenced by Config().

std::vector<NCExtrapolation*> NCExtrapolationModule::fExtrapolations [private]

Definition at line 213 of file NCExtrapolationModule.h. Referenced by AddEventToExtrapolations(), AddShiftedEventToExtrapolations(), CreateExtrapolations(), DoMockExperiments(), ExtrapolateNearToFar(), PrepareForExtrapolation(), Run(), and ~NCExtrapolationModule().

TString NCExtrapolationModule::fExtrapolationsList [private]

A space-separated list of extrapolations to use, from job macro. Definition at line 216 of file NCExtrapolationModule.h. Referenced by Config(), and Run().

std::vector<NCEventInfo*> NCExtrapolationModule::fFDMCSample [private]

Definition at line 240 of file NCExtrapolationModule.h. Referenced by AddEventToExtrapolations(), DoMockExperiments(), and ~NCExtrapolationModule().

TString NCExtrapolationModule::fFileName [private]

name of output file Definition at line 181 of file NCExtrapolationModule.h. Referenced by Config(), and Run().

std::vector<NC::FitMaster*> NCExtrapolationModule::fFitMasters [private]

Definition at line 214 of file NCExtrapolationModule.h. Referenced by ExtrapolateNearToFar(), Run(), and ~NCExtrapolationModule().

bool NCExtrapolationModule::fIncludeDataFromLoadedExtrapolations [private]

If fLoadExtrapolationsFile then load data part of spectrum too. Definition at line 221 of file NCExtrapolationModule.h. Referenced by Config().

TString NCExtrapolationModule::fLoadExtrapolationsFile [private]

Filename to load extrapolation objects from. Empty string -> no loading. Definition at line 219 of file NCExtrapolationModule.h. Referenced by Config(), and CreateExtrapolations().

bool NCExtrapolationModule::fMakeDQPlotsSpecial [private]

Ask Alex... Definition at line 206 of file NCExtrapolationModule.h. Referenced by Config().

POTMap NCExtrapolationModule::fMCPOTFar [private]

Definition at line 233 of file NCExtrapolationModule.h. Referenced by Run().

POTMap NCExtrapolationModule::fMCPOTFarElectron [private]

Definition at line 235 of file NCExtrapolationModule.h. Referenced by Run().

POTMap NCExtrapolationModule::fMCPOTFarTau [private]

Definition at line 234 of file NCExtrapolationModule.h. Referenced by Run().

POTMap NCExtrapolationModule::fMCPOTNear [private]

Definition at line 232 of file NCExtrapolationModule.h. Referenced by Run().

int NCExtrapolationModule::fMockExperimentsSeed [private]

Definition at line 239 of file NCExtrapolationModule.h. Referenced by Config(), and DoMockExperiments().

std::vector<Registry*> NCExtrapolationModule::fMockFits [private]

Definition at line 244 of file NCExtrapolationModule.h. Referenced by DoMockExperiments(), Run(), and ~NCExtrapolationModule().

int NCExtrapolationModule::fNumMockExperiments [private]

Zero if fake experiments are not to be carried out (default). Definition at line 238 of file NCExtrapolationModule.h. Referenced by AddEventToExtrapolations(), Config(), and Run().

NCType::EOscModel NCExtrapolationModule::fOscillationModel [private]

model to use in the fit Definition at line 184 of file NCExtrapolationModule.h. Referenced by Config().

double NCExtrapolationModule::fPIDCustomCut [private]

Custom cut value. Definition at line 190 of file NCExtrapolationModule.h. Referenced by AddEventToExtrapolations(), and Config().

NCPOTCounter* NCExtrapolationModule::fPOTCount [private]

Definition at line 242 of file NCExtrapolationModule.h. Referenced by AddFilesToChain(), Config(), NCExtrapolationModule(), Run(), and SetMCExposureForBeam().

std::vector<NC::RunUtil::ERunType> NCExtrapolationModule::fRunsToUse [private]

define which runs to use Definition at line 227 of file NCExtrapolationModule.h. Referenced by Config(), and Run().

TString NCExtrapolationModule::fSaveExtrapolationsFile [private]

Filename to save extrapolation objects to. Empty string -> no saving. Definition at line 223 of file NCExtrapolationModule.h. Referenced by Config(), and Run().

bool NCExtrapolationModule::fShiftedBeams [private]

If set then AddShiftedEventToExtrapolations is called. Definition at line 193 of file NCExtrapolationModule.h. Referenced by Config().

bool NCExtrapolationModule::fSimpleShiftedBeams [private]

Controls whether to generate a simpler set of shifted beams. If not set then shifted beams are created. If set then only beams are created Definition at line 198 of file NCExtrapolationModule.h. Referenced by Config(), and GetListOfShifts().

int NCExtrapolationModule::fSingleShiftedBeam [private]

Controls if only a single shifted beam is made. If set to -1 then no effect. If set then only the shifted beam from GetListOfShifts with this index is created. This is useful for generating a large number of beams in parallel as multiple jobs. Definition at line 204 of file NCExtrapolationModule.h. Referenced by AddShiftedEventToExtrapolations(), and Config().

bool NCExtrapolationModule::fSingleSpectrum [private]

use a single spectrum Definition at line 225 of file NCExtrapolationModule.h. Referenced by Config().

NC::OscProb::OscPars* NCExtrapolationModule::fTrueOscPars [private]

Definition at line 176 of file NCExtrapolationModule.h. Referenced by ApplySystematicShifts(), Config(), DoMockExperiments(), ExtrapolateNearToFar(), and Run().

bool NCExtrapolationModule::fUseMCAsData [private]

use the MC as data for testing purposes Definition at line 182 of file NCExtrapolationModule.h. Referenced by Config(), and Run().

bool NCExtrapolationModule::fUseMockData [private]

are you using mock data for the data? Definition at line 186 of file NCExtrapolationModule.h. Referenced by Config(), and Run().

bool NCExtrapolationModule::fUsePIDCustomCut [private]

Use custom cut. Definition at line 189 of file NCExtrapolationModule.h. Referenced by AddEventToExtrapolations(), and Config().

---

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

• NCExtrapolationModule.h
• NCExtrapolationModule.cxx

---