baseTrackerAnalysis Class Reference

#include <baseTrackerAnalysis.hxx>

Inheritance diagram for baseTrackerAnalysis:

Public Types
enum	enumStandardMicroTrees_baseTrackerAnalysis {   ntpctracks = enumStandardMicroTreesLast_baseAnalysis+1, ntpcposQualityFV, ntpcnegQualityFV, nfgdtracks,   nfgdonlytracks, chargeid_ncorrect, chargeid_nwrong, tpcfgdmatch_ncorrect,   tpcfgdmatch_nwrong, tpctr_ncorrect, tpctr_nwrong, fgdtr_ncorrect,   fgdtr_nwrong, fgdhybtr_ncorrect, fgdhybtr_nwrong, meeff_ncorrect,   meeff_nwrong, mepur_ncorrect, mepur_nwrong, tpc_ecal_match_ncorrect,   tpc_ecal_match_nwrong, tpc_p0d_match_ncorrect, tpc_p0d_match_nwrong, fgd_ecal_match_ncorrect,   fgd_ecal_match_nwrong, fgd_ecal_smrd_match_ncorrect, fgd_ecal_smrd_match_nwrong, ecal_pid_ncorrect,   ecal_pid_nwrong, ecal_tr_ncorrect, ecal_tr_nwrong, ecal_emhippid_ncorrect,   ecal_emhippid_nwrong, fgd2shower_ncorrect, fgd2shower_nwrong, enumStandardMicroTreesLast_baseTrackerAnalysis }
enum	enumConf_baseTrackerAnalysis {   bfield_syst =baseAnalysis::enumConfLast_baseAnalysis+1, momscale_syst, momresol_syst, momrange_resol_syst,   tpcpid_syst, fgdpid_syst, chargeideff_syst, tpctrackeff_syst,   fgdtrackeff_syst, fgdhybridtrackeff_syst, tpcfgdmatcheff_syst, tpcclustereff_syst,   michel_syst, oofv_syst, pileup_syst, fgdmass_syst,   sandmu_syst, ecal_emresol_syst, ecal_emscale_syst, tpc_ecal_matcheff_syst,   tpc_p0d_matcheff_syst, fgd_ecal_matcheff_syst, fgd_ecal_smrd_matcheff_syst, ecal_trackeff_syst,   ecal_pid_syst, tof_resol_syst, ecal_emhippid_syst, fgd2shower_syst,   nuetpcpileup_syst, nuep0dpileup_syst, nueecalpileup_syst, nueoofv_syst,   p0d_elossscale_syst, p0d_elossresol_syst, p0d_veto_syst, enumConfLast_baseTrackerAnalysis }
Public Types inherited from baseAnalysis
enum	enumStandardMicroTrees_baseAnalysis {   run = enumStandardMicroTreesLast_AnalysisAlgorithm+1, subrun, evt, evt_time,   bunch, NWEIGHTS, weight, TruthVertexID,   TruthVertexNB, RooVtxIndex, RooVtxEntry, RooVtxEntry2,   RooVtxFile, nu_pdg, nu_trueE, nu_truereac,   nu_truedir, truelepton_mom, truelepton_costheta, truelepton_dir,   truevtx_pos, selvtx_det, selvtx_pos, selvtx_truepos,   true_signal, weight_syst_total_noflux, enumStandardMicroTreesLast_baseAnalysis }
enum	enumConf_baseAnalysis {   sipion_syst =ConfigurationManager::enumConfLast_ConfigurationManager+1, siproton_syst, nuflux_syst, antinuflux_syst,   all_syst, zero_var, enumConfLast_baseAnalysis }
Public Types inherited from AnalysisAlgorithm
enum	enumAnalysisPoint {   kInitialize =0, kDefineProductions, kDefineInputConverters, kDefineSelections,   kDefineCorrections, kDefineSystematics, kDefineConfigurations, kDefineMicroTrees,   kDefineTruthTree, kFillConfigTree, kInitializeSpill, kInitializeBunch,   kInitializeConfiguration, kInitializeToy, kInitializeSelection, kFinalizeSelection,   kFinalizeToy, kFillToyVarsInMicroTrees, kFinalizeConfiguration, kFillCategories,   kFillMicroTrees, kFinalizeBunch, kFillTruthTree, kFinalizeSpill,   kFinalize }
enum	enumStandardMicroTrees_AnalysisAlgorithm {   firstCategory = OutputManager::enumStandardMicroTreesLast_OutputManager+1, firstCategoryCounter = firstCategory+NMAXCATEG, entry = firstCategoryCounter + NMAXCATEGCOUNTERS, toy_ref,   toy_index, toy_par_weight, toy_par_var, NWEIGHTSYST,   weight_syst, weight_syst_total, weight_corr, weight_corr_total,   redo, accum_level, first_cut, last_cut =first_cut+NMAXSTEPS,   enumStandardMicroTreesLast_AnalysisAlgorithm }
enum	enumConfigTree_AnalysisAlgorithm {   SoftwareVersion =0, HOSTNAME, CMTPATH, INPUTFILE,   OriginalFile, MinAccumLevelToSave, enumConfigTreeLast_AnalysisAlgorithm }

Public Member Functions
	baseTrackerAnalysis (AnalysisAlgorithm *ana=NULL)
virtual bool	Initialize ()
	[AnalysisAlgorithm_mandatory]
virtual void	DefineCorrections ()
virtual void	DefineSystematics ()
virtual void	DefineConfigurations ()
virtual void	DefineMicroTrees (bool addBase=true)
virtual void	DefineTruthTree ()
virtual void	FillMicroTrees (bool addBase=true)
virtual void	FillToyVarsInMicroTrees (bool addBase=true)
virtual void	FillTruthTreeBase (const AnaTrueVertex &vtx, const SubDetId::SubDetEnum det=SubDetId::kFGD1, bool IsAntinu=false)
virtual const ToyBoxTracker &	box (Int_t isel=-1) const
	Returns the ToyBoxTracker.
virtual AnaVertexB *	GetVertex () const
	Returns the vertex for the ToyBoxTracker.
virtual AnaTrueVertexB *	GetTrueVertex () const
	Returns the true vertex for the ToyBoxTracker.
Public Member Functions inherited from baseAnalysis
	baseAnalysis (AnalysisAlgorithm *ana=NULL)
virtual bool	InitializeSpill ()
virtual bool	FinalizeConfiguration ()
virtual void	DefineProductions ()
virtual void	DefineInputConverters ()
virtual bool	CheckFillTruthTree (const AnaTrueVertex &vtx)=0
virtual void	FillTruthTree (const AnaTrueVertex &vtx)=0
void	FillMicroTreesBase (bool addBase=true)
void	FillToyVarsInMicroTreesBase (bool addBase=true)
void	FillTruthTree ()
void	FillTruthTreeBase (const AnaTrueVertex &vtx, const SubDetId::SubDetEnum det=SubDetId::kFGD1, bool IsAntinu=false)
AnaSpill &	GetSpill ()
	Get a casted AnaSpillC to AnaSpill from the InputManager.
AnaBunch &	GetBunch ()
	Get a casted AnaBunchBB to AnaBunch from the InputManager (TODO the protection)
AnaEvent &	GetEvent ()
	Get a casted AnaEventC to AnaEvent.
virtual AnaEventC *	MakeEvent ()
	Create the appropriate event time from an Spill and a Bunch in that spill.
void	SetSaveRooTracker (bool save)
	Set whether to save the RooTrackerVtx tree or not.
void	SetRooVtxManager (RooTrackerVtxManager *man)
	Set the RooTrackerVtxManager.
Public Member Functions inherited from AnalysisAlgorithm
	AnalysisAlgorithm (AnalysisAlgorithm *ana=NULL)
virtual void	Finalize ()
	[AnalysisAlgorithm_optional]
virtual void	FinalizeSpill ()
virtual void	InitializeBunch ()
virtual void	FinalizeBunch ()
virtual void	InitializeConfiguration ()
virtual void	InitializeToy ()
virtual void	FinalizeToy ()
virtual void	InitializeSelection (const SelectionBase &)
virtual void	FinalizeSelection (const SelectionBase &)
virtual void	FillCategories ()
virtual void	FillConfigTree ()
virtual void	DefineSelections ()=0
void	FinalizeToyBase ()
	[AnalysisAlgorithm_mandatory] More...
void	SetFillSuccessOnly (bool fill)
	Fill trees and process weight systematics only when any of the branches is successful.
bool	GetFillSuccessOnly ()
void	SetInitializeTrees (bool ini)
	Initialize trees at the beginning of each configuration.
bool	GetInitializeTrees ()
void	SetMinAccumCutLevelToSave (Int_t level)
	Set the minimum accumulated cut level to save an event into the micro-tree.
Int_t	GetMinAccumCutLevelToSave ()
	Get the minimum accumulated cut level to save an event into the micro-tree.
bool	CheckAccumLevelToSave ()
	Check if the condition is fulfilled for at least one branch.
void	SetEvent (AnaEventC *event)
	Set the current event into the algorithm and all used algorithms.
void	SetToyBox (const ToyBoxB *box, Int_t isel=0)
	Set the current box into the algorithm and all used algorithms. This is useful when one Analysis uses another.
void	UseAnalysis (AnalysisAlgorithm *ana)
	Used a given analysis.
void	SetSelectedSelection (Int_t sel)
	Select one of the selections.
void	SetVersionCheck (bool check)
	Set version checking.
void	SetAnalysisPoint (enumAnalysisPoint point)
	Set the point of the analysis at which AnalysisLoop is.
HighlandInputManager &	input ()
SelectionManager &	sel ()
CorrectionManager &	corr ()
SystematicManager &	syst ()
EventWeightManager &	eweight ()
EventVariationManager &	evar ()
OutputManager &	output ()
ConfigurationManager &	conf ()
CategoryManager &	cat ()
DocStringManager &	doc ()
virtual const ToyBoxB &	boxB (Int_t isel=-1) const

Protected Attributes
bool	_computeEfficiency
	Compute analysis sample efficiency.
ChargeIDEffSystematics *	_chargeid
TPCFGDMatchEffSystematics *	_tpcfgdmatch
TPCTrackEffSystematics *	_tpctr
FGDTrackEffSystematics *	_fgdtr
FGDHybridTrackEffSystematics *	_fgdhybtr
MichelElectronEffSystematics *	_me
TPCECalMatchEffSystematics *	_tpc_ecal_matcheff
TPCP0DMatchEffSystematics *	_tpc_p0d_matcheff
FGDECalMatchEffSystematics *	_fgd_ecal_matcheff
FGDECalSMRDMatchEffSystematics *	_fgd_ecal_smrd_matcheff
ECalTrackEffSystematics *	_ecal_trackeff
ECalPIDSystematics *	_ecal_pid
ECalEmHipPIDSystematics *	_ecal_emhippid
FGD2ShowerSystematics *	_fgd2shower
Protected Attributes inherited from baseAnalysis
RooTrackerVtxManager *	_rooVtxManager
	the manager of the RooTrackerVtx
bool	_saveRooTrackerVtxTree
	Save RooTracker tree in output file.
FluxWeighting *	_flux
	Access to the flux weighting.
bool	_applyFluxWeight
	Flag to enable/disable flux weight.
std::string	_fluxFile
	Flux file and option.
std::string	_fluxTuning
bool	_enableSingleVariationSystConf
bool	_enableSingleWeightSystConf
bool	_enableAllSystConfig
bool	_enableZeroVarConfig
Int_t	_ntoys
Int_t	_randomSeed
Protected Attributes inherited from AnalysisAlgorithm
HighlandInputManager *	_inputManager
	Input Manager: access to the current Event.
CorrectionManager *	_corrManager
	Correction Manager.
SystematicManager *	_systManager
	Systematics Manager.
EventWeightManager *	_weightManager
	EventWeight Manager.
EventVariationManager *	_variationManager
	EventVariation Manager.
OutputManager *	_outputManager
	Output Manager.
ConfigurationManager *	_confManager
	Configuration Manager.
SelectionManager *	_selManager
CategoryManager *	_categManager
DocStringManager *	_docManager
const ToyBoxB *	_box [NMAXSELECTIONS]
	The analysis box.
Int_t	_min_accum_cut_level
	the minimum accumulated cut level to save an event into the micro-tree
bool	_fillSuccessOnly
	Fill trees and process weight systematics only when any of the branches is succesful.
bool	_initializeTrees
	Initialize trees at the beginning of each configuration.
AnaEventC *	_event
	The current event.
std::vector< AnalysisAlgorithm * >	_usedAnalyses
	The Vector of used analysis.
Int_t	_selectedSelection
	The selected selection.
bool	_setMethodCalled
	Boolean parameter to know whether nny of the methods that sets things into used analysis has been called.
bool	_versionCheck
enumAnalysisPoint	_analysisPoint

Additional Inherited Members
Protected Member Functions inherited from baseAnalysis
void	AddZeroVarConfiguration ()

Detailed Description

This class provides a base for user analyses. It handles many common functions, and provides a structure so that users don't have to write too much "boiler-plate" code.

User analyses should inherit from this class.

Definition at line 36 of file baseTrackerAnalysis.hxx.

Constructor & Destructor Documentation

baseTrackerAnalysis()

baseTrackerAnalysis::baseTrackerAnalysis

(

AnalysisAlgorithm *

ana = NULL

)

Constructor, which instantiates the necessary converters for converting input files to the AnaSpill format.

Definition at line 50 of file baseTrackerAnalysis.cxx.

                                                              : baseAnalysis(ana){
//********************************************************************

  _chargeid               = NULL;
  _tpcfgdmatch            = NULL;
  _tpctr                  = NULL;
  _fgdtr                  = NULL;
  _fgdhybtr               = NULL;
  _me                     = NULL;
  _tpc_ecal_matcheff      = NULL; 
  _tpc_p0d_matcheff       = NULL;
  _fgd_ecal_matcheff      = NULL;
  _fgd_ecal_smrd_matcheff = NULL;
  _ecal_trackeff          = NULL;
  _ecal_pid               = NULL;
  _fgd2shower             = NULL;
  
  // Add the package version
  ND::versioning().AddPackage("baseTrackerAnalysis", anaUtils::GetSoftwareVersionFromPath((std::string)getenv("BASETRACKERANALYSISROOT")));

  // Don't compute efficiencies by default
  _computeEfficiency = false;
}

Member Function Documentation

DefineConfigurations()

void baseTrackerAnalysis::DefineConfigurations ( )

virtual

[baseTrackerAnalysis_all_syst]

[baseTrackerAnalysis_all_syst]

Reimplemented from baseAnalysis.

Reimplemented in tutorialAnalysis.

Definition at line 189 of file baseTrackerAnalysis.cxx.

                                              {
//********************************************************************

  // Define all configuration of the base package
  baseAnalysis::DefineConfigurations();  

  //-------  Add and define individual configurations with one systematic only ------------------

   if (_enableSingleVariationSystConf){
    if (ND::params().GetParameterI("baseTrackerAnalysis.Variations.EnableBFieldDist")){
      AddConfiguration(conf(), bfield_syst, _ntoys, _randomSeed, new baseToyMaker(_randomSeed));
      conf().EnableEventVariation(SystId::kBFieldDist,bfield_syst);
    }
    if (ND::params().GetParameterI("baseTrackerAnalysis.Variations.EnableMomScale")){
      AddConfiguration(conf(), momscale_syst, _ntoys, _randomSeed, new baseToyMaker(_randomSeed));
      conf().EnableEventVariation(SystId::kMomScale,momscale_syst);
    }
    if (ND::params().GetParameterI("baseTrackerAnalysis.Variations.EnableMomRes")){
      AddConfiguration(conf(), momresol_syst, _ntoys, _randomSeed, new baseToyMaker(_randomSeed));
      conf().EnableEventVariation(SystId::kMomResol,momresol_syst);
    }
    if (ND::params().GetParameterI("baseTrackerAnalysis.Variations.EnableMomRangeRes")){
      AddConfiguration(conf(), momrange_resol_syst, _ntoys, _randomSeed, new baseToyMaker(_randomSeed));
      conf().EnableEventVariation(SystId::kMomRangeResol,momrange_resol_syst);
    }
    if (ND::params().GetParameterI("baseTrackerAnalysis.Variations.EnableTPCPID")){
      AddConfiguration(conf(), tpcpid_syst, _ntoys, _randomSeed, new baseToyMaker(_randomSeed));
      conf().EnableEventVariation(SystId::kTpcPid,tpcpid_syst);
    }
    if (ND::params().GetParameterI("baseTrackerAnalysis.Variations.EnableFGDPID")){
      AddConfiguration(conf(), fgdpid_syst, _ntoys, _randomSeed, new baseToyMaker(_randomSeed));
      conf().EnableEventVariation(SystId::kFgdPid, fgdpid_syst);
    }    
    if (ND::params().GetParameterI("baseTrackerAnalysis.Variations.EnableECalEMResol")){
      AddConfiguration(conf(), ecal_emresol_syst, _ntoys, _randomSeed, new baseToyMaker(_randomSeed));
      conf().EnableEventVariation(SystId::kECalEMResol, ecal_emresol_syst);
    }    
    if (ND::params().GetParameterI("baseTrackerAnalysis.Variations.EnableECalEMScale")){
      AddConfiguration(conf(), ecal_emscale_syst, _ntoys, _randomSeed, new baseToyMaker(_randomSeed));
      conf().EnableEventVariation(SystId::kECalEMScale, ecal_emscale_syst);
    }    
    if (ND::params().GetParameterI("baseTrackerAnalysis.Variations.EnableToFResol")){
      AddConfiguration(conf(), tof_resol_syst, _ntoys, _randomSeed, new baseToyMaker(_randomSeed));
      conf().EnableEventVariation(SystId::kToFResol, tof_resol_syst);
    }
    if (ND::params().GetParameterI("baseTrackerAnalysis.Variations.EnableP0DELossScale")){
      AddConfiguration(conf(), p0d_elossscale_syst, _ntoys, _randomSeed, new baseToyMaker(_randomSeed));
      conf().EnableEventVariation(SystId::kP0DELossScale, p0d_elossscale_syst);
    }
    if (ND::params().GetParameterI("baseTrackerAnalysis.Variations.EnableP0DELossResol")){
      AddConfiguration(conf(), p0d_elossresol_syst, _ntoys, _randomSeed, new baseToyMaker(_randomSeed));
      conf().EnableEventVariation(SystId::kP0DELossResol, p0d_elossresol_syst);
    }
  }

  if (_enableSingleWeightSystConf){
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableChargeConf")){
      AddConfiguration(conf(), chargeideff_syst, _ntoys, _randomSeed, new baseToyMaker(_randomSeed));
      conf().EnableEventWeight(SystId::kChargeIDEff, chargeideff_syst);
    }
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableTPCTrackEff")){
      AddConfiguration(conf(), tpctrackeff_syst, _ntoys, _randomSeed, new baseToyMaker(_randomSeed));
      conf().EnableEventWeight(SystId::kTpcTrackEff,tpctrackeff_syst);
    }
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableFGDTrackEff")){
      AddConfiguration(conf(), fgdtrackeff_syst, _ntoys, _randomSeed, new baseToyMaker(_randomSeed));
      conf().EnableEventWeight(SystId::kFgdTrackEff,fgdtrackeff_syst);
    }
      if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableFGDHybridTrackEff")){
      AddConfiguration(conf(), fgdhybridtrackeff_syst, _ntoys, _randomSeed, new baseToyMaker(_randomSeed));
      conf().EnableEventWeight(SystId::kFgdHybridTrackEff,fgdhybridtrackeff_syst);
    }
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableTPCFGDMatchEff")){
      AddConfiguration(conf(), tpcfgdmatcheff_syst, _ntoys, _randomSeed, new baseToyMaker(_randomSeed));
      conf().EnableEventWeight(SystId::kTpcFgdMatchEff,tpcfgdmatcheff_syst);
    }
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableOOFV")){
      AddConfiguration(conf(), oofv_syst, _ntoys, _randomSeed, new baseToyMaker(_randomSeed));
      conf().EnableEventWeight(SystId::kOOFV,oofv_syst);
    }
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnablePileUp")){
      AddConfiguration(conf(), pileup_syst, _ntoys, _randomSeed, new baseToyMaker(_randomSeed));
      conf().EnableEventWeight(SystId::kPileUp,pileup_syst);
    }
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableFGDMass")){
      AddConfiguration(conf(), fgdmass_syst, _ntoys, _randomSeed, new baseToyMaker(_randomSeed));
      conf().EnableEventWeight(SystId::kFgdMass,fgdmass_syst);
    }
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableMichelEleEff")){
      AddConfiguration(conf(), michel_syst, _ntoys, _randomSeed, new baseToyMaker(_randomSeed));
      conf().EnableEventWeight(SystId::kMichelEleEff,michel_syst);
    }
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableSandMu")){
      AddConfiguration(conf(), sandmu_syst, _ntoys, _randomSeed, new baseToyMaker(_randomSeed));
      conf().EnableEventWeight(SystId::kSandMu,sandmu_syst);
    }
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableTPCClusterEff")){
      AddConfiguration(conf(), tpcclustereff_syst, _ntoys, _randomSeed, new baseToyMaker(_randomSeed));
      conf().EnableEventWeight(SystId::kTpcClusterEff,tpcclustereff_syst);
    }
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableTPCECalMatchEff")){
      AddConfiguration(conf(), tpc_ecal_matcheff_syst, _ntoys, _randomSeed, new baseToyMaker(_randomSeed));
      conf().EnableEventWeight(SystId::kTpcECalMatchEff, tpc_ecal_matcheff_syst);
    }
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableTPCP0DMatchEff")){
      AddConfiguration(conf(), tpc_p0d_matcheff_syst, _ntoys, _randomSeed, new baseToyMaker(_randomSeed));
      conf().EnableEventWeight(SystId::kTpcP0dMatchEff, tpc_p0d_matcheff_syst);
    }
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableFGDECalMatchEff")){
      AddConfiguration(conf(), fgd_ecal_matcheff_syst, _ntoys, _randomSeed, new baseToyMaker(_randomSeed));
      conf().EnableEventWeight(SystId::kFgdECalMatchEff, fgd_ecal_matcheff_syst);
    }
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableFGDECalSMRDMatchEff")){
      AddConfiguration(conf(), fgd_ecal_smrd_matcheff_syst, _ntoys, _randomSeed, new baseToyMaker(_randomSeed));
      conf().EnableEventWeight(SystId::kFgdECalSmrdMatchEff, fgd_ecal_smrd_matcheff_syst);
    }
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableECalTrackEff")){
      AddConfiguration(conf(), ecal_trackeff_syst, _ntoys, _randomSeed, new baseToyMaker(_randomSeed));
      conf().EnableEventWeight(SystId::kECalTrackEff, ecal_trackeff_syst);
    }
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableECalPID")){
      AddConfiguration(conf(), ecal_pid_syst, _ntoys, _randomSeed, new baseToyMaker(_randomSeed));
      conf().EnableEventWeight(SystId::kECalPID, ecal_pid_syst);
    }
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableECalEmHipPID")){
      AddConfiguration(conf(), ecal_emhippid_syst, _ntoys, _randomSeed, new baseToyMaker(_randomSeed));
      conf().EnableEventWeight(SystId::kECalEmHipPID, ecal_emhippid_syst);
    }
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableFGD2Shower")){
      AddConfiguration(conf(), fgd2shower_syst, _ntoys, _randomSeed, new baseToyMaker(_randomSeed));
      conf().EnableEventWeight(SystId::kFGD2Shower, fgd2shower_syst);
    }
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableNuETPCPileUp")){
      AddConfiguration(conf(), nuetpcpileup_syst, _ntoys, _randomSeed, new baseToyMaker(_randomSeed));
      conf().EnableEventWeight(SystId::kNuETPCPileUp, nuetpcpileup_syst);
    }
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableNuEP0DPileUp")){
      AddConfiguration(conf(), nuep0dpileup_syst, _ntoys, _randomSeed, new baseToyMaker(_randomSeed));
      conf().EnableEventWeight(SystId::kNuEP0DPileUp, nuep0dpileup_syst);
    }
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableNuEECalPileUp")){
      AddConfiguration(conf(), nueecalpileup_syst, _ntoys, _randomSeed, new baseToyMaker(_randomSeed));
      conf().EnableEventWeight(SystId::kNuEECalPileUp, nueecalpileup_syst);
    }
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableNuEOOFV")){
      AddConfiguration(conf(), nueoofv_syst, _ntoys, _randomSeed, new baseToyMaker(_randomSeed));
      conf().EnableEventWeight(SystId::kNuEOOFV,nueoofv_syst);
    }
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableP0DVeto")){
      AddConfiguration(conf(), p0d_veto_syst, _ntoys, _randomSeed, new baseToyMaker(_randomSeed));
      conf().EnableEventWeight(SystId::kP0DVeto,nueoofv_syst);
    }
  }

  //! [baseTrackerAnalysis_all_syst]
  // Enable all variation systematics in the all_syst configuration (created in baseAnalysis)
  if ( _enableAllSystConfig){
    if (ND::params().GetParameterI("baseTrackerAnalysis.Variations.EnableBFieldDist"))           conf().EnableEventVariation(SystId::kBFieldDist           , all_syst);      
    if (ND::params().GetParameterI("baseTrackerAnalysis.Variations.EnableMomRes"))               conf().EnableEventVariation(SystId::kMomResol             , all_syst);      
    if (ND::params().GetParameterI("baseTrackerAnalysis.Variations.EnableMomRangeRes"))          conf().EnableEventVariation(SystId::kMomRangeResol        , all_syst); 
    if (ND::params().GetParameterI("baseTrackerAnalysis.Variations.EnableMomScale"))             conf().EnableEventVariation(SystId::kMomScale             , all_syst);
    if (ND::params().GetParameterI("baseTrackerAnalysis.Variations.EnableTPCPID"))               conf().EnableEventVariation(SystId::kTpcPid               , all_syst);
    if (ND::params().GetParameterI("baseTrackerAnalysis.Variations.EnableFGDPID"))               conf().EnableEventVariation(SystId::kFgdPid               , all_syst);
    if (ND::params().GetParameterI("baseTrackerAnalysis.Variations.EnableECalEMResol"))          conf().EnableEventVariation(SystId::kECalEMResol          , all_syst);
    if (ND::params().GetParameterI("baseTrackerAnalysis.Variations.EnableECalEMScale"))          conf().EnableEventVariation(SystId::kECalEMScale          , all_syst);
    if (ND::params().GetParameterI("baseTrackerAnalysis.Variations.EnableToFResol"))             conf().EnableEventVariation(SystId::kToFResol             , all_syst);
    if (ND::params().GetParameterI("baseTrackerAnalysis.Variations.EnableP0DELossScale"))        conf().EnableEventVariation(SystId::kP0DELossScale        , all_syst);
    if (ND::params().GetParameterI("baseTrackerAnalysis.Variations.EnableP0DELossResol"))        conf().EnableEventVariation(SystId::kP0DELossResol        , all_syst);
  }

  // Enable all Event Weights in the default and all_syst configurations
  for (std::vector<ConfigurationBase* >::iterator it= conf().GetConfigurations().begin();it!=conf().GetConfigurations().end();it++){
    Int_t index = (*it)->GetIndex();
    if (index != ConfigurationManager::default_conf && (index != all_syst || !_enableAllSystConfig)) continue;

    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableChargeConf"))           conf().EnableEventWeight(SystId::kChargeIDEff          , index);     
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnablePileUp"))               conf().EnableEventWeight(SystId::kPileUp               , index);      
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableMichelEleEff"))         conf().EnableEventWeight(SystId::kMichelEleEff         , index);      
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableTPCTrackEff"))          conf().EnableEventWeight(SystId::kTpcTrackEff          , index);      
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableFGDTrackEff"))          conf().EnableEventWeight(SystId::kFgdTrackEff          , index);      
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableFGDHybridTrackEff"))    conf().EnableEventWeight(SystId::kFgdHybridTrackEff    , index);      
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableTPCFGDMatchEff"))       conf().EnableEventWeight(SystId::kTpcFgdMatchEff       , index);      
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableOOFV"))                 conf().EnableEventWeight(SystId::kOOFV                 , index);
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableTPCClusterEff"))        conf().EnableEventWeight(SystId::kTpcClusterEff        , index);
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableFGDMass"))              conf().EnableEventWeight(SystId::kFgdMass              , index);      
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableSandMu"))               conf().EnableEventWeight(SystId::kSandMu               , index);
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableTPCECalMatchEff"))      conf().EnableEventWeight(SystId::kTpcECalMatchEff      , index);
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableTPCP0DMatchEff"))       conf().EnableEventWeight(SystId::kTpcP0dMatchEff       , index);
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableFGDECalMatchEff"))      conf().EnableEventWeight(SystId::kFgdECalMatchEff      , index);
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableFGDECalSMRDMatchEff"))  conf().EnableEventWeight(SystId::kFgdECalSmrdMatchEff  , index);
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableECalTrackEff"))         conf().EnableEventWeight(SystId::kECalTrackEff         , index);
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableECalPID"))              conf().EnableEventWeight(SystId::kECalPID              , index); 
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableECalEmHipPID"))         conf().EnableEventWeight(SystId::kECalEmHipPID         , index); 
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableFGD2Shower"))           conf().EnableEventWeight(SystId::kFGD2Shower           , index);
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableNuETPCPileUp"))         conf().EnableEventWeight(SystId::kNuETPCPileUp         , index);
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableNuEP0DPileUp"))         conf().EnableEventWeight(SystId::kNuEP0DPileUp         , index);
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableNuEECalPileUp"))        conf().EnableEventWeight(SystId::kNuEECalPileUp        , index);
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableNuEOOFV"))              conf().EnableEventWeight(SystId::kNuEOOFV              , index);
    if (ND::params().GetParameterI("baseTrackerAnalysis.Weights.EnableP0DVeto"))              conf().EnableEventWeight(SystId::kP0DVeto              , index);
  }
  //! [baseTrackerAnalysis_all_syst]
  
  // A configuration with all syst but zero variation applied
  if (_enableZeroVarConfig)
    AddZeroVarConfiguration();
  
}

DefineSystematics()

void baseTrackerAnalysis::DefineSystematics ( )

virtual

[baseTrackerAnalysis_varsyst]

[baseTrackerAnalysis_varsyst]

[baseTrackerAnalysis_weightsyst]

[baseTrackerAnalysis_weightsyst]

Reimplemented from baseAnalysis.

Reimplemented in tutorialAnalysis.

Definition at line 75 of file baseTrackerAnalysis.cxx.

                                           {
//********************************************************************

  //------------ Add Variation systematics ------------
  //! [baseTrackerAnalysis_varsyst]
  evar().AddEventVariation(SystId::kBFieldDist,          "BFieldDist",           new BFieldDistortionSystematics());
  evar().AddEventVariation(SystId::kMomScale,            "MomScale",             new MomentumScaleSystematics());
  evar().AddEventVariation(SystId::kMomResol,            "MomResol",             new MomentumResolSystematics());
  evar().AddEventVariation(SystId::kMomRangeResol,       "MomRangeResol",        new MomRangeResolSystematics());
  evar().AddEventVariation(SystId::kTpcPid,              "TpcPid",               new TPCPIDSystematics());
  evar().AddEventVariation(SystId::kFgdPid,              "FgdPid",               new FGDPIDSystematics());
  //! [baseTrackerAnalysis_varsyst]
  
  evar().AddEventVariation(SystId::kECalEMResol,         "ECalEMResol",          new ECalEMEnergyResolSystematics());
  evar().AddEventVariation(SystId::kECalEMScale,         "ECalEMScale",          new ECalEMEnergyScaleSystematics());

  evar().AddEventVariation(SystId::kToFResol,            "ToFResol",             new ToFResolSystematics());
  evar().AddEventVariation(SystId::kP0DELossScale,       "P0DELossScale",        new P0DELossScaleSystematics());
  evar().AddEventVariation(SystId::kP0DELossResol,       "P0DELossResol",        new P0DELossResolSystematics());

  
  //-------------- Add Event Weights ------------------

  // compute efficiency using truth for eff-like systematics
  _computeEfficiency =  (bool)ND::params().GetParameterI("baseTrackerAnalysis.Systematics.ComputeEfficiency"); 

  _chargeid                 = new ChargeIDEffSystematics(         _computeEfficiency);
  _tpcfgdmatch              = new TPCFGDMatchEffSystematics(      _computeEfficiency);
  _tpctr                    = new TPCTrackEffSystematics(         _computeEfficiency);
  _fgdtr                    = new FGDTrackEffSystematics(         _computeEfficiency);
  _fgdhybtr                 = new FGDHybridTrackEffSystematics(   _computeEfficiency);
  _me                       = new MichelElectronEffSystematics(   _computeEfficiency);
  _tpc_ecal_matcheff        = new TPCECalMatchEffSystematics(     _computeEfficiency);
  _tpc_p0d_matcheff         = new TPCP0DMatchEffSystematics(      _computeEfficiency);
  _fgd_ecal_matcheff        = new FGDECalMatchEffSystematics(     _computeEfficiency);
  _fgd_ecal_smrd_matcheff   = new FGDECalSMRDMatchEffSystematics( _computeEfficiency);
  _ecal_trackeff            = new ECalTrackEffSystematics(        _computeEfficiency);
  _ecal_pid                 = new ECalPIDSystematics(             _computeEfficiency);
  _ecal_emhippid            = new ECalEmHipPIDSystematics(        _computeEfficiency);
  _fgd2shower               = new FGD2ShowerSystematics(          _computeEfficiency);
  
  //BELOW the order is the same as in psyche, so that each throws can be exactly the same as in psyche.
  eweight().AddEventWeight(SystId::kChargeIDEff,          "ChargeIDEff",          _chargeid);
  eweight().AddEventWeight(SystId::kTpcClusterEff,        "TpcClusterEff",        new TPCClusterEffSystematics());
  eweight().AddEventWeight(SystId::kTpcTrackEff,          "TpcTrackEff",          _tpctr);
  eweight().AddEventWeight(SystId::kTpcFgdMatchEff,       "TpcFgdMatchEff",       _tpcfgdmatch);
  eweight().AddEventWeight(SystId::kFgdTrackEff,          "FgdTrackEff",          _fgdtr);
  eweight().AddEventWeight(SystId::kFgdHybridTrackEff,    "FgdHybridTrackEff",    _fgdhybtr);
  eweight().AddEventWeight(SystId::kMichelEleEff,         "MichelEleEff",         _me);
  //! [baseTrackerAnalysis_weightsyst]
  eweight().AddEventWeight(SystId::kPileUp,               "PileUp",               new PileUpSystematics());
  eweight().AddEventWeight(SystId::kFgdMass,              "FgdMass",              new FGDMassSystematics());
  eweight().AddEventWeight(SystId::kOOFV,                 "OOFV",                 new OOFVSystematics());
  eweight().AddEventWeight(SystId::kSandMu,               "SandMu",               new SandMuonsSystematics());
  //! [baseTrackerAnalysis_weightsyst]
  eweight().AddEventWeight(SystId::kTpcECalMatchEff,      "TpcECalMatchEff",      _tpc_ecal_matcheff);
  eweight().AddEventWeight(SystId::kTpcP0dMatchEff,       "TpcP0dMatchEff",       _tpc_p0d_matcheff);
  eweight().AddEventWeight(SystId::kFgdECalMatchEff,      "FgdECalMatchEff",      _fgd_ecal_matcheff);
  eweight().AddEventWeight(SystId::kFgdECalSmrdMatchEff,  "FgdECalSMRDMatchEff",  _fgd_ecal_smrd_matcheff);
  eweight().AddEventWeight(SystId::kECalTrackEff,         "ECalTrackEff",         _ecal_trackeff);
  eweight().AddEventWeight(SystId::kECalPID,              "ECalPID",              _ecal_pid);
  eweight().AddEventWeight(SystId::kECalEmHipPID,         "ECalEmHipPID",         _ecal_emhippid);
  eweight().AddEventWeight(SystId::kFGD2Shower,           "Fgd2Shower",           _fgd2shower);
  eweight().AddEventWeight(SystId::kNuETPCPileUp,         "nueTPCPileup",         new nueTPCPileUpSystematics());
  eweight().AddEventWeight(SystId::kNuEP0DPileUp,         "nueP0DPileup",         new nueP0DPileUpSystematics());
  eweight().AddEventWeight(SystId::kNuEECalPileUp,        "nueEcalPileup",        new nueECalPileUpSystematics());
  eweight().AddEventWeight(SystId::kNuEOOFV,              "nueOOFV",              new nueOOFVSystematics());
  eweight().AddEventWeight(SystId::kP0DVeto,              "P0DVeto",              new P0DVetoSystematics());
  
  // This must be called here (after adding all other systematics) such that the order in which they are added is the same as before (in baseAnalysis). 
  // Otherwise the random throws will be different. TODO. Is this still true ?
  baseAnalysis::DefineSystematics();
}

---

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

• /hep/T2K/nd280rep/ANALYSIS/HIGHLAND2/ANAPARTICLE/highland2/baseTrackerAnalysis/v2r10/src/baseTrackerAnalysis.hxx
• /hep/T2K/nd280rep/ANALYSIS/HIGHLAND2/ANAPARTICLE/highland2/baseTrackerAnalysis/v2r10/src/baseTrackerAnalysis.cxx