AnalysisManager Class Reference

This class is the Top level interface for the library. More...

#include <AnalysisManager.hxx>

Public Member Functions
void	DefineProduction ()
void	DefineInputConverters ()
void	DefineSelections ()
void	DefineSystematics ()
SystematicManager &	syst ()
	Returns the systematic manager.
EventWeightManager &	eweight ()
	Returns the EventWeight manager.
EventVariationManager &	evar ()
	Returns the EventVariation manager.
InputManager &	input ()
	Returns the input manager.
SelectionManager &	sel ()
	Returns the selection manager.
void	SetExperiment (Experiment *exp)
	Sets the Experiment.
bool	ProcessEvent (const ToyExperiment &toy, AnaEventB &event, std::vector< Weight_h > &totalWeightSystVector, std::vector< Weight_h > &fluxWeightSystVector)
bool	ProcessEvent (const ToyExperiment &toy, AnaEventB &event, std::vector< Weight_h > &totalWeightSystVector, std::vector< Weight_h > &fluxWeightSystVector, Float_t &POTweight)
bool	ProcessEvent (AnaEventB &event, Float_t &POTWeight)
bool	ProcessEvent (AnaEventB &event)
bool	ProcessEvent (const ToyExperiment &toy, AnaEventB &event, Weight_h &totalWeight, Weight_h &FluxWeightSyst)
	Process one event method for use in BANFF and MaCh3 fitters. More...
void	CreateEventArray (Int_t nmax)
	Create the evevt array for preloading events.
bool	ReadEvents (const std::string &inputFile, Int_t nmax=-1)
	Read the specified number of events from the file and save them into an array. Default(-1) is all events.
bool	ReadEvents (Int_t nmax=-1)
	Read the specified number of events from the current DataSample and save them into an array. Default(-1) is all events.
bool	ReadEvents (DataSample *sample, Int_t nmax=-1)
	Read the specified number of events from the DataSample and save them into an array. Default(-1) is all events.
void	SetNEventsToProcess (Int_t nmax)
	Set the maximum number of events to process.
AnaSuperEventB *	GetSuperEvent (Int_t eventIndex)
	Returns The SuperEvent with a given index from the array.
AnaEventB *	GetEvent (Int_t eventIndex)
	Returns The Event with a given index from the array.
AnaSuperEventB *	GetNextSuperEvent ()
	Returns The next SuperEvent.
AnaEventB *	GetNextEvent ()
	Returns The next Event.
UInt_t	GetEntries ()
	Returns the number of entries in the input tree.
bool	LoadEvent (Long64_t &entry)
void	PreloadEvents (bool preloadData=1, bool preloadMC=1)
bool	PreloadMCEvents (std::vector< std::string > inputFiles, std::vector< float > POT_weights)
bool	PreloadDataEvents (std::vector< std::string > inputFiles)
AnaSuperEventB *	GetPreloadedMCSuperEvent (int i)
AnaSuperEventB *	GetPreloadedDataSuperEvent (int i)
void	CreateMCEventArray (Int_t nmax)
void	CreateDataEventArray (Int_t nmax)
UInt_t	GetNMCEvents ()
UInt_t	GetNDataEvents ()
bool	Initialize (Int_t nmax)
void	InitialiseDataTChain ()
void	InitialiseMCTChain ()
void	ResetEventsProcessed ()
AnaSuperEventB *	LoadSuperEvent (Long64_t &evtIndex)
FluxWeighting *	GetFluxWeighting ()
bool	CheckSelectionAgainstRunPeriod (SelectionBase *selec, int RunPeriod)
UInt_t	GetNPreloadedEvents () const
	Return the number of preloaded events.

Protected Attributes
SystematicManager	_syst
	An instance of the systematic manager.
EventWeightManager	_weight
	An instance of the EventWeight manager.
EventVariationManager	_var
	An instance of the EventVariation manager.
InputManager	_input
	An instance of the input manager.
SelectionManager	_sel
	An instance of the selection manager.
AnaSuperEventB **	_eventArray
	The array of events.
UInt_t	_nEventsInArray
	the number of events in the array
bool	_applyEventWeights
	whether to apply detector event weight or not
bool	_applyEventVariations
	whether to apply detector event variation or not
bool	_applyFluxWeightSystematic
	whether to apply Flux weight systematic or not
Int_t	_currentEvent
	The current event in the event array.
Experiment *	_exp
	The Experiment.
ToyExperiment	_toy
	The Toy Experiment.
std::vector< DataSample * >::iterator	_currentSample
SampleGroup *	_currentSampleGroup
std::vector< DataSample * >	_samples
Int_t	_nEventsToProcess
	the maximum number of events to process
Int_t	_nEventsProcessed
	the number of events processed so far
FluxWeighting *	_flux
	Access to the flux weighting.
bool	_applyFluxWeight
	Flag to enable/disable flux weight.
bool	_initialisePionSystematics
std::string	_fluxFile
	Flux file and option.
std::string	_fluxTuning
std::string	_fluxVersion
AnaSuperEventB **	_mcEventArray
	The array of preloaded MC events.
AnaSuperEventB **	_dataEventArray
	The array of preloaded Data events.
UInt_t	_nEventsInMCArray
	the number of events in the preloaded MC array
UInt_t	_nEventsInDataArray
	the number of events in the preloaded Data array
std::vector< Float_t >	_POT_weights
	The POT weight for each MC file loaded into the Analysis Manager.
bool	_doFGD1
bool	_doFGD2

Detailed Description

This class is the Top level interface for the library.

Definition at line 20 of file AnalysisManager.hxx.

Member Function Documentation

CheckSelectionAgainstRunPeriod()

bool AnalysisManager::CheckSelectionAgainstRunPeriod	(	SelectionBase *	selec,
		int	RunPeriod
	)

Check to see whether the event is from the right run period for the selection This is important for making sure we do not run the anti-neutrino mode selections on neutrino mode data

Definition at line 1272 of file AnalysisManager.cxx.

                                                                                       {
    //******************************************************************
    return selec->IsValidRun(RunPeriod);
}

LoadEvent()

bool AnalysisManager::LoadEvent

(

Long64_t &

entry

)

Method to load a given single event, without pre-loading. Fill the raw AnaEventB structure. The argument entry (the entry number in the input tree) will be modified inside the method by the specific converter (hence the non-cont reference). The way entry is modified will depend on whether the input file is event based (every call to this method will increment by one the argument entry) or spill based (several events – one per bunch – correspond to the same spill, so once the first event in a given spill is read entry number will not be varied until all events in that spill are processed). Returns whether the event was successfully filled.

Definition at line 761 of file AnalysisManager.cxx.

                                              {
    //******************************************************************
    
    AnaSuperEventB* event = LoadSuperEvent(entry);
    if(event==NULL) return false;
    
    return true;
}

LoadSuperEvent()

AnaSuperEventB * AnalysisManager::LoadSuperEvent

(

Long64_t &

evtIndex

)

Fill the raw AnaEventB structure and create a AnaSuperEventB from the raw event (all done by InputManagerB calls). The input entry number will be modified internally by the specific converter (hence the non-cont reference) . This will depend on whether the input file is spill based or event based.

Definition at line 933 of file AnalysisManager.cxx.

                                                              {
    //******************************************************************
    // Fill the event structure for the current event
    if (!_input.LoadEvent(entry,true)) return NULL;
    
    // Get the SuperEvent
    AnaSuperEventB* event = &_input.GetSuperEvent();
    
    if(event->Event->GetIsMC()){
        if(_POT_weights.size()) event->POTWeight = _POT_weights[_input.GetChain(_input.GetConverter().GetTreeName().c_str())->GetTreeNumber()];
    }
    
    return event;
}

ProcessEvent() [1/4]

bool AnalysisManager::ProcessEvent	(	const ToyExperiment &	toy,
		AnaEventB &	event,
		std::vector< Weight_h > &	totalWeightSystVector,
		std::vector< Weight_h > &	fluxWeightSystVector
	)

Process one event. The input is the event. The output is a boolean (return value) telling us whether at least one selection was passes for the current event, and a vector of Weight_hs with the weights for each selection

Definition at line 494 of file AnalysisManager.cxx.

                                                                                                                                                                   {
    //******************************************************************
    
    // Method not computing the POTweight
    Float_t POTweight;
    return ProcessEvent(toy,event,totalWeightSystVector,fluxWeightSystVector,POTweight);
}

ProcessEvent() [2/4]

bool AnalysisManager::ProcessEvent	(	const ToyExperiment &	toy,
		AnaEventB &	event,
		std::vector< Weight_h > &	totalWeightSystVector,
		std::vector< Weight_h > &	fluxWeightSystVector,
		Float_t &	POTweight
	)

The vector of systematic weights (one entry per systematic)

Clear the vector of weight and flux systematics (a entry per selection)

Apply the systematics variations (for all selections) The event will be modified. All actions below should proceed on the modified event

Loop over selections

Initialize the Flux Weight Systematic to 1 (in the case it is not applied)

Initialize the total weight of Weight Systematics to 1 (in the case they are not applied)

Apply the flux weight

Compute the weight for this selection by applying the systematic weights.

Definition at line 513 of file AnalysisManager.cxx.

                                                                                                                                                                                       {
    //******************************************************************
    
    /*
     This Method Process one event. That means:
     
     1. Apply systematic variations
     2. Loop over selections. And for each selection:
     2a. Apply all steps
     2b. Compute the systematic weight when all cuts are passed
     
     Input:
     - AnaEventB, but the one to be modified (event). Contains the SystBox
     
     - ToyExperiment,  the toy experiment definition with the variation for each systematic (toy)
     Output:
     - EventSummary (part of the AnaEventB) containing high level info (candidate, etc)
     - The vector of weights for each selection
     
     Return value:
     - true when at least one selection has been passed
     
     */
    bool passed=false;
    
    /// The vector of systematic weights (one entry per systematic)
    Int_t nWeightSyst= eweight().GetNEnabledEventWeights();
    Weight_h* weightSystDummy;
    anaUtils::CreateArray(weightSystDummy, nWeightSyst);
    
    /// Clear the vector of weight and flux systematics (a entry per selection)
    totalWeightSystVector.clear();
    fluxWeightSystVector.clear();
    
    /// Apply the systematics variations (for all selections)
    /// The event will be modified. All actions below should proceed on the modified event
    if (_applyEventVariations && event.GetIsMC()){
        // First, reset the event to the original data
        //      if  (syst().UndoEventVariations(event)) _input.ResetSpillToRaw();
        // Now apply variations to original spill
        evar().ApplyEventVariations(toy, event);
    }
    
    
    // Reset event summary sample before applying all selections
    static_cast<AnaEventSummaryB*>(event.Summary)->ResetSummary();
    
    /// Loop over selections
    for (std::vector<SelectionBase*>::iterator it=sel().GetSelections().begin();it!=sel().GetSelections().end();it++){
        SelectionBase& selec = **it;
        
        // only enabled selections
        if (!selec.IsEnabled()) continue;
        // check we should apply this selection to this run period
        if (!CheckSelectionAgainstRunPeriod(*it, anaUtils::GetRunPeriod(static_cast<AnaEventB*>(&event)->EventInfo.Run))) continue;
        
        /// Initialize the Flux Weight Systematic to 1 (in the case it is not applied)
        Weight_h fluxWeightSyst=1.;
        
        /// Initialize the  total weight of Weight Systematics to 1 (in the case they are not applied)
        Weight_h  totalWeightSyst = 1;
        bool redo;
        bool passed_temp = selec.Apply(event,redo);
        
        if (passed_temp && event.GetIsMC()){
            
            /// Apply the flux weight
            if (_flux && event.Summary && !event.GetIsSandMC())
                if (static_cast<AnaEventSummaryB*>(event.Summary)->TrueVertex[selec.GetSampleId()])
                    fluxWeightSyst *=_flux->GetWeight(static_cast<AnaEventSummaryB*>(event.Summary)->TrueVertex[selec.GetSampleId()], anaUtils::GetRunPeriod(static_cast<AnaEventB*>(&event)->EventInfo.Run));
            
            /// Compute the weight for this selection by applying the systematic weights.
            if (_applyEventWeights || _applyFluxWeightSystematic){
                // apply the detector weight systematics
                if (_applyEventWeights){
                    totalWeightSyst = eweight().ComputeEventWeights(selec, toy, event, selec.GetPreviousToyBox(event), weightSystDummy);
                }
                // apply the Flux systematic independently
                if (_applyFluxWeightSystematic && !event.GetIsSandMC()){
                    fluxWeightSyst *= syst().ApplyFluxSystematics(toy, event, selec.GetPreviousToyBox(event));
                }
            }
        }
        
        // add the total weight and flux weight to the vector
        totalWeightSystVector.push_back(totalWeightSyst);
        fluxWeightSystVector.push_back(fluxWeightSyst);
        
        // If any of the selections is passed the overall passed is true
        if (passed_temp) passed=true;
    }
    
    // computes the POT normalization for the current event
    if (_currentSampleGroup){
        Float_t POTdata=0;
        Float_t POTmc=0;
        Float_t POTsand=0;
        _currentSampleGroup->GetPOT(POTdata, POTmc, POTsand);
        POTweight = POTdata/POTmc;
    }
    
    delete [] weightSystDummy;
    
    return passed;
}

ProcessEvent() [3/4]

bool AnalysisManager::ProcessEvent	(	AnaEventB &	event,
		Float_t &	POTWeight
	)

Loop over selections

Apply the selection

Definition at line 712 of file AnalysisManager.cxx.

                                                                       {
    //******************************************************************
    
    /*
     This Method Process one event. That means:
     
     2. Loop over selections. And for each selection:
     2a. Apply all steps
     
     Input:
     - AnaEventB, but the one to be modified (event). Contains the SystBox
     
     Output:
     - EventSummary (part of the AnaEventB) containing high level info (candidate, etc)
     
     Return value:
     - true when at least one selection has been passed
     
     */
    bool passed=false;
    /// Loop over selections
    
    // Reset event summary sample before applying all selections
    static_cast<AnaEventSummaryB*>(event.Summary)->ResetSummary();
    
    for (std::vector<SelectionBase*>::iterator it=sel().GetSelections().begin();it!=sel().GetSelections().end();it++){
        SelectionBase& selec = **it;
        // only enabled selections
        if (!selec.IsEnabled()) continue;
        if (!CheckSelectionAgainstRunPeriod(*it, anaUtils::GetRunPeriod(static_cast<AnaEventB*>(&event)->EventInfo.Run))) continue;
        
        /// Apply the selection
        bool redo;
        if (selec.Apply(event, redo)) passed=true;
    }
    
    // computes the POT normalization for the current event
    if (_currentSampleGroup){
        Float_t POTdata=0;
        Float_t POTmc=0;
        Float_t POTsand=0;
        _currentSampleGroup->GetPOT(POTdata, POTmc, POTsand);
        POTweight = POTdata/POTmc;
    }
    
    return passed;
}

ProcessEvent() [4/4]

bool AnalysisManager::ProcessEvent	(	const ToyExperiment &	toy,
		AnaEventB &	event,
		Weight_h &	totalWeight,
		Weight_h &	FluxWeightSyst
	)

Process one event method for use in BANFF and MaCh3 fitters.

Apply the systematics variations (for all selections) The event will be modified. All actions below should proceed on the modified event

Loop over selections

Initialize the Flux Weight Systematic to 1 (in the case it is not applied)

Initialize the total weight of Weight Systematics to 1 (in the case they are not applied)

Apply the flux weight

Compute the weight for this selection by applying the systematic weights.

Definition at line 620 of file AnalysisManager.cxx.

                                                                                                                            {
    //******************************************************************
    
    /*
     This Method Process one event. That means:
     
     1. Apply systematic variations
     2. Loop over selections. And for each selection:
     2a. Apply all steps
     2b. Compute the systematic weight when all cuts are passed
     
     Input:
     - AnaEventB, but the one to be modified (event). Contains the SystBox
     
     - ToyExperiment,  the toy experiment definition with the variation for each systematic (toy)
     Output:
     - EventSummary (part of the AnaEventB) containing high level info (candidate, etc)
     - The vector of weights for each selection
     
     Return value:
     - true when at least one selection has been passed
     
     */
    bool passed=false;
    
    
    /// Apply the systematics variations (for all selections)
    /// The event will be modified. All actions below should proceed on the modified event
    if (evar().GetNEventVariations() && _applyEventVariations && event.GetIsMC()){
        // First, reset the event to the original data
        //      if  (syst().UndoEventVariations(event)) _input.ResetSpillToRaw();
        //GetSystematicVariationIndex(const std::string& name)
        // Now apply variations to original spill
        evar().ApplyEventVariations(toy, event);
    }
    
    // Reset event summary sample before applying all selections
    static_cast<AnaEventSummaryB*>(event.Summary)->ResetSummary();
    
    Int_t nWeightSyst= eweight().GetNEnabledEventWeights();
    Weight_h* weightSystDummy;
    anaUtils::CreateArray(weightSystDummy, nWeightSyst);
    
    /// Loop over selections
    for (std::vector<SelectionBase*>::iterator it=sel().GetSelections().begin();it!=sel().GetSelections().end();it++){
        SelectionBase& selec = **it;
        
        // only enabled selections
        if (!selec.IsEnabled()) continue;
        // check we should apply this selection to this run period
        if (!CheckSelectionAgainstRunPeriod(*it, anaUtils::GetRunPeriod(static_cast<AnaEventB*>(&event)->EventInfo.Run))) continue;
        
        /// Initialize the Flux Weight Systematic to 1 (in the case it is not applied)
        fluxWeightSyst=1.;
        
        /// Initialize the  total weight of Weight Systematics to 1 (in the case they are not applied)
        totalweight = 1;
        
        bool redo;
        bool passed_temp = selec.Apply(event,redo);
        
        if(passed_temp && passed) std::cout << "DOUBLE EVENT SELECTION ON selec.GetSampleId() = " << selec.GetSampleId() << std::endl;
        if(passed_temp) passed = 1;
        
        if (passed_temp && event.GetIsMC()){
            
            /// Apply the flux weight
            if (_flux && event.Summary)
                if (static_cast<AnaEventSummaryB*>(event.Summary)->TrueVertex[selec.GetSampleId()] && !event.GetIsSandMC())
                    fluxWeightSyst *=_flux->GetWeight(static_cast<AnaEventSummaryB*>(event.Summary)->TrueVertex[selec.GetSampleId()], anaUtils::GetRunPeriod(static_cast<AnaEventB*>(&event)->EventInfo.Run));
            
            /// Compute the weight for this selection by applying the systematic weights.
            if (_applyEventWeights || _applyFluxWeightSystematic){
                // apply the detector weight systematics
                if (_applyEventWeights){
                    totalweight = eweight().ComputeEventWeights(selec,toy, event, selec.GetPreviousToyBox(event),weightSystDummy);
                }
                // apply the Flux systematic independently
                if (_applyFluxWeightSystematic && !event.GetIsSandMC()){
                    fluxWeightSyst *= syst().ApplyFluxSystematics(toy, event, selec.GetPreviousToyBox(event));
                }
            }
        }
        
        //weights.push_back(weight);
        // If any of the selections is passed the overall passed is true
        if (passed_temp) return true;
    }
    return passed;
}

Member Data Documentation

_initialisePionSystematics

bool AnalysisManager::_initialisePionSystematics

protected

Flag to tell psyche whether to initialise pion systematics, taken from parameters file Pion systematic initialisation is very very slow, so disabling this when it is not needed speeds the event loading by a factor of 30

Definition at line 217 of file AnalysisManager.hxx.

---

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

• /hep/T2K/nd280rep/ANALYSIS/HIGHLAND2/ANAPARTICLE/psyche/psycheSteering/v3r12/src/AnalysisManager.hxx
• /hep/T2K/nd280rep/ANALYSIS/HIGHLAND2/ANAPARTICLE/psyche/psycheSteering/v3r12/src/AnalysisManager.cxx