tutorialAnalysis Class Reference

Inherit from baseTrackerAnalysis, which inherit from basAnslysis, which inherits from AnalysisAlgorithm (in highlandCore) More...

#include <tutorialAnalysis.hxx>

Inheritance diagram for tutorialAnalysis:

Public Types
enum	enumStandardMicroTrees_tutorialAnalysis {   nLongTPCTracks = nueCCAnalysis::enumStandardMicroTreesLast_nueCCAnalysis+1, selmu_truemom, selmu_detectors, selmu_sense,   selmu_costheta, selmu_deltaPhi, selmu_pT, selmu_dir,   selmu_pos, selmu_ntpcs, selmu_tpc_det, selmu_tpc_nnodes,   selmu_tpc_mom, selmu_tpc_pos, selmu_tpc_dir, selmu_tpc_truemom,   selmu_mom, selmu_tpc_dedx, truelepton_pdg, truelepton_mom,   truelepton_pos, truelepton_dir, truelepton_costheta, enumStandardMicroTreesLast_tutorialAnalysis }
enum	enumSyst_tutorialAnalysis { kTutorialWeight = SystId::SystEnumLast_SystId+1, kTutorialVariation, enumSystLast_tutorialAnalysis }
enum	enumConf_tutorialAnalysis { tutorial_syst =enumConfLast_baseTrackerAnalysis+1, enumConfLast_btutorialAnalysis }
enum	enumConfigTree_tutorialAnalysis { nNucleonsFGD1 = enumConfigTreeLast_AnalysisAlgorithm+1, nNucleonsFGD2scint, nNucleonsFGD2water, enumConfigTreeLast_tutorialAnalysis }
Public Types inherited from baseTrackerAnalysis
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
	tutorialAnalysis (AnalysisAlgorithm *ana=NULL)
bool	Initialize ()
	[AnalysisAlgorithm_mandatory]
void	DefineSelections ()
	Add to the selection manager the selections for this analysis. More...
void	DefineCorrections ()
	[tutorialAnalysis_DefineSelections] More...
void	DefineSystematics ()
	[tutorialAnalysis_DefineCorrections] More...
void	DefineConfigurations ()
	[tutorialAnalysis_DefineSystematics] More...
void	DefineMicroTrees (bool addBase=true)
	[tutorialAnalysis_DefineConfigurations] More...
void	DefineTruthTree ()
	[tutorialAnalysis_DefineMicroTrees] More...
void	FillMicroTrees (bool addBase=true)
	[tutorialAnalysis_DefineTruthTree] More...
void	FillToyVarsInMicroTrees (bool addBase=true)
	[tutorialAnalysis_FillMicroTrees] More...
bool	CheckFillTruthTree (const AnaTrueVertex &vtx)
	[tutorialAnalysis_FillToyVarsInMicroTrees]
void	FillTruthTree (const AnaTrueVertex &vtx)
void	FillConfigTree ()
void	FillCategories ()
Public Member Functions inherited from baseTrackerAnalysis
	baseTrackerAnalysis (AnalysisAlgorithm *ana=NULL)
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 ()
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 &)
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

Additional Inherited Members
Protected Member Functions inherited from baseAnalysis
void	AddZeroVarConfiguration ()
Protected Attributes inherited from baseTrackerAnalysis
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

Detailed Description

Inherit from baseTrackerAnalysis, which inherit from basAnslysis, which inherits from AnalysisAlgorithm (in highlandCore)

Definition at line 9 of file tutorialAnalysis.hxx.

Member Function Documentation

DefineConfigurations()

void tutorialAnalysis::DefineConfigurations ( )

virtual

[tutorialAnalysis_DefineSystematics]

[tutorialAnalysis_DefineConfigurations]

Reimplemented from baseTrackerAnalysis.

Definition at line 230 of file tutorialAnalysis.cxx.

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

  /*  
      The user can run several analyses in parallel minimising the acces to disk. 
      Those parallel analyses are call configurations. Although this might be extended in the future, currenly 
      configurations only allow you to specify which systematics errors will be propagated, the number of toy experiments 
      and the random seed. 
      
      A tree for each configuration is produced in the output file, with the same name as the configuration. 
      By default a single configuration (called "default") is run, producing
      a single tree (with name default). This tree does not have any systematics enabled and hence it represents the nominal selection. 
  */

  // Some configurations are defined in baseTrackerAnalysis (have a look at baseTrackerAnalysis/vXrY/src/baseTrackerAnalysis.cxx)
  baseTrackerAnalysis::DefineConfigurations();

  Int_t ntoys = ND::params().GetParameterI("baseAnalysis.Systematics.NumberOfToys");
  Int_t randomSeed = ND::params().GetParameterI("baseAnalysis.Systematics.RandomSeed");

  // Add a new configuration called "tutorial_syst" with the following properties:
  // - the number of toys defined in the baseAnalysis parameters file
  // - the random seed for toy experiments defined in the baseAnalysis parameters file
  // - The ToyMaker used to CreateTheToyExperiments (random throws for each systematic parameter).
  //   Have a look at baseToyMaker in baseAnalysis/vXrY/src
  // - This configuration has two systematics kTutorialWeight and kTutorialVariation, defined above
  
  AddConfiguration(conf(), tutorial_syst, ntoys, randomSeed, new baseToyMaker(randomSeed));
  conf().EnableSystematic(kTutorialWeight,    tutorial_syst);  // Enable the kTutorialWeight in the tutorial_syst configuration
  conf().EnableSystematic(kTutorialVariation, tutorial_syst);  // Enable the kTutorialVariation in the tutorial_syst configuration

  // Disable the configuration when requested
  if (!ND::params().GetParameterI("tutorialAnalysis.Systematics.EnableTutorialSystematics"))
    conf().DisableConfiguration(tutorial_syst);
}

DefineCorrections()

void tutorialAnalysis::DefineCorrections ( )

virtual

[tutorialAnalysis_DefineSelections]

[tutorialAnalysis_DefineCorrections]

Reimplemented from baseTrackerAnalysis.

Definition at line 164 of file tutorialAnalysis.cxx.

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

  /* Corrections change the input data to rectify a problem in the MC or in the real data. Imagine for example that the energy deposited by a particle
     in a given sub-detector is overestimated in the MC by about 5%, and that this effect depends on the particle type (6% for muons and 4% for electrons).
     We could introduce a correction for the MC, which would scale the deposited energy by 0.94 for true muons and by 0.96 for true electrons. In this way
     we make sure that any cut using the deposited energy will have the same effect in data and MC, avoiding the corresponding systematic.

     The entire analysis will proceed on the modified data
     Corrections are only applied once per spill.
  */

  // Some corrections are defined in baseTrackerAnalysis (have a look at baseTrackerAnalysis/vXrY/src/baseTrackerAnalysis.cxx)
  baseTrackerAnalysis::DefineCorrections();

  // ----- We can add here extra corrections ----------

  // A dummy correction which moves forward the position of all global tracks by some mm, as specified in 
  // an external data file (data/tutorialCorrection.dat)
  corr().AddCorrection("tutorialCorrection", new tutorialCorrection());
}

DefineMicroTrees()

void tutorialAnalysis::DefineMicroTrees ( bool  addBase = true )

virtual

[tutorialAnalysis_DefineConfigurations]

[tutorialAnalysis_DefineMicroTrees]

Reimplemented from baseTrackerAnalysis.

Definition at line 269 of file tutorialAnalysis.cxx.

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

  /*  We call Micro-trees to the standard analysis trees appearing in the output file. 
      There is always a Micro-Tree call "default" which should contain the basic info to understand our selection. 
      The user can add extra Micro-Trees by adding configurations to the analysis (see DefineConfigurations method above).

      Here we give an example of different variables that can be added. Have a look at OutputManager.hxx under highlandCore
      to see all available methods.
  */

  // -------- Add variables to the analysis tree ----------------------

  // Variables from baseTrackerAnalysis (run, event, ..., tracker related stuff, ...)
  if (addBase) baseTrackerAnalysis::DefineMicroTrees(addBase);

  // --- Single variables -------
  AddVarD(  output(), selmu_costheta,   "muon candidate reconstructed cos(theta) w.r.t. to neutrino direction");     // Double 
  AddVarF(  output(), selmu_truemom,    "muon candidate true momentum");           // Float
  AddVarI(  output(), selmu_detectors,  "muon candidate detectors");               // Integer
  AddVarC(  output(), selmu_sense,      "muon candidate sense");                   // Char

  AddVarF(  output(), selmu_deltaPhi,   "angle between muon candidate and the proton candidate (HMP track)");             // Float 
  AddVarF(  output(), selmu_pT,         "muon candidate reconstructed transverse momentum w.r.t to neutrino direction");  // Float 

  AddVarI(  output(), nLongTPCTracks,   "number of long TPC tracks");               // Integer

  // --- Vector variables -------
  // selmu_ntpcs is the counter, which is added automatically as integer variable  
  AddVarVI(output(), selmu_tpc_det,         "muon candidate TPC number",                               selmu_ntpcs);
  AddVarVI(output(), selmu_tpc_nnodes,      "muon candidate #nodes in each TPC",                       selmu_ntpcs);  // Vector of integers
  AddVarVF(output(), selmu_tpc_mom,         "muon candidate reconstructed momentum in each TPC",       selmu_ntpcs);  // Vector of floats
  AddVarVD(output(), selmu_tpc_truemom,     "muon candidate true momentum in each TPC",                selmu_ntpcs);  // Vector of doubles

  // --- 3D and 4D vector variables (i.e. directions and positions) -------
  AddVar4VF(output(), selmu_pos,    "muon candidate reconstructed position");     // 4-Vector of floats    
  AddVar3VF(output(), selmu_dir,    "muon candidate reconstructed direction");    // 3-Vector of floats     

  // --- Matrix variables -------
  //  AddVarMF(output(), selmu_tpc, "",selmu_necals,-30,4);

  // --- 3D and 4D matrix variables (i.e. directions and positions for constituents) -------
  AddVar4MF(output(), selmu_tpc_pos,    "muon candidate true position in each tpc",  selmu_ntpcs);         
  AddVar3MF(output(), selmu_tpc_dir,    "muon candidate true direction in each tpc", selmu_ntpcs);         


  // Now we had toy-dependent variables
  // There could be many variables that are toy-dependent. We don't need to save all of them as toy variables, 
  // but only the ones we are interested in plotting for different toys. 
  // TOY VARIABLES ARE VERY SPACE CONSUMING SO WE SHOULD MINIMISE ITS NUMBER !!!!

  // --- single toy variables -------
  AddToyVarF(output(), selmu_mom,      "muon candidate reconstructed momentum");

  // --- vector toy variables -------
  AddToyVarVF(output(), selmu_tpc_dedx,    "muon candidate dEdx (CT) in each TPC", NMAXTPCS);
}

DefineSelections()

void tutorialAnalysis::DefineSelections ( )

virtual

Add to the selection manager the selections for this analysis.

[tutorialAnalysis_DefineSelections]

Implements AnalysisAlgorithm.

Definition at line 126 of file tutorialAnalysis.cxx.

                                       {
//********************************************************************
  
  /* In this method the user will add to the SelectionManager (accessed by  sel() ) the selections to be run, 
     defined in other files. In general an analysis has a single selection, which could have multiple branches. 
     Each of the branches is in fact a different selection (different cuts and actions), but defining them as branches 
     we ussualy gain in speed and simplicity since the steps that are common are applied only once. 
     Sometimes the user does not want to expend time merging two selections in a single one (as branches), but preffers to run 
     both independently. This is in general done for quick checks (are the selections mutually exclusive ?, etc). 
     This is possible in highland2. An example on how to do that is shown below. 

     In this case we add two selections to the SelectionManager provided:
     - Name of the selection (kTrackerTutorial, kTrackerTutorialBranches)
     - Title, the one dumped by the DrawingTools::DumpSelections() method. It is an explaination of the selection
     - Pointer to the selection. The argument in the constructor (false) indicates that the 
       step sequence is not broken when a cut is not passed. In this way we can save intermediate information for events 
       not passing the entire selection
   */


  // Add a simple selection with no branches
  sel().AddSelection("kTrackerTutorial",          "tutorial selection",                   new tutorialSelection(false));

  // Add a more complicated selection with branches
  sel().AddSelection("kTrackerTutorialBranches",  "tutorial selection with branches",     new tutorialBranchesSelection(false));

  // Disable the ones not enabled in parameters file
  if (!ND::params().GetParameterI("tutorialAnalysis.Selections.RunSelectionWithoutBranches"))
    sel().DisableSelection("kTrackerTutorial");

  if (!ND::params().GetParameterI("tutorialAnalysis.Selections.RunSelectionWithBranches"))
    sel().DisableSelection("kTrackerTutorialBranches");

}

DefineSystematics()

void tutorialAnalysis::DefineSystematics ( )

virtual

[tutorialAnalysis_DefineCorrections]

[tutorialAnalysis_DefineSystematics]

Reimplemented from baseTrackerAnalysis.

Definition at line 189 of file tutorialAnalysis.cxx.

                                        {
//********************************************************************
  
  /*  Systematics will modify the effective number of events passing the selection and the distribution of the observables. 

      After corrections have been applied it is possible to 
      "manipulate" again the information using Systematics. In this case the purpose is different: we want to test several values of 
      a given detector property and check the impact on the number of selected events. This allows propagating systematic errors numerically. 
      
      There are two kind of systematics:
      - Variations: modify the input data (momentum, PID variables, etc). The selection is run on the modified data such that 
        the result of the selection can be different 
      - Weights: do not modify the input data. The selection is not affected. Simply a weight is added to the event. 
        Since events with different values of a given observable (i.e. momentum ) can have different weights, 
        distributions of that observable may change.
      
      In the above example about the deposited energy (in DefineCorrections(), the correction introduced cannot be perfectly known. 
      The 4% and 6% mentioned have an error (i.e. 0.5%). 
      This error should be propagated as a systematic. A given number of toy experiments will be run with different values of the scaling parameter 
      for the deposited energy (i.e. for muons 0.93, 0.935, 0.95, ..., following
      a gaussian distribution with mean 0.94 and sigma 0.005). If a cut on the deposited energy (or a variable using it)
      is applied the number of selected events could differ depending on the scaling applied.
      The RMS of the number of selected events for all toy experiments represents the systematic error induced by the deposited energy scaling.
   */


  // Some systematics are defined in baseTrackerAnalysis (have a look at baseTrackerAnalysis/vXrY/src/baseTrackerAnalysis.cxx)
  baseTrackerAnalysis::DefineSystematics();

  // ----- We can add here extra systematics ----------

  // An example of variation systematic, which is added to the EventVariationManager
  evar().AddEventVariation(kTutorialVariation, "TutorialVarSyst",   new tutorialVariationSystematics());

  // A example of weight systematic, which is added to the EventWeightManager
  eweight().AddEventWeight(   kTutorialWeight,    "TutorialWeightSyst", new tutorialWeightSystematics());
}

DefineTruthTree()

void tutorialAnalysis::DefineTruthTree ( )

virtual

[tutorialAnalysis_DefineMicroTrees]

[tutorialAnalysis_DefineTruthTree]

[tutorialAnalysis_DefineTruthTree_info]

[tutorialAnalysis_DefineTruthTree_info]

Reimplemented from baseTrackerAnalysis.

Definition at line 334 of file tutorialAnalysis.cxx.

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

  
//! \if INTERNAL

hello
//! \endif
  
//! [tutorialAnalysis_DefineTruthTree_info]
    The main trees in the output file are the "default" and "truth" trees. The "default" tree contains all selected events (the ones that passed a given cut, ussualy 
    specified in the parameters file). This is the tree used to optimise the selection cuts, to make selection plots and to compute or plot the purity of the selection. 
    The main reason for having a separate tree, call "truth", is to allow the efficiency computation. The "default" tree does not contain all true signal events, 
    because it will be too big. The preselection for that tree is only based in reconstructed quantities (selection cuts). Instead, to compute true signal efficiencies 
    we need all true signal events to be present in the output tree. The "truth" tree fullfils this condition. Since, in general, this tree will contain many events, only a 
    reduced set of variables (the ones needed to compute the efficiency) is stored in that tree. 
    
    SUMMARY: The "truth" tree also appears in the output file. It contains all interactions in which we are interested in regardless on whether 
    the selection was passed or not. This is the tree that should be used to compute signal efficiencies
//! [tutorialAnalysis_DefineTruthTree_info]



  // Variables from baseTrackerAnalysis (run, event, ...)
  baseTrackerAnalysis::DefineTruthTree();

  //--- muon variables -------
  AddVarI(  output(), truelepton_pdg,      "true lepton PDG");
  AddVar4VF(output(), truelepton_pos,      "true lepton position");
  // Moved to baseAnalysis !!!!!!!
  //  AddVarF(  output(), truelepton_mom,      "true lepton momentum");
  //  AddVarF(  output(), truelepton_costheta, "true lepton cos(theta) w.r.t. neutrino direction");
  //  AddVar3VF(output(), truelepton_dir,      "true lepton direction"); 
}

FillMicroTrees()

void tutorialAnalysis::FillMicroTrees ( bool  addBase = true )

virtual

[tutorialAnalysis_DefineTruthTree]

[tutorialAnalysis_FillMicroTrees]

Reimplemented from baseTrackerAnalysis.

Definition at line 372 of file tutorialAnalysis.cxx.

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

  /*  In this method we fill all toy-independent variables (all except the ones added with AddToy...) defined in the method DefineMicroTrees. 
      This method is called once all toys has been run, what means that the value of all variables for the last toy will be saved. This is not a problem 
      for variables that are not expected to change from a toy to another.
  */

  // Variables from baseTrackerAnalysis (run, event, ...)
  if (addBase) baseTrackerAnalysis::FillMicroTreesBase(addBase);

  // Add a variable that is only in the derived box AnaBoxTutorial. We need to cast the base box to have access 
  output().FillVar(nLongTPCTracks, static_cast<const ToyBoxTutorial*>(&box())->nLongTPCTracks);      

  // Muon candidate variables. The MainTrack (The muon candidate) should exist in the box
  if (box().MainTrack){    

    // Since Detectors is not in BaseDataClasses (in psycheEventModel) but in DataClasses in (highlandEventModel) we need to cast 
    // the AnaTrackB pointer in box().MainTrack to the derived class AnaTrack.
    output().FillVar(selmu_detectors, static_cast<AnaTrack*>(box().MainTrack)->Detectors);      

    // Compute the cosine of the angle between the muon and the neutrino
    // vertex defined as start of muon track, neutrino direction calculated from this
    TVector3 nuDirVec = anaUtils::GetNuDirRec(box().MainTrack->PositionStart);  // Method in NuDirUtils (in psycheND280Utils)
    TVector3 muDirVec = anaUtils::ArrayToTVector3(box().MainTrack->DirectionStart);
    double costheta_mu_nu = nuDirVec.Dot(muDirVec);

    // Cast it to a double because we have defined this variable as double in DefineMicroTrees 
    // (no need to be a double, it is just to have an example of double variable)
    output().FillVar(selmu_costheta, costheta_mu_nu);
    
    // Transverse component of muon momentum calculated relative to reconstructed neutrino direction
    Float_t  nuDirArr[3]; 
    nuDirVec.GetXYZ(nuDirArr);
    Float_t  pT = anaUtils::GetTransverseMom(nuDirArr,box().MainTrack->DirectionStart,box().MainTrack->Momentum);  // Method in NuDirUtils (in psycheND280Utils)
    output().FillVar(selmu_pT, pT);

    // Coplanarity angle requires a proton... for now just assume use highest momentum +ve track    
    Float_t deltaPhi=0;
    if(box().HMPtrack)
      deltaPhi = anaUtils::GetDPhi(nuDirArr,box().MainTrack->DirectionStart,box().HMPtrack->DirectionStart); // Method in NuDirUtils (in psycheND280Utils)
    output().FillVar(selmu_deltaPhi, deltaPhi);

    // This is unnecessary here (we could use 1 and -1 which are smaller types), but serves as an example
    if (box().MainTrack->DirectionStart[2]>0)
      output().FillVar(selmu_sense,                 "forward");
    else
      output().FillVar(selmu_sense,                 "backward");

    // This is the way we fill 3 and 4-vectors. Must specify the array size when using FillVectorVarFromArray
    output().FillVectorVarFromArray(selmu_pos,    box().MainTrack->PositionStart,  4);
    output().FillVectorVarFromArray(selmu_dir,    box().MainTrack->DirectionStart, 3);

    // Properties of the true particle associated to the muon candidate. 
    // We can also acces the truth with box().MainTrack->TrueObject, but this is of the more basic type AnaTrueObjectC, which does not have Momentum. The GetTrueParticle() method 
    // just do the casting
    if(  box().MainTrack->GetTrueParticle() ) {
      output().FillVar(selmu_truemom,             box().MainTrack->GetTrueParticle()->Momentum);
    }

    // Info in all TPCs 
    for (Int_t subdet = 0; subdet<3; subdet++) {
      if (!SubDetId::GetDetectorUsed(box().MainTrack->Detector, static_cast<SubDetId::SubDetEnum >(subdet+2))) continue;
      AnaTPCParticle* TPCSegment = static_cast<AnaTPCParticle*>(anaUtils::GetSegmentInDet( *box().MainTrack,static_cast<SubDetId::SubDetEnum >(subdet+2)));
      if (!TPCSegment) continue;
      output().FillVectorVar(selmu_tpc_det,     subdet);
      output().FillVectorVar(selmu_tpc_mom,     TPCSegment->Momentum);
      output().FillVectorVar(selmu_tpc_nnodes,  TPCSegment->NNodes);

      // Must specify the array size when using FillMatrixVarFromArray
      output().FillMatrixVarFromArray(selmu_tpc_pos,    TPCSegment->PositionStart,  4);
      output().FillMatrixVarFromArray(selmu_tpc_dir,    TPCSegment->DirectionStart, 3);

      if (TPCSegment->GetTrueParticle()){
        // Cast it to a double because we have defined this variable as double in DefineMicroTrees
        // (no need to be a double, it is just to have an example of double variable)
        output().FillVectorVar(selmu_tpc_truemom, (Double_t)TPCSegment->GetTrueParticle()->Momentum);
      }
      
      // increment the value of the counter for all TPC variables (selmu_ntpcs)
      // The same effect will have output().IncrementCounter(selmu_ntpcs);
      output().IncrementCounterForVar(selmu_tpc_det);
    }
  }
  
}

FillToyVarsInMicroTrees()

void tutorialAnalysis::FillToyVarsInMicroTrees ( bool  addBase = true )

virtual

[tutorialAnalysis_FillMicroTrees]

[tutorialAnalysis_FillToyVarsInMicroTrees]

Reimplemented from baseTrackerAnalysis.

Definition at line 462 of file tutorialAnalysis.cxx.

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

  /*  In this method we fill all toy-dependent variables (the ones added with AddToy...) defined in the method DefineMicroTrees. 
      This method is called at the end of each toy.

      There could be many variables that are toy-dependent. We don't need to save all of them as toy variables, but only the ones we are interested in plotting 
      for different toys. 

      TOY VARIABLES ARE VERY SPACE CONSUMING SO WE SHOULD MINIMISE ITS NUMBER !!!!
  */

  // Fill the common variables
  if (addBase) baseTrackerAnalysis::FillToyVarsInMicroTreesBase(addBase);

  //---- variables specific for this analysis -----
  if (box().MainTrack){
    // Since we are applying a systematic that varies the momentum we need to save the momentum for each toy
    output().FillToyVar(selmu_mom, box().MainTrack->Momentum);    

    // Info in all TPCs 
    for (Int_t subdet = 0; subdet<3; subdet++) {
      if (!SubDetId::GetDetectorUsed(box().MainTrack->Detector, static_cast<SubDetId::SubDetEnum >(subdet+2))) continue;
      AnaTPCParticle* TPCSegment = static_cast<AnaTPCParticle*>(anaUtils::GetSegmentInDet( *box().MainTrack, static_cast<SubDetId::SubDetEnum >(subdet+2)));
      if (!TPCSegment) continue;
      // In principle we need this variable here when PID systematics are run
      output().FillToyVectorVar(selmu_tpc_dedx,   TPCSegment->dEdxMeas, subdet);
    }
  }
}

---

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

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