XAMPPmonoH reference

class AbsEqualCondition : public XAMPP::Condition

#include <Cuts.h>

Public Functions

bool PassScalar() const

bool PassVector(size_t entry) const

bool PassMatrix(size_t column, size_t row) const

std::string name() const

class AbsGreaterCondition : public XAMPP::Condition

#include <Cuts.h>

Public Functions

bool PassScalar() const

bool PassVector(size_t entry) const

bool PassMatrix(size_t column, size_t row) const

std::string name() const

class AbsGreaterEqualCondition : public XAMPP::Condition

#include <Cuts.h>

Public Functions

bool PassScalar() const

bool PassVector(size_t entry) const

bool PassMatrix(size_t column, size_t row) const

std::string name() const

class AbsIParticleVarReader : public XAMPP::IParticleVariable

#include <UtilityReader.h>

IParticleVarReader stuff.

Public Functions

double readEntry(size_t I) const

std::string name() const

bool init(TTree *t)

Public Static Functions

IParticleVarReader *GetReader(IParticleVarReader *R)

Protected Functions

AbsIParticleVarReader(IParticleVarReader *R)

Protected Attributes

IParticleVarReader *m_Var

bool m_Registered

class AbsLessCondition : public XAMPP::Condition

#include <Cuts.h>

Public Functions

bool PassScalar() const

bool PassVector(size_t entry) const

bool PassMatrix(size_t column, size_t row) const

std::string name() const

class AbsLessEqualCondition : public XAMPP::Condition

#include <Cuts.h>

Public Functions

bool PassScalar() const

bool PassVector(size_t entry) const

bool PassMatrix(size_t column, size_t row) const

std::string name() const

class AbsNotEqualCondition : public XAMPP::Condition

#include <Cuts.h>

Public Functions

bool PassScalar() const

bool PassVector(size_t entry) const

bool PassMatrix(size_t column, size_t row) const

std::string name() const

struct AdditionalBranches

Public Functions

AdditionalBranches(bool S, DataVectorStorage::StoreVariable D, const std::string &acc_name)

Public Members

DataVectorStorage::StoreVariable DataType

bool SaveSyst

std::string AccessorName

Define a different accesor than the branch name.

class Analysis

#include <Analysis.h>

Class for analysis.

Subclassed by XAMPP::NTupleWriter, XAMPP::Selector, XAMPP::SubSetAnalysis

Public Functions

Analysis()

~Analysis()

bool Process(long int nMax = -1, long int nSkip = 0)

Process the loop on the events.

Return

{ description_of_the_return_value }

Parameters

• nMax: The maximum
• nSkip: The skip

void SetName(const std::string &N)

Set the name of the analysis.

Parameters

• N: { parameter_description }

void SetRegion(const std::string &Region)

Sets the name of the region in your analysis.

Parameters

• Region: The region

std::string name() const

Get the name of the analysis.

Return

{ description_of_the_return_value }

void SetTreeName(const std::string &Name)

Sets the tree name.

Parameters

• Name: The name

void SetInputFiles(const std::vector<std::string> &Files)

Sets the input files.

Parameters

• Files: The files

void SetOutputLocation(const std::string &File)

Sets the output location.

Parameters

• File: The file

void FinalizeOutput()

{ function_description }

void SetReaders(const std::vector<ITreeVarReader *> &R)

Sets the readers.

Parameters

• R: { parameter_description }

void SetCuts(const std::vector<std::shared_ptr<Condition>> &C)

Sets the cuts.

Parameters

• C: { parameter_description }

void SetHistos(const std::vector<std::shared_ptr<Histo>> &H)

Sets the histos.

Parameters

• H: { parameter_description }

void ProcessSystematics(bool B)

{ function_description }

Parameters

• B: { parameter_description }

void ProcessWeightVariations(bool B)

{ function_description }

Parameters

• B: { parameter_description }

void ProcessNominal(bool B)

{ function_description }

Parameters

• B: { parameter_description }

void SetNominalName(const std::string &Nominal)

Sets the nominal name.

Parameters

• Nominal: The nominal

void DoCutFlow(bool B)

{ function_description }

Parameters

• B: { parameter_description }

void SetSystematics(const std::vector<std::string> &List)

Give a specific list of systematics.

Parameters

• List: The list

void SetWeightSystmatics(const std::vector<std::string> &List)

Give a specific list of systematics affecting the event weights.

Parameters

• List: The list

void SetSystSuffixName(const std::string &N)

Sets the syst suffix name.

Parameters

• N: { parameter_description }

void SetSystNames(const std::map<std::string, std::string> &Names)

Sets the syst names.

Parameters

• Names: The names

bool RenameSystematic(const std::string &From, const std::string &To)

void DisableProgressBar()

Disables the progress bar.

void setBatchMode()

Protected Functions

bool initBranches(const std::string &Syst)

{ function_description }

Return

{ description_of_the_return_value }

Parameters

• Syst: The syst

void AppendReader(ITreeVarReader *R)

Appends a reader.

Parameters

• R: { parameter_description }

bool AppendHisto(std::shared_ptr<Histo> H)

Appends a histo.

Return

{ description_of_the_return_value }

Parameters

• H: { parameter_description }

bool init(const std::string &Syst)

{ function_description }

Return

{ description_of_the_return_value }

Parameters

• Syst: The syst

bool ReadMetaDataTree()

Reads a meta data tree.

Return

{ description_of_the_return_value }

bool SetupHistograms(const std::string &Syst)

{ function_description }

Return

{ description_of_the_return_value }

Parameters

• Syst: The syst

TDirectory *CreateDirectory(const std::string &Syst, const std::string &Region)

Creates a directory.

Return

{ description_of_the_return_value }

Parameters

• Syst: The syst
• Region: The region

std::string GetDirectoryName(const std::string &Syst, const std::string &Region) const

Gets the directory name.

Return

The directory name.

Parameters

• Syst: The syst
• Region: The region

bool AnalyzeEvent()

{ function_description }

Return

{ description_of_the_return_value }

void WriteOutput()

Writes an output.

bool HandleWeightVariations()

{ function_description }

Return

{ description_of_the_return_value }

Parameters

• nMax: The maximum
• nSkip: The skip

bool PassCuts(bool PassAnd = true) const

{ function_description }

Return

{ description_of_the_return_value }

Parameters

• PassAnd: The pass and

std::string NominalName() const

std::string getFinalSystName(const std::string &syst) const

Protected Attributes

std::string m_SystAppendix

XAMPP::NormalizationDataBase *m_NormDB

XAMPP::Weight *m_weight

std::shared_ptr<TFile> m_outFile

Private Functions

bool ReadSystematics()

Reads systematics.

Return

{ description_of_the_return_value }

bool SetupInTree()

{ function_description }

Return

{ description_of_the_return_value }

bool LoadTreeFromFile(std::shared_ptr<TFile> F, const std::string &Syst)

Loads a tree from file.

Return

{ description_of_the_return_value }

Parameters

• F: { parameter_description }
• Syst: The syst

void FillCutFlowHistograms(int N) const

{ function_description }

Parameters

• N: { parameter_description }

bool ProcessLoop(const std::shared_ptr<IKinematicSyst> &syst, long int nMax = -1, long int nSkip = 0)

{ function_description }

Return

{ description_of_the_return_value }

Parameters

• Syst: The syst
• nMax: The maximum
• nSkip: The skip

bool ProcessTree(long int nMax = -1, long int nSkip = 0)

{ function_description }

Return

{ description_of_the_return_value }

Parameters

• nMax: The maximum
• nSkip: The skip

bool GetTotalEvents()

Gets the total events.

Return

The total events.

bool SetupCutFlow()

{ function_description }

Return

{ description_of_the_return_value }

void Progress()

Prints the progress bar during runtime.

Private Members

EventService *m_eventService

bool m_batchMode

bool m_DoSyst

bool m_DoSyst_W

bool m_DoNominal

bool m_DoCutFlow

std::vector<std::string> m_Systematics

std::vector<std::string> m_Systematics_W

std::vector<std::string> m_input_dirs

std::vector<std::shared_ptr<IKinematicSyst>> m_systToRun

std::map<std::string, std::string> m_SystNames

std::vector<std::shared_ptr<Condition>> m_Cuts

std::vector<std::shared_ptr<Histo>> m_Histos

TTree *m_tree

std::shared_ptr<Histo> m_CutFlow

std::shared_ptr<Histo> m_RawCutFlow

std::string m_TreeName

std::string m_Name

std::string m_Region

long int m_TotEvents

long int m_CurrentEvent

long int m_PrintInterval

TStopwatch m_tsw

bool m_PrintProgress

std::string m_NominalName

class AnalysisConfig : public AsgTool, public virtual XAMPP::IAnalysisConfig

#include <AnalysisConfig.h>

Class for defining different CutFlows.

Subclassed by XAMPP::MonoHAnalysisConfig, XAMPP::TruthAnalysisConfig

Public Functions

AnalysisConfig(const std::string &Analysis)

{ function_description }

Parameters

• Analysis: The analysis

~AnalysisConfig()

Destroys the object.

StatusCode initialize()

{ function_description }

Return

{ description_of_the_return_value }

StatusCode AddToCutFlows(CutFlow &cf)

bool ApplyCuts(CutKind K)

{ function_description }

Return

{ description_of_the_return_value }

Parameters

• K: { parameter_description }

std::vector<std::string> GetCutNames(int hash = 0) const

Gets the cut names.

Return

The cut names.

Parameters

• hash: The hash

std::string TreeName() const

{ function_description }

Return

{ description_of_the_return_value }

bool RegisterHistoBase(HistoBase *Base)

{ function_description }

Return

{ description_of_the_return_value }

Parameters

• Base: The base

Cut *NewCut(const std::string &Name, Cut::CutType T, bool IsSkimming)

Protected Functions

bool isData() const

StatusCode initializeCustomCuts()

StatusCode initializeStandardCuts()

bool isActive(CutFlow &cf) const

Cut *NewSkimmingCut(const std::string &Name, Cut::CutType T)

Cut *NewCutFlowCut(const std::string &Name, Cut::CutType T)

unsigned int NumActiveCutFlows() const

Protected Attributes

EventInfo *m_XAMPPInfo

CutRow m_StandardCuts

Private Types

typedef std::pair<const CP::SystematicSet *, const CutFlow *> SystSelectionPair

Private Functions

bool PassStandardCuts(unsigned int &N) const

IHistoVariable *FindCutFlowHisto(const CP::SystematicSet *Set, const CutFlow *Flow) const

Private Members

std::string m_treeName

std::vector<std::string> m_ActiveCutflows

std::string m_ActiveCutflowsString

std::vector<CutFlow> m_CutFlows

CutRow m_DefinedCuts

std::map<SystSelectionPair, IHistoVariable *> m_CutFlowHistos

bool m_init

asg::AnaToolHandle<XAMPP::IEventInfo> m_InfoHandle

ToolHandle<ISystematics> m_systematics

class AnalysisRegion

#include <AnalysisSetup.h>

Public Functions

AnalysisRegion(const std::string &Name)

~AnalysisRegion()

std::string name() const

bool AppendCut(std::vector<std::shared_ptr<Condition>> Cuts)

bool AppendCut(std::shared_ptr<Condition> C)

bool PrependCut(std::vector<std::shared_ptr<Condition>> Cuts)

bool PrependCut(std::shared_ptr<Condition> C)

void Finalize()

const std::vector<std::shared_ptr<Condition>> &GetCuts() const

std::shared_ptr<Condition> RetrieveCompressedCut()

ITreeVarReader *RegionReader() const

std::shared_ptr<Histo> CreateHistoArray(const std::vector<std::shared_ptr<Histo>> &HistosToUse, bool DoCutFlow)

Private Members

std::string m_RegionName

bool m_Init

std::vector<std::shared_ptr<Condition>> m_Cuts

std::shared_ptr<Condition> m_SummarizedCut

ITreeVarReader *m_region_reader

class AnalysisSetup

#include <AnalysisSetup.h>

Public Functions

AnalysisSetup()

~AnalysisSetup()

void SetOutputLocation(const std::string &File)

bool ParseConfig(std::string HistoConfig, std::string RunConfig, std::string InputConfig)

bool ParseTreeConfig(std::string TreeConfig, std::string InputConfig)

std::shared_ptr<Analysis> SetupAnalyses(unsigned int begin = 0, unsigned int end = -1)

std::shared_ptr<Analysis> SetupNTupleWriters(unsigned int begin = 0, unsigned int end = -1)

std::shared_ptr<Analysis> SetupEventChecker()

void LoadWeightsOnly()

void ignoreMetaInput()

std::vector<std::string> inputFiles() const

Protected Types

enum PropertyStatus

Values:

Failure = 0

NothingFound

New

typedef bool (AnalysisSetup::*ConfigReader)(std::ifstream &inf)

Protected Functions

int CheckAnaConfigProperties(std::ifstream &inf, const std::string &line)

int CheckInputConfigProperties(std::ifstream &inf, const std::string &line)

bool ReadInputFiles(std::ifstream &inf)

bool ReadAnaConfig(std::ifstream &inf)

bool loadWeightsOnly() const

void ParseOptionsToAnalysis(std::shared_ptr<Analysis> Ana, unsigned int begin = 0, unsigned int end = -1)

bool FinalizeActRegion()

bool InitMetaData()

void ClearVectors()

void SetCrossSectionDir()

Protected Attributes

std::vector<ITreeVarReader *> m_Readers

std::string m_Tree

std::string m_SampleName

std::string m_AnaName

std::string m_outFile

std::vector<std::string> m_ImportedConfigs

std::map<std::string, std::shared_ptr<AnalysisRegion>> m_RegionCuts

std::shared_ptr<AnalysisRegion> m_ActRegion

std::shared_ptr<Analysis> m_Analysis

std::string m_NominalName

bool m_SetNominalName

Private Functions

bool ReadHistoConfig(std::ifstream &inf)

bool ReadTreeConfig(std::ifstream &inf)

bool ImportFile(const std::string &Config, ConfigReader Parser, bool always = false)

bool CreateNewRegion(const std::string &Name)

bool RenameSystematic(std::stringstream &sstr)

bool ReplaceStringOfSystematic(std::stringstream &sstr)

void setPRWperiod(std::stringstream &sstr)

Private Members

std::vector<std::string> m_InputFiles

std::vector<std::string> m_MetaInputFiles

std::vector<std::string> m_PRWlumiFiles

std::vector<std::string> m_PRWconfigFiles

std::vector<std::string> m_Systematics

std::vector<std::string> m_Weights

std::vector<std::string> m_DataWeights

std::vector<std::string> m_WeightSystematics

std::vector<std::shared_ptr<Condition>> m_Cuts

std::vector<std::shared_ptr<Histo>> m_Histos

bool m_NormSUSYprocs

bool m_ApplyXS

bool m_doSyst

bool m_doSystW

bool m_doNominal

bool m_doCutFlow

bool m_ignoreMetaInputs

std::vector<ITreeVarWriter *> m_Branches

std::map<std::string, std::string> m_ReplaceBranchNames

std::map<std::string, std::string> m_ReplaceSystNames

std::map<std::string, std::string> m_ReplaceStringOfSyst

std::string m_SystPrefix

bool m_LoadWeightsOnly

std::string m_xSecDirSig

std::string m_xSecDirBkg

std::unique_ptr<XAMPP::DMXSecUpdater> m_DMXSec

bool m_Debug

std::vector<std::string> m_GRLs

std::shared_ptr<UniqueEventCondition> m_uniqueRun

template <class T>
class ArrayReader : public XAMPP::IVectorReader

#include <TreeVarReader.h>

Public Functions

std::string name() const

double readEntry(const size_t I) const

size_t entries() const

bool init(TTree *t)

~ArrayReader()

Public Static Functions

ArrayReader<T> *GetReader(const std::string &varname, ITreeVarReader *Size = nullptr, unsigned int Cache = 50)

Protected Functions

ArrayReader(const std::string &varname, ITreeVarReader *SizeBranch, unsigned int Cache)

ArrayReader(const ArrayReader&)

void operator=(const ArrayReader&)

Private Members

bool m_Registered

std::string m_var_name

T *m_var

Long64_t m_lastEvent

unsigned int m_TreeNumber

TBranch *m_branch

EventService *m_evService

TreeIndexer *m_indexer

ITreeVarReader *m_Size

class BaseAnalysisModule : public AsgTool, public virtual XAMPP::IAnalysisModule

#include <BaseAnalysisModule.h>

Public Functions

BaseAnalysisModule(const std::string &myname)

~BaseAnalysisModule()

StatusCode initialize()

Protected Functions

StatusCode fillDefaultValues()

StatusCode bookParticleStore(const std::string &name, ParticleStorage *&store, bool use_mass = true, bool saveVariations = true, bool writeTrees = true)

std::string full_name(const std::string &name) const

std::string getGroupName() const

template <typename T>
StatusCode newVariable(const std::string &name, XAMPP::Storage<T> *&store, bool saveToTree = true, bool SaveVariations = true)

template <typename T, typename T1>
StatusCode newVariable(const std::string &name, const T1 &def, XAMPP::Storage<T> *&store, bool saveToTree = true, bool SaveVariations = true)

StatusCode retrieve(XAMPP::ParticleStorage *&store, const std::string &name)

Protected Attributes

asg::AnaToolHandle<XAMPP::IReconstructedParticles> m_ParticleConstructor

XAMPP::EventInfo *m_XAMPPInfo

Private Members

asg::AnaToolHandle<XAMPP::IEventInfo> m_InfoHandle

std::vector<std::unique_ptr<IStorageDefaultValues>> m_defaults

std::string m_groupName

bool m_suffixNotation

class BinnedDataTakingReader : public XAMPP::IScalarReader

#include <UtilityReader.h>

Public Functions

bool init(TTree *t)

std::string name() const

double read() const

~BinnedDataTakingReader()

Public Static Functions

ITreeVarReader *GetReader(double lumi_slice)

Private Functions

BinnedDataTakingReader(double lumi_slice)

BinnedDataTakingReader(const BinnedDataTakingReader&)

void operator=(const BinnedDataTakingReader&)

Private Members

double m_lumi_slice

ITreeVarReader *m_run_reader

ITreeVarReader *m_lumi_reader

std::unique_ptr<LumiSlicer> m_lumi_slices

bool m_Registered

class BTagJetWeight : public XAMPP::JetWeightDecorator

#include <SUSYJetSelector.h>

Public Functions

BTagJetWeight(ToolHandle<IBTaggingEfficiencyTool> &SFTool)

~BTagJetWeight()

bool PassSelection(const xAOD::Jet &jet) const

void SetBJetEtaCut(float eta)

Protected Functions

StatusCode calculateEfficiencySF(const xAOD::Jet &Jet, float &SF)

StatusCode calculateInefficiencySF(const xAOD::Jet &Jet, float &SF)

Private Members

ToolHandle<IBTaggingEfficiencyTool> m_SFTool

float m_bJetEtaCut

class Classification

#include <UtilityReader.h>

Subclassed by XAMPP::ClassificationReader::ReplicatedClassification

Public Functions

bool isSatisfied()

ITreeVarReader *reader() const

size_t entries()

double readEntry(size_t e) const

Classification(ITreeVarReader *R, std::shared_ptr<Condition> C)

bool passThrough() const

void setBegin(size_t b)

size_t begin()

size_t end()

Private Members

std::shared_ptr<Condition> m_Cut

ITreeVarReader *m_Reader

bool m_isSatisfied

Long64_t m_eventNumber

EventService *m_service

size_t m_begin

class ClassificationReader : public XAMPP::IVectorReader

#include <UtilityReader.h>

Public Functions

bool init(TTree *t)

std::string name() const

size_t entries() const

double readEntry(size_t i) const

bool AddClassification(std::shared_ptr<Condition> Cond, ITreeVarReader *Obj, ITreeVarReader *Replica = nullptr)

bool AddClassification(std::ifstream &inf)

void SetupDone()

~ClassificationReader()

Public Static Functions

ClassificationReader *GetReader(const std::string &Name)

Protected Types

typedef std::shared_ptr<Classification> Classification_Ptr

Protected Functions

ClassificationReader(const std::string &Name)

ClassificationReader(const ClassificationReader&)

void operator=(const ClassificationReader&)

Private Members

std::string m_Name

bool m_Regist

bool m_Setup

std::vector<Classification_Ptr> m_Classification

std::vector<ITreeVarReader *> m_CutPartReaders

size_t m_tot_entries

Long64_t m_currentEv

EventService *m_service

Classification_Ptr m_currentObj

class CombCutAND : public XAMPP::CompositeCut

#include <Cuts.h>

Public Functions

CombCutAND(Cut *C1, Cut *C2)

bool ApplyCut(bool ForCutFlow = false)

std::string GetName() const

virtual ~CombCutAND()

class CombCutOR : public XAMPP::CompositeCut

#include <Cuts.h>

Public Functions

CombCutOR(Cut *C1, Cut *C2)

bool ApplyCut(bool ForCutFlow = false)

std::string GetName() const

virtual ~CombCutOR()

class CombinatoricService

#include <CombinatoricSelection.h>

Public Functions

~CombinatoricService()

std::shared_ptr<DrawElementsFromSet> comb_to_draw(unsigned int n, unsigned k, unsigned int offset = 0)

bool next()

unsigned int current_combinatoric() const

void attach(IPermutationElement *element)

void detach(IPermutationElement *element)

Long64_t last_cached_event() const

std::vector<IPermutationElement *> permuations() const

bool has_permutable() const

Public Static Functions

CombinatoricService *getService()

Private Functions

CombinatoricService()

void operator=(const CombinatoricService&)

CombinatoricService(const CombinatoricService&)

Private Members

Weight *m_weighter

EventService *m_service

std::vector<std::shared_ptr<DrawElementsFromSet>> m_draw_sets

std::vector<IPermutationElement *> m_permut_ele

Long64_t m_event_number

unsigned int m_combinations

unsigned int m_ptr

bool m_cleared

Private Static Attributes

CombinatoricService *m_Inst = nullptr

class CombinedFakeFactor : public XAMPP::FakeFactor

#include <DataDrivenWeights.h>

The combined fake-factor combines process fraction, fake-rate and scale-factor of each particle to a single weight

Public Functions

CombinedFakeFactor()

double Evaluate(size_t entry)

Calculate the fake-factor weight finally.

bool init(TTree *t)

Initialize the access to the TTree as usual.

int sign() const

Sign of the fake-factor in the event.

std::shared_ptr<FakeFactor> clone() const

bool applyUncertainty(double w)

Apply an uncertainty based on +- w*sigma.

bool add_fake_factor(const std::shared_ptr<FakeFactor> &ff)

Add a component to the combination the method returns falls either if the particle is not the one given by particle() or the ff is a nullptr.

Private Members

std::vector<std::shared_ptr<FakeFactor>> m_ff

class CombinedP4VarReader : public XAMPP::IParticleVariable

#include <ReconstructedParticleReaders.h>

Public Functions

std::string name() const

double readEntry(size_t I) const

bool init(TTree *t)

Public Static Functions

IParticleVarReader *GetReader(CombinedParticleReader *Reader, const std::string &Var)

Private Functions

CombinedP4VarReader(CombinedParticleReader *Reader, const std::string &component)

CombinedP4VarReader(const CombinedP4VarReader&)

void operator=(const CombinedP4VarReader&)

Private Members

CombinedParticleReader *m_Particle

std::string m_VarName

std::function<double(size_t)> m_func

class CombinedParticleReader : public XAMPP::IParticleCollection

#include <ReconstructedParticleReaders.h>

Public Functions

std::string name() const

bool init(TTree *t)

IParticleVarReader *RetrieveVariable(const std::string &Var)

size_t Size()

size_t ReaderIndex() const

size_t ReaderIndex(size_t P)

unsigned int GetCollectionHash() const

const TLorentzVector &P4() const

Actually this method is a dummy method.

TLorentzVector GetP4(size_t E)

IParticleReader *first_incoming() const

IParticleReader *second_incoming() const

std::shared_ptr<TensorCombination> get_combination(size_t E)

Public Static Functions

CombinedParticleReader *GetReader(const std::string &Name, const std::string &First = "", const std::string &Second = "")

Private Functions

CombinedParticleReader(const std::string &name, const std::string &first, const std::string &second)

CombinedParticleReader(const CombinedParticleReader&)

void operator=(const CombinedParticleReader&)

Private Members

std::string m_name

IParticleReader *m_first

Pointer to the first particle.

IParticleReader *m_second

unsigned int m_hash

std::vector<std::shared_ptr<TensorCombination>> m_combinations

Allowed possibilities to combine the two input containers.

Weight *m_weighter

Let’s use the weighter to keep track of the current event.

Long64_t m_ev_number

class CombinedParticleVarReader : public XAMPP::IParticleVariable

#include <ReconstructedParticleReaders.h>

Public Functions

double readEntry(size_t I) const

std::string name() const

bool init(TTree *t)

Private Functions

CombinedParticleVarReader(CombinedParticleReader *particle, const std::string &var, MathITreeVarReader::ArithmetricOperators O = MathITreeVarReader::ArithmetricOperators::Unknown)

CombinedParticleVarReader(const CombinedParticleVarReader&)

void operator=(const CombinedParticleVarReader&)

Private Members

CombinedParticleReader *m_particle

MathITreeVarReader::ArithmetricOperators m_operator

IParticleVarReader *m_first_var

IParticleVarReader *m_second_var

bool m_Registered

std::shared_ptr<BinaryFunc> m_func

Weight *m_weighter

Long64_t m_evNumber

std::vector<double> m_cached

class CompositeCondition : public XAMPP::Condition

#include <Cuts.h>

Subclassed by XAMPP::CompositeConditionAND, XAMPP::CompositeConditionOR, XAMPP::ConditionNOT

Public Functions

CompositeCondition(std::shared_ptr<Condition> Cut1, std::shared_ptr<Condition> Cut2)

~CompositeCondition()

Protected Attributes

std::shared_ptr<Condition> m_cut_1

std::shared_ptr<Condition> m_cut_2

class CompositeConditionAND : public XAMPP::CompositeCondition

#include <Cuts.h>

Composition of two cuts via AND or OR relation.

Public Functions

CompositeConditionAND(std::shared_ptr<Condition> Cut1, std::shared_ptr<Condition> Cut2)

bool Pass() const

bool PassScalar() const

bool PassVector(size_t entry) const

bool PassMatrix(size_t column, size_t row) const

std::string name() const

virtual ~CompositeConditionAND()

class CompositeConditionOR : public XAMPP::CompositeCondition

#include <Cuts.h>

Public Functions

CompositeConditionOR(std::shared_ptr<Condition> Cut1, std::shared_ptr<Condition> Cut2)

bool Pass() const

bool PassScalar() const

bool PassVector(size_t entry) const

bool PassMatrix(size_t column, size_t row) const

std::string name() const

virtual ~CompositeConditionOR()

class CompositeCut : public XAMPP::Cut

#include <Cuts.h>

Subclassed by XAMPP::CombCutAND, XAMPP::CombCutOR

Public Functions

CompositeCut(Cut *C1, Cut *C2)

~CompositeCut()

bool IsInitialized() const

void Disconnect(Cut *C)

Protected Attributes

Cut *m_Cut1

Cut *m_Cut2

class Condition

#include <Cuts.h>

Subclassed by XAMPP::AbsEqualCondition, XAMPP::AbsGreaterCondition, XAMPP::AbsGreaterEqualCondition, XAMPP::AbsLessCondition, XAMPP::AbsLessEqualCondition, XAMPP::AbsNotEqualCondition, XAMPP::CompositeCondition, XAMPP::EqualCondition, XAMPP::GreaterCondition, XAMPP::GreaterEqualCondition, XAMPP::GRLCondition, XAMPP::LessCondition, XAMPP::LessEqualCondition, XAMPP::NotEqualCondition, XAMPP::ParticleTaggerCut, XAMPP::UniqueEventCondition

Public Types

enum Mode

Values:

inDef

AND

OR

NOTOR

NOTAND

Public Functions

Condition()

bool Pass() const

virtual bool PassScalar() const = 0

virtual bool PassVector(size_t entry) const = 0

virtual bool PassMatrix(size_t column, size_t row) const = 0

bool Init(ITreeVarReader *Reader, double Value)

bool InitVector(ITreeVectorReader *Vector, double Value)

bool InitMatrix(ITreeMatrixReader *Matrix, double Value)

virtual std::string name() const = 0

~Condition()

Public Static Functions

std::shared_ptr<Condition> Combine(std::shared_ptr<Condition> first, std::shared_ptr<Condition> second, Mode mode = AND)

Protected Functions

std::string reader_name() const

Protected Attributes

ITreeVarReader *m_Reader

ITreeVectorReader *m_VectorReader

ITreeMatrixReader *m_MatrixReader

double m_CutValue

Private Members

bool m_hasScalarReader

bool m_hasVectorReader

bool m_hasMatrixReader

bool m_init

class ConditionalVariations

#include <DataDrivenWeights.h>

Public Functions

ConditionalVariations(const std::string &Variation, ConditionalWeight &Conditional)

void AppendConditional(const std::vector<ConditionalWeight::CondWeight> &Weighters)

void AppendConditional(ConditionalWeight::CondWeight Cond)

void NewEvent(bool UseWeighter = false)

ITreeVarReader *GetTreeVarReader()

std::string variation()

Protected Attributes

std::string m_VarName

ConditionalWeight &m_RefInstance

std::map<ITreeVarReader *, IWeightElement *> m_Weights

PseudoScalarVarReader *m_PseudoReader

class ConditionalWeight : public XAMPP::IWeightElement

#include <DataDrivenWeights.h>

Weights administrated by the conditional weight are going to be applied if user specified conditions are satisfied

Public Functions

std::string name() const

bool init(TTree *t)

double read()

ITreeVarReader *GetTreeVarReader()

ITreeVarReader *GetSystematicReader(const std::string &Syst)

std::vector<std::string> FindWeightVariations(TTree *Tree)

IWeightElement::SystStatus ApplySystematic(const std::string &variation)

void ResetSystematic()

std::vector<std::string> GetWeightVariations()

~ConditionalWeight()

bool LoadConfiguration(std::ifstream &inf, std::vector<ITreeVarReader *> &Readers)

bool AppendWeightElement(IWeightElement *Weight, std::shared_ptr<Condition> Cut)

bool IsWeightApplied()

bool ApplyWeighter(IWeightElement *Weight) const

Public Static Functions

ConditionalWeight *GetWeighter(const std::string &Name)

Protected Types

typedef std::shared_ptr<ConditionalWeight::ConditionalVariations> Conditional_Ptr

Protected Functions

ConditionalWeight(const std::string &Name)

ConditionalWeight(const ConditionalWeight&)

void operator=(const ConditionalWeight&)

void UpdateCuts()

bool GetWeightElement(std::ifstream &inf, std::vector<ITreeVarReader *> &Readers)

bool LoadSystematic(const std::string &Variation = "")

Protected Attributes

std::string m_Name

std::vector<CondWeight> m_Weighters

std::vector<Conditional_Ptr> m_Variations

std::vector<Conditional_Ptr>::iterator m_VarItr

std::vector<Conditional_Ptr>::iterator m_VarEndItr

bool m_Init

bool m_Registered

unsigned int m_eventNumber

XAMPP::Weight *m_weightService

bool m_disabled

class ConditionalWeightAppliedReader : public XAMPP::IScalarReader

#include <UtilityReader.h>

Public Functions

double read() const

bool init(TTree *t)

std::string name() const

Public Static Functions

ITreeVarReader *GetReader(const std::string &Name)

ITreeVarReader *GetReader(ConditionalWeight *Weight)

Protected Functions

ConditionalWeightAppliedReader(ConditionalWeight *Weight)

ConditionalWeightAppliedReader(const ConditionalWeightAppliedReader&)

void operator=(const ConditionalWeightAppliedReader&)

Protected Attributes

ConditionalWeight *m_Weight

bool m_Registered

class ConditionNOT : public XAMPP::CompositeCondition

#include <Cuts.h>

Public Functions

ConditionNOT(std::shared_ptr<Condition> Cut)

bool Pass() const

bool PassScalar() const

bool PassVector(size_t entry) const

bool PassMatrix(size_t column, size_t row) const

std::string name() const

struct CondWeight

#include <DataDrivenWeights.h>

Public Members

IWeightElement *Weight

std::shared_ptr<Condition> Cut

bool Passed = false

class ContainerTaggerCut : public XAMPP::ParticleTaggerCut

#include <ParticleTagger.h>

Public Functions

ContainerTaggerCut(IParticleReader *reader, const std::string &tagger_name)

bool PassVector(size_t entry) const

Protected Functions

std::shared_ptr<IParticleTagger> FillUp(int begin, int end) const

Protected Attributes

std::shared_ptr<IParticleTagger> m_max_tagger

class CorruptedFileChecker

#include <MergeHelpers.h>

Public Static Functions

bool isFileOk(const std::string &path)

bool isFileOk(std::shared_ptr<TFile> f)

std::vector<unsigned int> getLHEWeights(std::shared_ptr<TFile> f)

std::vector<unsigned int> getLHEWeights(const std::string &f)

Private Static Functions

bool checkFriendShip(TTree *tree)

class CumulativeHisto : public XAMPP::Histo

#include <Histo.h>

Subclassed by XAMPP::RevCumulativeHisto

Public Functions

CumulativeHisto(XAMPP::ITreeVarReader *Reader, const std::string &Name, const std::string &Template)

CumulativeHisto(const std::string &Name, const std::string &Template)

CumulativeHisto(const std::string &Name, unsigned int Nbins, double low, double high)

CumulativeHisto(const std::string &Name, unsigned int Nbins, const double *xbins)

CumulativeHisto(XAMPP::ITreeVarReader *Reader, const std::string &Name, unsigned int Nbins, double low, double high)

CumulativeHisto(XAMPP::ITreeVarReader *Reader, const std::string &Name, unsigned int Nbins, const double *xbins)

std::shared_ptr<Histo> Clone()

Protected Functions

void Finalize()

class CumulativeHisto2D : public XAMPP::Histo2D

#include <Histo.h>

Subclassed by XAMPP::RevCumulativeHisto2D

Public Functions

CumulativeHisto2D(const std::string &Name, const std::string &Template)

CumulativeHisto2D(XAMPP::ITreeVarReader *xReader, XAMPP::ITreeVarReader *yReader, const std::string &Name, const std::string &Template)

CumulativeHisto2D(const std::string &Name, unsigned int NBinsX, double xLow, double xHigh, unsigned int NBinsY, double yLow, double yHigh)

CumulativeHisto2D(const std::string &Name, unsigned int NBinsX, double xLow, double xHigh, unsigned int NBinsY, double *ybins)

CumulativeHisto2D(const std::string &Name, unsigned int NBinsX, double *xbins, unsigned int NBinsY, double yLow, double yHigh)

CumulativeHisto2D(XAMPP::ITreeVarReader *xReader, XAMPP::ITreeVarReader *yReader, const std::string &Name, unsigned int NBinsX, double xLow, double xHigh, unsigned int NBinsY, double yLow, double yHigh)

CumulativeHisto2D(XAMPP::ITreeVarReader *xReader, XAMPP::ITreeVarReader *yReader, const std::string &Name, unsigned int NBinsX, double xLow, double xHigh, unsigned int NBinsY, double *ybins)

CumulativeHisto2D(XAMPP::ITreeVarReader *xReader, XAMPP::ITreeVarReader *yReader, const std::string &Name, unsigned int NBinsX, double *xbins, unsigned int NBinsY, double yLow, double yHigh)

std::shared_ptr<Histo> Clone()

Protected Functions

void Finalize()

class Cut

#include <Cuts.h>

Subclassed by XAMPP::CompositeCut

Public Types

enum CutType

Values:

CutInt

CutFloat

CutChar

CutBool

CutPartInt

CutPartFloat

CutPartChar

CutPartBool

CutXAMPPmet

CutInDef

enum Combine

Values:

inDef

AND

OR

enum Relation

Values:

NoRel

Greater

Equal

Less

GreaterEqual

LessEqual

Public Functions

Cut(XAMPP::EventInfo *Info, const std::string &N, CutType T, bool Real)

Cut(const std::string &N, CutType T, bool Real)

~Cut()

Cut *combine(Cut *cut, Combine C = Combine::inDef)

template <typename T1>
bool initialize(XAMPP::Storage<XAMPPmet> *S, T1 CutValue, Cut::Relation Rel)

template <typename T, typename T1>
bool initialize(XAMPP::Storage<T> *Store, T1 CutValue, Cut::Relation Rel)

template <typename T>
bool ParticleInit(const std::string &Container, const std::string &Variable, unsigned int Nth, T CutValue, Cut::Relation Rel)

bool ParticleInit(const std::string &Container, Momentum Mom, unsigned int Nth, float CutValue, Cut::Relation Rel)

bool initialize(std::string VarName, std::string Relation)

void SetName(const std::string &N)

bool ApplyCut(bool ForCutFlow = false)

std::string GetName() const

void Debug(bool B = true)

bool IsInitialized() const

void Disconnect(Cut *C)

void Connect(Cut *C)

Public Static Functions

std::string RelToString(Relation R)

Protected Functions

Cut()

unsigned int EventNumber() const

Cut::Relation GetCondition(std::string &Cond)

Protected Attributes

std::string m_Name

CutType m_Type

bool m_IsRealCut

bool m_Debug

std::unique_ptr<XAMPP::ICutElement> m_CutElement

XAMPP::EventInfo *m_XAMPPInfo

Private Members

bool m_Init

std::vector<Cut *> m_Connected

class CutAppliedReader : public XAMPP::IScalarReader

#include <UtilityReader.h>

Public Functions

double read() const

bool init(TTree *t)

std::string name() const

void cacheDecision(bool B)

Public Members

friend XAMPP::CutAppliedReader::AnalysisRegion

friend XAMPP::CutAppliedReader::ReaderProvider

Protected Functions

CutAppliedReader(const std::vector<std::shared_ptr<Condition>> &cuts, const std::string &name)

CutAppliedReader(const CutAppliedReader&)

void operator=(const CutAppliedReader&)

Private Members

std::string m_name

std::vector<std::shared_ptr<Condition>> m_Cuts

bool m_Registered

bool m_Printed

bool m_cacheDecision

bool m_cache

Long64_t m_eventNumber

EventService *m_service

class CutFlow

#include <AnalysisConfig.h>

Class for cut flow. This class stores the cuts for the event selection and can hold the cuts similar to a container. It supports indexing the cuts via integer hash values.

Public Functions

CutFlow()

Default constructor for cut flow class.

CutFlow(const std::string &name)

Constructor for cut flow class allowing to name the cutflow. The hash of the cutflow (used for faster indexing) is based on the name of the cutflow.

Parameters

• name: The name of the CutFlow (is also converted to a hash value via std::hash)

~CutFlow()

Destroys the object.

void push_back(Cut *cut)

Adds a cut to the CutFlow.

Parameters

• cut: The cut to add

void replaceCut(Cut *ToReplace, Cut *With)

Replaces a cut of the CutFlow with another one.

Parameters

• ToReplace: Cut to replace
• With: New cut which should be used

int hash() const

Converts a cut into an integer hash in order to speed up the code.

Return

Integer hash of the CutFlow

const std::string &name() const

Returns the name of the CutFlow.

Return

Name of CutFlow

void setName(const std::string &N)

Sets the name of the CutFlow.

Parameters

• N: Name of CutFlow

const CutRow &GetCuts() const

Gets the cuts as CutRow object (vector of Cut objects)

Return

The cuts (as CutRow object - a std::vector of pointers to the Cut objects)

CutFlow &operator=(const CutFlow &cutflow)

Assignment operator. Assigns the cuts stored in another cutflow to this cutflow and sets cutflow name and hash to the values of the other cutflow.

Return

This existing object (this allows that this operator can be chained)

Parameters

• cutflow: The cutflow that should be assigned to this cutflow by copying the name, cutflow hash and inserting the cuts of the other cutflow to this cutflow.

Private Members

CutRow m_AnaCuts

std::string m_Name

int m_Hash

class CutFlowHisto : public XAMPP::Histo

#include <Histo.h>

Public Functions

CutFlowHisto(const std::string &Name, const std::string &Region)

bool init(TDirectory *D)

void Fill(double xValue)

void Fill(double xValue, double yValue)

void Fill(double xValue, double yValue, double zValue)

bool SetCuts(const std::vector<std::shared_ptr<Condition>> &Cuts)

bool SetCuts(const std::vector<std::string> &Cuts)

std::shared_ptr<Histo> Clone()

class CutFlowHistoVariable : public XAMPP::IHistoVariable

#include <HistoHelpers.h>

Public Functions

bool Fill()

TH1 *GetTemplate() const

bool FillBin(int Bin)

CutFlowHistoVariable(HistoBase *Base, const CutFlow *Flow)

~CutFlowHistoVariable()

bool InitializeCutFlow(const std::vector<std::string> &CutNames)

Private Members

TH1 *m_Template

class DataLumiReader : public XAMPP::IScalarReader

#include <ObservableReader.h>

Public Functions

double read() const

std::string name() const

bool init(TTree *t)

virtual ~DataLumiReader()

Public Static Functions

ITreeVarReader *GetReader()

Protected Functions

DataLumiReader()

DataLumiReader(const DataLumiReader&)

void operator=(const DataLumiReader&)

unsigned int GetRandomLumiBlock() const

Protected Attributes

ITreeVarReader *m_Reader

bool m_Registered

bool m_UsePRWTool

class DataVectorStorage : public XAMPP::IStorage

#include <EventStorage.h>

Subclassed by XAMPP::ParticleStorage

Public Functions

DataVectorStorage(const std::string &Name, XAMPP::IEventInfo *info, bool isCommon = false)

virtual ~DataVectorStorage()

StatusCode Fill(DataVector<SG::AuxElement> *Container)

StatusCode Fill(xAOD::IParticleContainer *Particles)

DataVector<SG::AuxElement> *Container()

DataVector<SG::AuxElement> *Container(const CP::SystematicSet *set)

SystematicContainer *findContainer(const CP::SystematicSet *set)

SystematicContainer *findContainer()

std::vector<std::shared_ptr<ITreeBranchVariable>> CreateParticleTree(TreeBase *base_tree)

StatusCode SaveInteger(const std::string &Branch, bool SaveVariations = true)

StatusCode SaveFloat(const std::string &Branch, bool SaveVariations = true)

StatusCode SaveDouble(const std::string &Branch, bool SaveVariations = true)

StatusCode SaveChar(const std::string &Branch, bool SaveVariations = true)

StatusCode SaveIntegerVector(const std::string &Branch, bool SaveVariations = true)

StatusCode SaveFloatVector(const std::string &Branch, bool SaveVariations = true)

StatusCode SaveDoubleVector(const std::string &Branch, bool SaveVariations = true)

StatusCode SaveCharVector(const std::string &Branch, bool SaveVariations = true)

template <typename T>
StatusCode SaveVariable(const std::string &Branch, bool SaveVariations = true, const std::string &acc_name = "")

template <typename T>
StatusCode SaveVariable(const std::vector<std::string> &BranchVector, bool SaveVariations = true, const std::string &acc_name = "")

void pipeVariableToAllTrees(const std::string &variable)

void pipeVariableToAllTrees(const std::vector<std::string> &variables)

Protected Types

typedef std::shared_ptr<ITreeBranchVariable> (DataVectorStorage::*StoreVariable)(const std::string &name, TreeBase *base, const std::string &acc_name)

Protected Functions

StatusCode AddVariable(const std::string &Branch, DataVectorStorage::StoreVariable V, bool SaveVariations, const std::string &acc_name = "")

Private Functions

template <typename T>
std::shared_ptr<ITreeBranchVariable> createBranch(const std::string &name, TreeBase *base, const std::string &acc_name)

void clear()

Private Members

std::string m_Name

std::map<const CP::SystematicSet *, std::unique_ptr<SystematicContainer>> m_containers

std::vector<std::string> m_vars_to_all

std::map<std::string, AdditionalBranches> m_Vars

bool m_Cleared

template <class decoType>
class Decoration

#include <DecorationInterface.h>

Public Functions

Decoration(const std::string &name)

~Decoration()

bool get(const SG::AuxElement &aux, decoType &val) const

bool get(const SG::AuxElement *aux, decoType &val) const

template <typename T = decoType, typename std::enable_if< std::is_same< T, char >::value, int >::type = 0>
bool operator()(const SG::AuxElement &aux)

template <typename T = decoType, typename std::enable_if< std::is_same< T, char >::value, int >::type = 0>
bool operator()(const SG::AuxElement *aux)

bool operator()(...)

template <typename T = decoType, typename Q = decoType>
bool isAvailable(const SG::AuxElement &aux) const

bool isAvailable(const SG::AuxElement *aux) const

void set(const SG::AuxElement &aux, const decoType &val) const

void set(const SG::AuxElement *aux, const decoType &val) const

void setDecorationString(const std::string &name)

std::string getDecorationString() const

Private Members

SG::AuxElement::Decorator<decoType> m_deco

SG::AuxElement::Accessor<decoType> m_accessor

std::string m_decoName

class DeltaEtaReader : public XAMPP::ParticleCorrelationReader

#include <ObservableReader.h>

Public Functions

std::string name() const

Public Static Functions

ParticleCorrelationReader *GetReader(const std::string &FirstParticle, const std::string &SecondParticle)

Protected Functions

DeltaEtaReader(const std::string &FirstParticle, const std::string &SecondParticle)

DeltaEtaReader(const DeltaEtaReader&)

void operator=(const DeltaEtaReader&)

class DeltaPhiReader : public XAMPP::ParticleCorrelationReader

#include <ObservableReader.h>

Public Functions

std::string name() const

Public Static Functions

ParticleCorrelationReader *GetReader(const std::string &FirstParticle, const std::string &SecondParticle)

Protected Functions

DeltaPhiReader(const std::string &FirstParticle, const std::string &SecondParticle)

DeltaPhiReader(const DeltaPhiReader&)

void operator=(const DeltaPhiReader&)

class DeltaPhiToMetReader : public XAMPP::IParticleVariable

#include <ObservableReader.h>

Public Functions

double readEntry(size_t I) const

std::string name() const

bool init(TTree *t)

Public Static Functions

IParticleVarReader *GetReader(const std::string &Particle, const std::string &Met)

Protected Functions

DeltaPhiToMetReader(const std::string &Particle, const std::string &Met)

DeltaPhiToMetReader(const DeltaPhiToMetReader&)

void operator=(const DeltaPhiToMetReader&)

Protected Attributes

std::string m_Met

IParticleVarReader *m_Part_phi

ITreeVarReader *m_Met_phi

bool m_Registered

class DeltaRReader : public XAMPP::ParticleCorrelationReader

#include <ObservableReader.h>

Public Functions

std::string name() const

Public Static Functions

ParticleCorrelationReader *GetReader(const std::string &FirstParticle, const std::string &SecondParticle)

Protected Functions

DeltaRReader(const std::string &FirstParticle, const std::string &SecondParticle)

DeltaRReader(const DeltaRReader&)

void operator=(const DeltaRReader&)

class DiParticleComponentReader : public XAMPP::IParticleVariable

#include <ReconstructedParticleReaders.h>

Public Functions

std::string name() const

double readEntry(size_t I) const

bool init(TTree *t)

Public Static Functions

IParticleVarReader *GetReader(const std::string &Name)

Protected Functions

DiParticleComponentReader(const std::string &Name)

DiParticleComponentReader(const DiParticleComponentReader&)

void operator=(const DiParticleComponentReader&)

Protected Attributes

DiParticleReader *m_DiPartReader

class DiParticleReader : public XAMPP::IParticleCollection

#include <ReconstructedParticleReaders.h>

Subclassed by XAMPP::UnSortedDiParticleReader

Public Functions

std::string name() const

bool init(TTree *t)

IParticleVarReader *RetrieveVariable(const std::string &Var)

IParticleVarReader *RetrievePartialVariable(const std::string &Var, bool FirstPart)

IParticleVarReader *RetrieveComponentReader()

size_t Size()

size_t ReaderIndex() const

size_t ReaderIndex(size_t P)

unsigned int GetCollectionHash() const

const TLorentzVector &P4() const

TLorentzVector GetP4(size_t E)

bool UseFirst(size_t N_th) const

size_t ComponentIndex() const

size_t ComponentIndex(size_t N_th) const

Public Static Functions

DiParticleReader *GetReader(const std::string &Name, const std::string &First = "", const std::string &Second = "")

void setHashRegMode(bool B)

Protected Functions

DiParticleReader(const std::string &Name, const std::string &First, const std::string &Second)

DiParticleReader(const DiParticleReader&)

void operator=(const DiParticleReader&)

void OrderParticleStreams()

void FillOrdering(std::vector<DiPartOrdering> &ordering, size_t N_part, bool isFirst)

Protected Attributes

std::string m_Name

IParticleReader *m_FirstParticle

IParticleReader *m_SecondParticle

IParticleVarReader *m_FirstPt

IParticleVarReader *m_SecondPt

std::vector<DiPartOrdering> m_Order

unsigned int m_CurrentEv

size_t m_Idx

unsigned int m_FirstCachedHash

unsigned int m_SecondCachedHash

Private Static Attributes

bool m_hashRegMode = false

class DiParticleVarReader : public XAMPP::IParticleVariable

#include <ReconstructedParticleReaders.h>

Public Functions

double readEntry(size_t I) const

std::string name() const

bool init(TTree *t)

Public Static Functions

IParticleVarReader *GetReader(DiParticleReader *DiReader, const std::string &VarName)

Protected Functions

DiParticleVarReader(DiParticleReader *DiReader, const std::string &VarName)

DiParticleVarReader(const DiParticleVarReader&)

void operator=(const DiParticleVarReader&)

Protected Attributes

DiParticleReader *m_Particle

IParticleVarReader *m_FirVar

IParticleVarReader *m_SecVar

std::string m_VarName

struct DiPartOrdering

#include <ReconstructedParticleReaders.h>

Public Functions

DiPartOrdering(size_t I, bool B)

Public Members

size_t Idx

bool UseFirstParticle

class DMXSecUpdater

#include <DMXSecUpdater.h>

Public Functions

DMXSecUpdater()

virtual ~DMXSecUpdater()

void UpdateDMXSection()

void SetCoupling(const float &coupling)

void SetCrossSectionDir(const std::string &xSecDir)

Protected Attributes

bool m_isSet

float m_coupling

std::string m_xSecDir

class DrawElementsFromSet

#include <CombinatoricSelection.h>

Helper class to draw M elements from a set with N distnictive elements.

Public Functions

DrawElementsFromSet(unsigned int n, unsigned int m, unsigned int offset = 0)

DrawElementsFromSet(const DrawElementsFromSet&)

void operator=(const DrawElementsFromSet&)

unsigned int n() const

unsigned int m() const

unsigned int offset() const

Global offset shifting the values.

unsigned int size() const

How many possibilities to draw m elemenets from a set of n.

unsigned int value_in_tuple(unsigned int ele, unsigned int pos) const

Returns the i-th value in the n-th possibility.

std::vector<unsigned int> draw(unsigned int ele) const

Get all combinations in one go.

Private Functions

unsigned int value_in_tuple(unsigned int ele, unsigned int pos, unsigned int min) const

unsigned int get_zeroth(unsigned int ele) const

Private Members

unsigned int m_N

unsigned int m_M

unsigned int m_offset

unsigned int m_size

std::unique_ptr<DrawElementsFromSet> m_n_minus1

std::vector<unsigned int> m_borders

class ElectronDecorations : public XAMPP::ParticleDecorations

#include <ElectronDecorations.h>

Public Functions

ElectronDecorations()

void populateDefaults(SG::AuxElement &ipart)

Public Members

Decoration<float> z0sinTheta

Decoration<float> d0sig

Decoration<float> d0raw

Decoration<char> passSignalWorkingPoint

Decoration<ElementLink<xAOD::TruthParticleContainer>> truthParticleLink

Decoration<int> truthType

Decoration<int> truthOrigin

class ElectronTriggerSFHandler : public XAMPP::ElectronWeightDecorator

#include <SUSYElectronSelector.h>

Public Functions

ElectronTriggerSFHandler(const std::string &Trigger, const ToolHandle<ITriggerTool> &trigger_tool, EleEffToolHandle &TriggerSF)

StatusCode initialize()

~ElectronTriggerSFHandler()

Protected Functions

StatusCode calculateSF(const xAOD::Electron &Electron, double &SF)

Private Functions

bool RetrieveMatchers(const std::string &Trigger)

bool IsTriggerMachted(const xAOD::Electron &El) const

Private Members

std::string m_TrigStr

EleEffToolHandle m_TriggerSFTool

ToolHandle<ITriggerTool> m_trig_tool

std::vector<std::shared_ptr<TriggerInterface>> m_Triggers

class ElectronWeight : public XAMPP::ElectronWeightDecorator

#include <SUSYElectronSelector.h>

Public Functions

ElectronWeight(EleEffToolHandle &SFTool)

~ElectronWeight()

Protected Functions

StatusCode calculateSF(const xAOD::Electron &Electron, double &SF)

Private Members

EleEffToolHandle m_SFTool

class ElectronWeightDecorator : public XAMPP::IParticleWeightDecorator

#include <SUSYElectronSelector.h>

Subclassed by XAMPP::ElectronTriggerSFHandler, XAMPP::ElectronWeight, XAMPP::ElectronWeightHandler

Public Functions

ElectronWeightDecorator()

~ElectronWeightDecorator()

StatusCode initialize()

StatusCode saveSF(const xAOD::Electron &Electron, bool isSignal)

Protected Functions

virtual StatusCode calculateSF(const xAOD::Electron &Electron, double &SF) = 0

class ElectronWeightHandler : public XAMPP::ElectronWeightDecorator

#include <SUSYElectronSelector.h>

Public Functions

ElectronWeightHandler(const CP::SystematicSet *syst_set)

const CP::SystematicSet *systematic() const

size_t nWeights() const

void multipleTriggerSF(bool B = true)

StatusCode saveSF(const xAOD::Electron &Electron, bool isSignal)

StatusCode applySF()

bool append(const ElectronWeightMap &map, const CP::SystematicSet *nominal)

bool setSignalTriggerSF(const ElectronWeight_VectorMap &map, const CP::SystematicSet *nominal)

Protected Functions

StatusCode calculateSF(const xAOD::Electron &Electron, double &SF)

Private Members

const CP::SystematicSet *m_Syst

std::vector<ElectronWeight_Ptr> m_Weights

bool m_init

ElectronWeight_Vector m_signal_trig_SF

bool m_multiple_trig_sf

class EqualCondition : public XAMPP::Condition

#include <Cuts.h>

Public Functions

bool PassScalar() const

bool PassVector(size_t entry) const

bool PassMatrix(size_t column, size_t row) const

std::string name() const

template <class T>
class EventBranchVariable : public XAMPP::TreeHelper, public virtual XAMPP::ITreeBranchVariable

#include <TreeHelpers.h>

Public Functions

EventBranchVariable(XAMPP::Storage<T> *Store, TTree *tree)

bool Init()

std::string name() const

bool Fill()

virtual ~EventBranchVariable()

Private Members

XAMPP::Storage<T> *m_Store

template <class T>
class EventHistoVariable : public XAMPP::IHistoVariable

#include <HistoHelpers.h>

Public Functions

EventHistoVariable(XAMPP::Storage<T> *Store, HistoBase *Base, const CutFlow *Flow, const std::string &Name)

bool Fill()

TH1 *GetTemplate() const

Private Members

XAMPP::Storage<T> *m_Store

TH1 *m_Template

class EventIndexer : public XAMPP::Selector

#include <EventDuplication.h>

Public Functions

EventIndexer(const std::string &Name, const std::string &TreeName, const std::vector<std::string> &Files)

Private Functions

bool AnalyzeEvent()

{ function_description }

Return

{ description_of_the_return_value }

void SetupReaders()

void WriteOutput()

Writes an output.

Private Members

std::string m_cache_path

std::ofstream m_cache_stream

ITreeVarReader *m_event_number

ITreeVarReader *m_run_number

class EventInfo : public AsgTool, public virtual XAMPP::IEventInfo

#include <EventInfo.h>

Public Functions

EventInfo(const std::string &myname)

StatusCode initialize()

StatusCode LoadInfo()

StatusCode SetSystematic(const CP::SystematicSet *set)

const xAOD::EventInfo *GetOrigInfo() const

xAOD::EventInfo *GetEventInfo() const

const xAOD::Vertex *GetPrimaryVertex() const

bool isMC() const

Functions as a short cut from the event-info itself.

unsigned long long eventNumber() const

int mcChannelNumber() const

unsigned int runNumber() const

unsigned int randomRunNumber() const

unsigned int dataYear() const

const CP::SystematicSet *GetSystematic() const

const CP::SystematicSet *GetNominal() const

bool PassCleaning() const

double GetPileUpLuminosity()

Propagation of the luminosity to the meta-data.

bool ApplyPileUp() const

int dsidOffSet() const

bool applyDSIDShift() const

template <typename T>
bool DoesVariableExist(const std::string &Name) const

template <typename T>
StatusCode NewEventVariable(const std::string &Name, bool saveToTree = true, bool SaveVariations = true)

template <typename T>
StatusCode NewCommonEventVariable(const std::string &Name, bool saveToTree = true, bool SaveVariations = true)

template <typename T>
void RemoveVariableFromOutput(const std::string &Name)

template <typename T>
Storage<T> *GetVariableStorage(const std::string &Name) const

template <typename T>
std::vector<Storage<T> *> GetStorages(unsigned int e) const

StatusCode BookParticleStorage(const std::string &Name, bool StoreMass = false, bool SaveVariations = true, bool saveTrees = true)

StatusCode BookCommonParticleStorage(const std::string &Name, bool StoreMass = false, bool saveToTree = true)

Storage which is piped to the transient particle tree if there is any.

ParticleStorage *GetParticleStorage(const std::string &Name) const

StatusCode BookContainerStorage(const std::string &Name, bool SaveVariations = true, bool saveToTree = true)

StatusCode BookCommonContainerStorage(const std::string &Name, bool saveTrees = true)

DataVectorStorage *GetContainerStorage(const std::string &Name) const

Retrieves the container storage registered under a given name. ParticleStorages are returned as well. If the name does not exist nullptr is returned

std::vector<DataVectorStorage *> GetContainerStorages(unsigned int e) const

Retrieve all Container storages registered with this event info class.

double GetGenWeight(unsigned int idx = 0) const

double GetRawGenWeight(unsigned int idx = 0) const

StatusCode CopyInfoFromNominal(const CP::SystematicSet *To)

bool isLocked() const

void Lock()

Method which disables the adding of storages.

void LockKeeper()

StatusCode createSystematicGroup(const std::string &name, XAMPP::SelectionObject obj_type)

std::shared_ptr<SystematicGroup> getSystematicGroup(const std::string &name) const

const std::vector<std::shared_ptr<SystematicGroup>> &getSystematicGroups() const

bool buildSplittedTrees() const

Flag which disables/enables the split apart of systematic groups.

int getOutlierWeightStrategy() const

bool isOutlierGenWeight(unsigned int idx = 0) const

bool isOutlierGenWeight(double w) const

~EventInfo()

Private Functions

StatusCode FindPrimaryVertex()

StatusCode GetInfoFromStore(const CP::SystematicSet *set)

bool returnStorage(IStorage *store, unsigned int bit_mask) const

double GetPeriodWeight()

StatusCode RunPRWTool()

Private Members

const xAOD::EventInfo *m_ConstEvtInfo

xAOD::EventInfo *m_EvtInfo

const xAOD::Vertex *m_primaryVtx

const CP::SystematicSet *m_ActSys

ToolHandle<XAMPP::ISystematics> m_systematics

asg::AnaToolHandle<CP::IPileupReweightingTool> m_prwTool

asg::AnaToolHandle<IGoodRunsListSelectionTool> m_GrlTool

bool m_ApplyPRW

bool m_ApplyGRL

bool m_Init

bool m_Locked

bool m_Filter

bool m_RecoFlags

bool m_MultiPRWPeriods

std::map<const CP::SystematicSet *, PileUpDecorators> m_DecPup

XAMPP::Storage<int> *m_nNVtx

XAMPP::Storage<char> *m_PassGRL

XAMPP::Storage<char> *m_PassLArTile

XAMPP::Storage<char> *m_HasVtx

XAMPP::Storage<float> *m_mu_density

bool m_shiftDSISD

In case people are messing up the DSIDs of the samples. The boolean must be activated to shift the DSIDS, however, it’s an very ugly way of tweaking things and not actually recommended at all since it leads the concept of meta hillariously ad absurdum

int m_dsidOffSet

int m_OutlierStrat

double m_outlierWeightThreshold

std::vector<std::shared_ptr<SystematicGroup>> m_systGroups

bool m_makeSplitTrees

struct EventRegion

#include <Selector.h>

Public Functions

EventRegion(const std::string &N)

Public Members

std::string Name

std::vector<std::shared_ptr<Histo>> Histograms

class EventSeen

Public Functions

EventSeen(unsigned int run, unsigned long long event)

unsigned int run_number() const

unsigned long long event_number() const

bool is_duplicate()

Private Members

unsigned int m_run

unsigned long long m_event

bool m_seen

class EventService

#include <EventService.h>

Public Functions

~EventService()

Long64_t currentEvent() const

Long64_t entries() const

size_t cacheSize() const

bool partialEvent() const

unsigned int n_thTree() const

bool getEntry(Long64_t entry)

bool setupTree(TTree *tree)

bool AppendReader(ITreeVarReader *R)

bool SetReaders(const std::vector<ITreeVarReader *> &R)

void flushReaders()

void loadEntireEvent()

void setCacheSize(size_t S)

bool registerKinematic(std::shared_ptr<IKinematicSyst> syst)

std::shared_ptr<IKinematicSyst> getSyst(const std::string &name) const

std::shared_ptr<IKinematicSyst> getNominal() const

const std::vector<std::shared_ptr<IKinematicSyst>> &all_systematics() const

TreeIndexer *getIndexer(TBranch *br) const

std::string in_file_path() const

bool openFile(const std::string &file_path)

bool openFile(const std::shared_ptr<TFile> &file_obj)

void set_selector(Selector *selector)

Special functionallity to actually attach the ordinary branches from the XAMPP::Selector to the TTree. Usually the XAMPP::Selector is only used by under graduate students…

Public Static Functions

EventService *getService()

Private Functions

EventService()

EventService(const EventService&)

void operator=(const EventService&)

Private Members

Weight *m_weighter

bool m_loadEvent

std::vector<ITreeVarReader *> m_readerToLoad

size_t m_CacheSize

unsigned int m_TreesLoaded

std::vector<std::shared_ptr<IKinematicSyst>> m_kinematicSyst

std::shared_ptr<IKinematicSyst> m_nominal

std::unique_ptr<TreeIndexer> m_master_indexer

std::vector<std::unique_ptr<TreeIndexer>> m_friend_indexer

std::string m_filePath

std::shared_ptr<TFile> m_inFile

Selector *m_selector

Private Static Attributes

EventService *m_Inst = nullptr

class EventVarSortedParticleReader : public XAMPP::ResortedParticleReader

#include <ReconstructedParticleReaders.h>

Subclassed by XAMPP::SortedMetParticleReader_ASC, XAMPP::SortedMetParticleReader_DESC

Public Functions

bool init(TTree *t)

Protected Functions

EventVarSortedParticleReader(const std::string &Name, const std::string &Sorter, ITreeVarReader *EvVar, const std::string &App = "")

EventVarSortedParticleReader(const EventVarSortedParticleReader&)

void operator=(const EventVarSortedParticleReader&)

Protected Attributes

ITreeVarReader *m_EvSorter

class ExtremumVarReader : public XAMPP::IScalarReader

#include <ObservableReader.h>

Subclassed by XAMPP::MaximumVarReader, XAMPP::MinimumVarReader

Public Functions

double read() const

bool init(TTree *t)

std::string name() const

virtual ~ExtremumVarReader()

Protected Functions

virtual bool IsExtremum(double Current, double Test) const = 0

virtual double GetInitial() const = 0

ExtremumVarReader(const std::string &Name, const std::vector<ITreeVarReader *> &Readers)

Protected Attributes

std::string m_Name

double m_Ext

unsigned int m_EventNumber

std::vector<ITreeVarReader *> m_Readers

class FakeFactor : public XAMPP::IExternalWeight, public XAMPP::IPermutationElement

#include <DataDrivenWeights.h>

Fake factors are the ratio signal / loose requirement derived from MC depending on a given choice of variables. Following the general fake-factor recipe from the matrix formula F = f_{ij} * sf_{j} * P_{ij} The process-fraction can be parametrized as a function of the object kinematics or as a function of the discriminating variable. Preferred is usally the former one. In this case the FakeFactor class serves the purpose. Thus it’s usable for all 3 cases.

Subclassed by XAMPP::CombinedFakeFactor

Public Functions

FakeFactor()

virtual ~FakeFactor()

double Evaluate(size_t entry)

Calculate the fake-factor weight finally.

bool init(TTree *t)

Initialize the access to the TTree as usual.

std::shared_ptr<FakeFactor> clone() const

bool SetParticle(IParticleReader *P)

Set the global particle of the fake-factor.

bool SetXVar(IParticleVarReader *x)

Set the variable to read out the x-axis.

All variables must be associated to the particle -> SetParticle must be called at the very first

bool SetYVar(IParticleVarReader *y)

Set the variable to read out the y-axis.

bool SetZVar(IParticleVarReader *z)

Set the variable to read out the z-axis.

int fakeType() const

Type of fakes considered by the analysis. I.e. HF, LF, CONV, et al. The user himself decides about the numbering scheme with one exception -1 means no assignment is done at all and corresponds to the default setting

void setFakeType(int type)

int processBin() const

Similar arguments are lead into the battle for the processBin mapping the SM-background process to the fake-factor (Z+jets, W+jets, ttbar etc)

void setProcessBin(int bin)

IParticleVarReader *xVariable() const

Access to the x-variable.

IParticleVarReader *yVariable() const

Access to the y-variable.

IParticleVarReader *zVariable() const

Access to the z-variable.

IParticleReader *particle() const

Access to the particle itself.

bool entered_globally() const

Did any of the particles in the container pass the selection.

bool entered_component() const

Did the particle from the last evaluate call pass.

void doNotFlipDataMC(bool B = true)

Do not swap the sign on MC w.r.t. data.

void isSubtractingFakeFF(bool B = true)

The FF intrinsically subtracts the event to account for double counting.

int sign() const

Sign of the fake-factor in the event.

unsigned int nPassed() const

How many elements from the container were selected in total.

void setBeginPosition(size_t pos)

Only consider from the i-th element in the container for the FF.

void setEndPosition(size_t pos)

Only consider until the i-th element in the container for the FF.

void setDesignPartNumber(unsigned int p)

What is the desired size of the fake-factor weight (1/2)

unsigned int num_design_parts() const

unsigned int n_combinations() const

void setIncludeCombinatorics(bool B)

bool include_combinatorics() const

std::shared_ptr<DrawElementsFromSet> combinatoric_set() const

const std::vector<unsigned int> &get_entered() const

Protected Functions

void set_entered(bool B)

Private Functions

bool SetVar(IParticleVarReader *out, IParticleVarReader *&Ref)

Set the variable along the i-th axis.

Private Members

IParticleReader *m_Particle

IParticleVarReader *m_x

IParticleVarReader *m_y

IParticleVarReader *m_z

int m_fakeBin

int m_processBin

bool m_freeze_sign

bool m_is_subtracting

EventService *m_service

CombinatoricService *m_comb_service

Weight *m_weighter

size_t m_start_in_container

size_t m_end_in_container

unsigned int m_designpart

bool m_includeCombinatorics

std::shared_ptr<DrawElementsFromSet> m_combinatorics

std::vector<unsigned int> m_entered_particles

Long64_t m_last_ev

bool m_globally_entered

bool m_last_entry_entered

unsigned int m_n_passed

class FakeFactorBundle

#include <DataDrivenWeights.h>

Public Functions

FakeFactorBundle(const std::string &WeightName, const std::string &Syst)

std::string name() const

void Add(std::shared_ptr<FakeFactor> FF)

double Evaluate() const

bool init(TTree *T)

ITreeVarReader *GetReader() const

size_t nComponents() const

bool applyUncertainty(double w)

void clone_from(std::shared_ptr<FakeFactorBundle> other)

void setDataLumi(double lumi)

void includeCombinatorics(bool B = true)

Include the combinatoric selection of the fake-factor Meaning that the event is processed several times just picking the k out of n elements from the list

void setCut(std::shared_ptr<Condition> cut)

Private Functions

bool passCut() const

Private Members

std::string m_Syst

std::vector<std::shared_ptr<FakeFactor>> m_FF

PseudoScalarVarReader *m_Pseudo

Weight *m_weight

CombinatoricService *m_comb_service

bool m_types_cached

Cache the maxima of fake-type and process bin in a local variable.

double m_lumi

bool m_DoCombinatorics

std::shared_ptr<Condition> m_cut

class FakeFactorWeight : public XAMPP::IWeightElement

#include <DataDrivenWeights.h>

The fake-factor weight basically acts like a generic scale-factor read-out. Histograms are read from the file and their content is extracted based on the particle kinematics. The histogram can have any dimension from 1-3. Alternatively also the weight application according to TF1 is at least prepared

Public Functions

std::string name() const

bool init(TTree *t)

double read()

std::vector<std::string> FindWeightVariations(TTree *)

IWeightElement::SystStatus ApplySystematic(const std::string &variation)

void ResetSystematic()

std::vector<std::string> GetWeightVariations()

ITreeVarReader *GetTreeVarReader()

ITreeVarReader *GetSystematicReader(const std::string &Syst)

virtual ~FakeFactorWeight()

bool ReadFakeFactorConfig(std::ifstream &inf, std::vector<ITreeVarReader *> &Readers)

bool AddFakeFactor(std::shared_ptr<FakeFactorBundle> bundle)

bool AddFakeFactor(std::shared_ptr<FakeFactor> fakes, const std::string &syst = "")

Public Static Functions

FakeFactorWeight *GetWeighter(const std::string &Element = "FakeFactorWeightElement")

Private Functions

bool AppendFakeFactor(std::ifstream &inf, std::vector<ITreeVarReader *> &readers)

void CreateStatErrors()

void CreateSystematic(const std::string &Syst)

Create a new bundle storing all fake-factors corresponding to a systematic

bool LoadSystematic(const std::string &Syst = "")

Load the systematic into cache. False is returned if it does not exist

FakeFactorWeight(const std::string &Element)

FakeFactorWeight(const FakeFactorWeight&)

void operator=(const FakeFactorWeight&)

Private Members

std::string m_Name

std::vector<std::shared_ptr<FakeFactorBundle>> m_FF

std::shared_ptr<FakeFactorBundle> m_FFSyst

Current systematic.

bool m_Init

bool m_Registered

double m_lumi

Settings which can be configured to the particular fake-factors themselves If an option is set then it overwrites the one of each single fake-factor Luminosity of the used data. If this variable > 0 then the data is aditionally scaled by 1 / lumi to cancel the scaling at the final plotting stage.

std::shared_ptr<Condition> m_cut

bool m_includeCombinatorics

class FileHandler

#include <FinalPlotHelpers.h>

Public Functions

std::shared_ptr<TFile> LoadFile(const std::string &path)

FileStructure_Ptr GetFileStructure(const std::string &path)

FileStructure_Ptr GetFileStructure(const std::shared_ptr<TFile> &File) const

FileStructure_Ptr GetFileStructure(const TFile *File) const

std::vector<std::shared_ptr<TFile>> OpenedFiles() const

std::vector<FileStructure_Ptr> FileStructures() const

~FileHandler()

void closeAll()

void switchOffMsg()

bool showMsg() const

Public Static Functions

FileHandler *getInstance()

void reset()

Private Functions

FileHandler()

FileHandler(const FileHandler&)

void operator=(const FileHandler&)

Private Members

std::vector<FileStructure_Ptr> m_opened_files

bool m_showMessages

Private Static Attributes

FileHandler *m_Inst = nullptr

class FileStructure

#include <FinalPlotHelpers.h>

Public Functions

FileStructure(std::shared_ptr<TFile> ROOT_File)

FileStructure(const FileStructure&)

void operator=(const FileStructure&)

std::shared_ptr<TFile> reference() const

std::vector<PlotAnalysis_Ptr> get_analyses() const

PlotAnalysis_Ptr get_analysis(const std::string &ana_name) const

std::vector<std::string> get_analyses_names() const

Private Functions

void append_analysis(std::string &name)

Private Members

std::shared_ptr<TFile> m_reference_file

std::vector<PlotAnalysis_Ptr> m_analyses

struct FinalPRWWeight

Public Functions

FinalPRWWeight(PseudoScalarVarReader *C, ITreeVarReader *P)

Public Members

PseudoScalarVarReader *CombinedReader

ITreeVarReader *prwReader

struct FinalStrObjMatching

Public Members

xAOD::Type::ObjectType Obj = xAOD::Type::ObjectType::Other

unsigned int Multiplicity = 0

size_t StringPosition = std::string::npos

class FiredObjectTrigger

#include <SUSYTriggerTool.h>

Helper class to handle whether any trigger associated to an object e.g. electrons, muons, photons has fired

Public Types

enum Association

Values:

Electron = 1

Muon = 1 << 1

Photon = 1 << 2

Tau = 1 << 3

Public Functions

FiredObjectTrigger(const std::vector<std::shared_ptr<TriggerInterface>> &trigger_list, unsigned int assoc, int n_obj = -1)

FiredObjectTrigger(const FiredObjectTrigger&)

void operator=(const FiredObjectTrigger&)

bool has_triggers() const

StatusCode checkTrigger()

StatusCode checkMatching()

StatusCode make_stores(XAMPP::EventInfo *info)

Private Members

unsigned int m_assoc

int m_num_obj

std::vector<std::shared_ptr<TriggerInterface>> m_assoc_triggers

XAMPP::Storage<char> *m_dec_is_fired

XAMPP::Storage<char> *m_dec_is_matched

class FixedExternalWeight : public XAMPP::IWeightElement

#include <DataDrivenWeights.h>

Apply a flat scaling to each event. This class can only be used in combination with the Conditional weight

Public Functions

std::string name() const

bool init(TTree *t)

double read()

ITreeVarReader *GetTreeVarReader()

ITreeVarReader *GetSystematicReader(const std::string &Syst)

std::vector<std::string> FindWeightVariations(TTree *Tree)

IWeightElement::SystStatus ApplySystematic(const std::string &variation)

void ResetSystematic()

std::vector<std::string> GetWeightVariations()

~FixedExternalWeight()

Public Static Functions

IWeightElement *GetWeighter(const std::string &Name, const std::string &ReaderName = "", double FixedValue = 42.)

Private Functions

FixedExternalWeight(const std::string &WeightName, const std::string &ReaderName, double FixedValue)

FixedExternalWeight(const FixedExternalWeight&)

void operator=(const FixedExternalWeight&)

Private Members

std::string m_name

PseudoScalarVarReader *m_reader

class FloatWeightFromTree : public XAMPP::WeightElementFromTree

#include <Weight.h>

Public Functions

~FloatWeightFromTree()

Public Static Functions

FloatWeightFromTree *GetWeighter(const std::string &Name)

Protected Functions

FloatWeightFromTree(const std::string &Weight)

FloatWeightFromTree(const FloatWeightFromTree&)

void operator=(const FloatWeightFromTree&)

ITreeVarReader *LoadReader(const std::string &syst = "")

class GreaterCondition : public XAMPP::Condition

#include <Cuts.h>

Public Functions

bool PassScalar() const

bool PassVector(size_t entry) const

bool PassMatrix(size_t column, size_t row) const

std::string name() const

class GreaterEqualCondition : public XAMPP::Condition

#include <Cuts.h>

Public Functions

bool PassScalar() const

bool PassVector(size_t entry) const

bool PassMatrix(size_t column, size_t row) const

std::string name() const

class GRLCondition : public XAMPP::Condition

#include <Cuts.h>

Public Functions

GRLCondition(const std::vector<std::string> &GRLs)

bool Pass() const

virtual bool PassScalar() const

virtual bool PassVector(size_t) const

virtual bool PassMatrix(size_t, size_t) const

std::string name() const

~GRLCondition()

Private Members

bool m_init

asg::AnaToolHandle<IGoodRunsListSelectionTool> m_grl

class Histo

#include <Histo.h>

Subclassed by XAMPP::CumulativeHisto, XAMPP::CutFlowHisto, XAMPP::Histo2D, XAMPP::Histo3D, XAMPP::HistoArray

Public Types

enum HistoTypes

Values:

Undefined

H1

H2

H3

Public Functions

Histo(XAMPP::ITreeVarReader *Reader, const std::string &Name, const std::string &Template)

Histo(const std::string &Name, const std::string &Template)

Histo(const std::string &Name, unsigned int Nbins, double low, double high)

Histo(const std::string &Name, unsigned int Nbins, const double *xbins)

Histo(const std::string &Name, const std::vector<double> &xbins)

Histo(XAMPP::ITreeVarReader *Reader, const std::string &Name, unsigned int Nbins, double low, double high)

Histo(XAMPP::ITreeVarReader *Reader, const std::string &Name, unsigned int Nbins, const double *xbins)

Histo(XAMPP::ITreeVarReader *Reader, const std::string &Name, const std::vector<double> &xbins)

Histo(const Histo &other)

bool init(TDirectory *D)

void fill()

void Fill(double xValue)

void Fill(double xValue, double yValue)

void Fill(double xValue, double yValue, double zValue)

void write()

void Statistics() const

void DoRaw(bool B = true)

void PullOverFlowBins(bool B = true)

void PullUnderFlowBins(bool B = true)

bool PullOverFlow() const

bool PullUnderFlow() const

std::string name() const

void SetXaxisLabel(const std::string &L)

void SetYaxisLabel(const std::string &L)

void SetZaxisLabel(const std::string &L)

void SetBinLabelX(int Bin, const std::string &L)

void SetBinLabelY(int Bin, const std::string &L)

void SetBinLabelZ(int Bin, const std::string &L)

void SetNormToFirstBin(bool B)

void SetDivideByBinWidth(bool B)

void SetEntriesLabel(const std::string &L)

void SetUnitsLabel(const std::string &L)

void SetCut(std::shared_ptr<Condition> C)

~Histo()

std::string GetTemplate() const

std::shared_ptr<Histo> Clone()

Protected Functions

Histo(XAMPP::ITreeVarReader *Reader, const std::string &Name, const std::string &Template, Histo::HistoTypes Type)

Histo(const std::string &Name, const std::string &Template, Histo::HistoTypes Type)

void Finalize()

void PullBinsOutOfRange()

void PullContentInBin(int From, int To)

void AddBinContent(int Bin) const

bool NoReaderConnected() const

double weight() const

double weight2() const

bool passCut() const

Protected Attributes

XAMPP::ITreeVarReader *m_Reader

std::unique_ptr<TH1> m_TH1

Private Functions

void SetTitleAndLabels()

Private Members

std::string m_Name

std::string m_Template

HistoTypes m_Type

bool m_AltConst

bool m_UseWeights

bool m_PullOverFlow

bool m_PullUnderFlow

bool m_normToFirstBin

bool m_divideByBinWidth

std::string m_entriesLabel

std::string m_unitsLabel

unsigned int m_Entries

std::string m_xLabel

std::string m_yLabel

std::string m_zLabel

std::map<int, std::string> m_xBinLabels

std::map<int, std::string> m_yBinLabels

std::map<int, std::string> m_zBinLabels

XAMPP::Weight *m_Weight

std::shared_ptr<Condition> m_Cut

bool m_HasCut

TDirectory *m_Dir

class Histo2D : public XAMPP::Histo

#include <Histo.h>

Subclassed by XAMPP::CumulativeHisto2D, XAMPP::Histo2DPoly

Public Functions

Histo2D(XAMPP::ITreeVarReader *xReader, XAMPP::ITreeVarReader *yReader, const std::string &Name, const std::string &Template)

Histo2D(const std::string &Name, const std::string &Template)

Histo2D(const std::string &Name, unsigned int NBinsX, double xLow, double xHigh, unsigned int NBinsY, double yLow, double yHigh)

Histo2D(const std::string &Name, unsigned int NBinsX, double xLow, double xHigh, unsigned int NBinsY, double *ybins)

Histo2D(const std::string &Name, unsigned int NBinsX, double *xbins, unsigned int NBinsY, double yLow, double yHigh)

Histo2D(XAMPP::ITreeVarReader *xReader, XAMPP::ITreeVarReader *yReader, const std::string &Name, unsigned int NBinsX, double xLow, double xHigh, unsigned int NBinsY, double yLow, double yHigh)

Histo2D(XAMPP::ITreeVarReader *xReader, XAMPP::ITreeVarReader *yReader, const std::string &Name, unsigned int NBinsX, double xLow, double xHigh, unsigned int NBinsY, double *ybins)

Histo2D(XAMPP::ITreeVarReader *xReader, XAMPP::ITreeVarReader *yReader, const std::string &Name, unsigned int NBinsX, double *xbins, unsigned int NBinsY, double yLow, double yHigh)

void fill()

void Fill(double xValue)

void Fill(double xValue, double yValue)

void Fill(double xValue, double yValue, double zValue)

bool init(TDirectory *D)

std::shared_ptr<Histo> Clone()

Protected Functions

void PullBinsOutOfRange()

Protected Attributes

XAMPP::ITreeVarReader *m_yReader

class Histo2DPoly : public XAMPP::Histo2D

#include <Histo.h>

Public Functions

Histo2DPoly(const std::string &Name, const std::string &Template)

Histo2DPoly(XAMPP::ITreeVarReader *xReader, XAMPP::ITreeVarReader *yReader, const std::string &Name, const std::string &Template)

void fill()

void Fill(double xValue)

void Fill(double xValue, double yValue)

void Fill(double xValue, double yValue, double zValue)

bool init(TDirectory *D)

std::shared_ptr<Histo> Clone()

Private Functions

void FillPoly(double xValue, double yValue)

void Finalize()

Private Members

TH2Poly *m_THPoly

class Histo3D : public XAMPP::Histo

#include <Histo.h>

Public Functions

Histo3D(const std::string &Name, const std::string &Template)

Histo3D(XAMPP::ITreeVarReader *xReader, XAMPP::ITreeVarReader *yReader, XAMPP::ITreeVarReader *zReader, const std::string &Name, const std::string &Template)

Histo3D(const std::string &Name, unsigned int NBinsX, double xLow, double xHigh, unsigned int NBinsY, double yLow, double yHigh, unsigned int NBinsZ, double zLow, double zHigh)

Histo3D(const std::string &Name, unsigned int NBinsX, double *xbins, unsigned int NBinsY, double *ybins, unsigned int NBinsZ, double *zbins)

Histo3D(XAMPP::ITreeVarReader *xReader, XAMPP::ITreeVarReader *yReader, XAMPP::ITreeVarReader *zReader, const std::string &Name, unsigned int NBinsX, double xLow, double xHigh, unsigned int NBinsY, double yLow, double yHigh, unsigned int NBinsZ, double zLow, double zHigh)

Histo3D(XAMPP::ITreeVarReader *xReader, XAMPP::ITreeVarReader *yReader, XAMPP::ITreeVarReader *zReader, const std::string &Name, unsigned int NBinsX, double *xbins, unsigned int NBinsY, double *ybins, unsigned int NBinsZ, double *zbins)

void fill()

void Fill(double xValue)

void Fill(double xValue, double yValue)

void Fill(double xValue, double yValue, double zValue)

bool init(TDirectory *D)

std::shared_ptr<Histo> Clone()

Protected Attributes

XAMPP::ITreeVarReader *m_yReader

XAMPP::ITreeVarReader *m_zReader

class HistoArray : public XAMPP::Histo

#include <Histo.h>

Public Functions

HistoArray(const std::string &Name)

bool init(TDirectory *D)

void fill()

void write()

void Statistics() const

void AppendHistogram(const std::vector<std::shared_ptr<Histo>> &Histos)

void AppendHistogram(std::shared_ptr<Histo> In)

void SetCut(const std::vector<std::shared_ptr<Condition>> &Cuts)

void DoCutFlow(bool B)

~HistoArray()

std::shared_ptr<Histo> Clone()

Protected Functions

void FillCutFlowHistos(unsigned int Passed)

Protected Attributes

std::vector<std::shared_ptr<Histo>> m_ClientHistos

std::vector<std::shared_ptr<Condition>> m_Cuts

bool m_DoCutFlow

std::shared_ptr<CutFlowHisto> m_RawCutFlow

std::shared_ptr<CutFlowHisto> m_WeightedCutFlow

class HistoAxis

#include <HistoBins.h>

Public Functions

HistoAxis(unsigned int Nbins, double low_edge, double high_edge)

HistoAxis(const std::vector<double> &edges)

unsigned int FindBin(double value) const

unsigned int GetNbins() const

double GetBinCenter(unsigned int bin) const

double GetBinLowEdge(unsigned int bin) const

double GetBinUpEdge(unsigned int bin) const

std::vector<double> GetBinning() const

Private Functions

unsigned int FindBin(const double &value, std::vector<double>::const_iterator begin_itr, std::vector<double>::const_iterator end_itr) const

Private Members

double m_low_edge

double m_high_edge

unsigned int m_nbins

bool m_equal_distance

double m_bin_width

std::vector<double> m_bin_edges

std::vector<double>::const_iterator m_itr_begin

std::vector<double>::const_iterator m_itr_end

class HistoBase

#include <HistoBase.h>

Public Functions

HistoBase(const CP::SystematicSet *set)

~HistoBase()

StatusCode InitializeHistos()

bool FinalizeHistos()

StatusCode FillHistos()

void SetEventInfoHandler(const XAMPP::EventInfo *Info)

void SetEventInfoHandler(const ToolHandle<XAMPP::IEventInfo> &EvInfo)

void SetSystematicsTool(const ToolHandle<XAMPP::ISystematics> &Syst)

void SetAnalysisConfig(const ToolHandle<XAMPP::IAnalysisConfig> &config)

void SetDoHistos(bool doH)

void WriteCutFlow(bool B)

unsigned int Identifier() const

bool isData() const

double GetWeight() const

double GetWeight2() const

std::string name() const

const CP::SystematicSet *SystSet() const

bool HistoInOutput(TH1 *Histo, const std::string &FullPath)

bool RegisterCutFlow(const CutFlow &Flow)

CutFlowHistoVariable *CreateCutFlowHisto(const CutFlow &Flow)

void UpdateWeight()

Protected Attributes

const XAMPP::EventInfo *m_XAMPPInfo

Private Functions

void AppendWeight(const std::string &Name)

Private Members

const CP::SystematicSet *m_set

const XAMPP::ISystematics *m_systematics

ToolHandle<XAMPP::IAnalysisConfig> m_config

ServiceHandle<ITHistSvc> m_histSvc

bool m_init

bool m_doHistos

bool m_WriteCutFlow

double m_CurrentWeight

double m_CurrentWeight2

std::vector<XAMPP::Storage<double> *> m_EventWeights

std::vector<IHistoVariable_Ptr> m_Variables

std::vector<IHistoVariable_Ptr> m_CutFlowHistos

std::vector<const CutFlow *> m_CutFlows

unsigned int m_EvNumber

class HistoBin

#include <HistoBins.h>

Public Functions

void AddContent(const double &content)

void AddError(const double &error)

void SetContent(const double &content)

void SetError(const double &error)

void Fill()

void Fill(const double &content)

double GetContent() const

double GetError() const

double GetError2() const

unsigned int GetdDimension() const

bool isOverflow(unsigned int D) const

bool isUnderFlow(unsigned int D) const

double GetLowEdge(unsigned int D) const

double GetHighEdge(unsigned int D) const

double GetCenter(unsigned int D) const

virtual bool isInsideBin(const double &X) const

virtual bool isInsideBin(const double &X, const double &Y) const

virtual bool isInsideBin(const double &X, const double &Y, const double &Z) const

double GetVolume() const

HistoBin(double x_low, double x_high)

HistoBin(double x_low, double x_high, double y_low, double y_high)

HistoBin(double x_low, double x_high, double y_low, double y_high, double z_low, double z_high)

HistoBin(const std::vector<double> &low_edges, const std::vector<double> &high_edges)

Public Static Functions

static void AddSumW2(bool B = true)

Private Functions

HistoBin(unsigned int D)

bool PassAxisBorders(unsigned int D, const double &X) const

Private Members

Weight *m_weighter

double m_content

double m_error

unsigned int m_dimension

std::unique_ptr<double> m_low_edges

std::unique_ptr<double> m_high_edges

std::unique_ptr<bool> m_is_Overflow

std::unique_ptr<bool> m_is_Undeflow

double *m_low_edges_ptr

double *m_high_edges_ptr

bool *m_underflow_ptr

bool *m_overflow_ptr

Private Static Attributes

bool m_FillSumW2 = true

class Histogram

#include <HistoBins.h>

Public Functions

Histogram(unsigned int nbins, double low_edge, double up_edge)

Histogram(unsigned int nbins_x, double x_low, double x_high, unsigned int nbins_y, double y_low, double y_high)

Histogram(unsigned int nbins_x, double x_low, double x_high, unsigned int nbins_y, double y_low, double y_high, unsigned int nbins_z, double z_low, double z_high)

Histogram(const Histogram &other)

Protected Functions

Histogram()

Protected Attributes

unsigned int m_dim

HistoAxis_Ptr m_x_axis

HistoAxis_Ptr m_y_axis

HistoAxis_Ptr m_z_axis

std::vector<HistoBin_Ptr> m_bins

size_t m_entries

class HistoLib

#include <HistoHelpers.h>

Public Types

enum LibType

Values:

Raw

Weighted

Public Functions

HistoLib(IHistoVariable *Base, LibType T)

bool Finalize()

bool FillBin(int Bin)

~HistoLib()

Private Functions

TH1 *GetHisto()

void SetNbins()

int nBins() const

void Finalize(TH1 *TH1)

Private Members

IHistoVariable *m_Ref

HistoLib::LibType m_Type

std::map<unsigned int, LibEntry> m_Library

std::map<unsigned int, LibEntry>::iterator m_Book

std::map<unsigned int, LibEntry>::iterator m_End

int m_Nbins

class HistoTemplates

#include <HistoTemplates.h>

Public Functions

bool InitTemplates(const std::string &Path)

bool Create1D(const std::string &Line)

bool Create2D(const std::string &Line)

bool Create3D(const std::string &Line)

bool CrossProduct(const std::string &Line)

bool CreateVarHisto(const std::string &Name, std::ifstream &Config)

bool CreateVarHisto(const std::string &Name, std::vector<double> &BinEdgesX, std::vector<double> &BinEdgesY, std::vector<double> &BinEdgesZ)

bool CreateTH2Poly(const std::string &Name, std::ifstream &Config)

TH1 *GetTemplate(const std::string &Name)

bool InsertTemplate(const std::string &Name, TH1 *H)

bool InsertTemplate(const std::string &Name, std::shared_ptr<TH1> H)

bool IsTemplateDefined(const std::string &Name) const

~HistoTemplates()

std::vector<double> ExtractBinningFromAxis(TAxis *Axis) const

Public Static Functions

HistoTemplates *getHistoTemplater()

Private Functions

HistoTemplates()

HistoTemplates(const HistoTemplates&)

void operator=(const HistoTemplates&)

void PrintVarBinning(std::vector<double> &Edges, const std::string &Axis)

bool Import(const std::string &Config)

bool ReadTemplateConfig(std::ifstream &Inf)

bool AddTH2PolyBin(TH2Poly *Poly, std::ifstream &Inf)

Private Members

std::map<std::string, TH1_Ptr> m_Templates

std::vector<std::string> m_ImportedCfgs

Private Static Attributes

HistoTemplates *m_DB = nullptr

class IAnalysisConfig : public virtual IAsgTool

#include <AnalysisConfig.h>

Interface for AnalysisConfig. The analysis config can store multiple user-defined cutflows.

Subclassed by XAMPP::AnalysisConfig

Public Functions

virtual StatusCode initialize() = 0

Initialize the AnalysisConfig. If the analysis config is already initialized (m_init set is true), exit without doing anything. Otherwise retrieve ToolHandle for XAMPP::EventInfo and initialize standard + custom cuts.

Return

Status code, needs to be checked with e.g. ATH_CHECK(…).

virtual bool ApplyCuts(CutKind K) = 0

Checks if at least one cut is passed. If at least one cut is passed.

Return

{ description_of_the_return_value }

Parameters

• K: { parameter_description }

virtual StatusCode AddToCutFlows(CutFlow &cf) = 0

virtual std::vector<std::string> GetCutNames(int hash = 0) const = 0

Gets the cut names.

Return

The cut names.

Parameters

• hash: The hash

virtual std::string TreeName() const = 0

Get the name of the output tree.

Return

{ description_of_the_return_value }

virtual bool RegisterHistoBase(HistoBase *Base) = 0

{ function_description }

Return

{ description_of_the_return_value }

Parameters

• Base: The base

virtual Cut *NewCut(const std::string &Name, Cut::CutType T, bool IsSkimming) = 0

virtual ~IAnalysisConfig()

Destroys the object and deletes standard cuts and user-defined cutflows.

class IAnalysisHelper : public virtual IAsgTool

#include <IAnalysisHelper.h>

Subclassed by XAMPP::SUSYAnalysisHelper

Public Functions

virtual bool AcceptEvent() = 0

virtual bool EventCleaning() const = 0

virtual bool CleanObjects(const CP::SystematicSet *systset) = 0

virtual StatusCode LoadContainers() = 0

virtual StatusCode FillInitialObjects(const CP::SystematicSet *systset) = 0

virtual StatusCode RemoveOverlap() = 0

virtual StatusCode FillObjects(const CP::SystematicSet *systset) = 0

virtual StatusCode CheckCutFlow(const CP::SystematicSet *systset) = 0

virtual StatusCode finalize() = 0

virtual bool CheckTrigger() = 0

virtual StatusCode FillEvent(const CP::SystematicSet *sys) = 0

virtual unsigned int finalState() = 0

virtual double GetMCXsec(unsigned int mc_channel_number, unsigned int finalState = 0) = 0

virtual void GetMCXsecErrors(bool &error_exists, double &rel_err_down, double &rel_err_up, unsigned int mc_channel_number, unsigned int finalState = 0) = 0

virtual double GetMCFilterEff(unsigned int mc_channel_number, unsigned int finalState = 0) = 0

virtual double GetMCkFactor(unsigned int mc_channel_number, unsigned int finalState = 0) = 0

virtual double GetMCXsectTimesEff(unsigned int mc_channel_number, unsigned int finalState = 0) = 0

virtual ~IAnalysisHelper()

class IAnalysisModule : public virtual IAsgTool

#include <IAnalysisModule.h>

Subclassed by XAMPP::BaseAnalysisModule

Public Functions

virtual StatusCode initialize() = 0

virtual StatusCode bookVariables() = 0

virtual StatusCode fill() = 0

virtual ~IAnalysisModule()

class ICutElement

#include <Cuts.h>

Subclassed by XAMPP::ParticleCutElement< T >, XAMPP::ParticleFourVectorCutElement, XAMPP::ScalarCutElement< T >, XAMPP::XAMPPMetCutElement

Public Functions

virtual ~ICutElement()

virtual bool ApplyCut(bool ForCutFlow = false) const = 0

std::string name() const

Protected Functions

ICutElement(XAMPP::IStorage *Store, XAMPP::IEventInfo *Info)

template <class T>
bool IsValid(const T &Value) const

unsigned int EventNumber() const

Private Members

XAMPP::IStorage *m_Store

XAMPP::IEventInfo *m_Info

class IDiTauSelector : public virtual IAsgTool

#include <IDiTauSelector.h>

Public Functions

virtual StatusCode LoadContainers() = 0

virtual StatusCode InitialFill(const CP::SystematicSet &systset) = 0

virtual StatusCode FillDiTaus(const CP::SystematicSet &systset) = 0

virtual const xAOD::DiTauJetContainer *GetDiTauContainer() const = 0

virtual xAOD::DiTauJetContainer *GetDiTaus() const = 0

virtual xAOD::DiTauJetContainer *GetPreDiTaus() const = 0

virtual xAOD::DiTauJetContainer *GetSignalDiTausNoOR() const = 0

virtual xAOD::DiTauJetContainer *GetSignalDiTaus() const = 0

virtual xAOD::DiTauJetContainer *GetBaselineDiTaus() const = 0

virtual xAOD::DiTauJetContainer *GetCustomDiTaus(const std::string &kind) const = 0

virtual ~IDiTauSelector()

class IElectronSelector : public virtual IAsgTool

#include <IElectronSelector.h>

Subclassed by XAMPP::SUSYElectronSelector

Public Functions

virtual StatusCode LoadContainers() = 0

virtual StatusCode InitialFill(const CP::SystematicSet &systset) = 0

virtual StatusCode FillElectrons(const CP::SystematicSet &systset) = 0

virtual StatusCode LoadSelection(const CP::SystematicSet &systset) = 0

virtual EleLink GetLink(const xAOD::Electron &el) const = 0

virtual EleLink GetOrigLink(const xAOD::Electron &el) const = 0

virtual const xAOD::ElectronContainer *GetElectronContainer() const = 0

virtual xAOD::ElectronContainer *GetElectrons() const = 0

Returns the unskimmed container of all calibrated Electron objects.

virtual xAOD::ElectronContainer *GetPreElectrons() const = 0

The pre container only contains Electronss passing the basic kinematic requirements and the baseline selection WP.

virtual xAOD::ElectronContainer *GetBaselineElectrons() const = 0

Baseline Electron candidates are preElectrons surviving the overlap removal procedure No additional quality requirement is made

virtual xAOD::ElectronContainer *GetSignalElectrons() const = 0

Signal Electrons have to pass all final selection requirements.

virtual xAOD::ElectronContainer *GetSignalNoORElectrons() const = 0

Signal quality muons are all objects which pass the baseline & signal kinematics as well as the quality selection criteria. No overlap removal is considered.

virtual xAOD::ElectronContainer *GetCustomElectrons(const std::string &kind) const = 0

virtual StatusCode SaveScaleFactor() = 0

virtual std::shared_ptr<ElectronDecorations> GetElectronDecorations() const = 0

virtual ~IElectronSelector()

class IEventInfo : public virtual IAsgTool

#include <IEventInfo.h>

Subclassed by XAMPP::EventInfo

Public Types

enum OutputElement

Values:

Tree = 1

Histo = 1 << 1

enum OutlierWeightStrategy

Values:

doNothing = 0

ignoreEvent = 1

resetWeight = 2

typedef enum XAMPP::IEventInfo::OutlierWeightStrategy OutlierWeightStrategy

Public Functions

virtual StatusCode initialize() = 0

virtual StatusCode LoadInfo() = 0

virtual StatusCode SetSystematic(const CP::SystematicSet *set) = 0

virtual const xAOD::EventInfo *GetOrigInfo() const = 0

virtual xAOD::EventInfo *GetEventInfo() const = 0

virtual const xAOD::Vertex *GetPrimaryVertex() const = 0

virtual const CP::SystematicSet *GetSystematic() const = 0

virtual const CP::SystematicSet *GetNominal() const = 0

virtual bool PassCleaning() const = 0

virtual StatusCode CopyInfoFromNominal(const CP::SystematicSet *To) = 0

virtual bool isMC() const = 0

Functions as a short cut from the event-info itself.

virtual unsigned long long eventNumber() const = 0

virtual int mcChannelNumber() const = 0

virtual unsigned int runNumber() const = 0

virtual unsigned int randomRunNumber() const = 0

virtual double GetGenWeight(unsigned int idx = 0) const = 0

virtual double GetRawGenWeight(unsigned int idx = 0) const = 0

virtual double GetPileUpLuminosity() = 0

Propagation of the luminosity to the meta-data.

virtual bool ApplyPileUp() const = 0

virtual int dsidOffSet() const = 0

virtual bool applyDSIDShift() const = 0

virtual StatusCode BookParticleStorage(const std::string &Name, bool StoreMass = false, bool SaveVariations = true, bool saveTrees = true) = 0

virtual StatusCode BookCommonParticleStorage(const std::string &Name, bool StoreMass = false, bool saveTrees = true) = 0

virtual ParticleStorage *GetParticleStorage(const std::string &Name) const = 0

virtual StatusCode BookContainerStorage(const std::string &Name, bool SaveVariations = true, bool saveTrees = true) = 0

virtual StatusCode BookCommonContainerStorage(const std::string &Name, bool saveTrees = true) = 0

virtual DataVectorStorage *GetContainerStorage(const std::string &Name) const = 0

Retrieves the container storage registered under a given name. ParticleStorages are returned as well. If the name does not exist nullptr is returned

virtual std::vector<DataVectorStorage *> GetContainerStorages(unsigned int e) const = 0

Retrieve all Container storages registered with this event info class.

virtual StatusCode createSystematicGroup(const std::string &name, XAMPP::SelectionObject obj_type) = 0

virtual std::shared_ptr<SystematicGroup> getSystematicGroup(const std::string &name) const = 0

virtual const std::vector<std::shared_ptr<SystematicGroup>> &getSystematicGroups() const = 0

virtual bool buildSplittedTrees() const = 0

Flag which disables/enables the split apart of systematic groups.

virtual void Lock() = 0

Method which disables the adding of storages.

virtual bool isLocked() const = 0

virtual int getOutlierWeightStrategy() const = 0

virtual bool isOutlierGenWeight(unsigned int idx = 0) const = 0

virtual bool isOutlierGenWeight(double w) const = 0

virtual ~IEventInfo()

class IExternalLookUpTable

#include <DataDrivenWeights.h>

Subclassed by XAMPP::TF1LookUp, XAMPP::TH1LookUp

Public Functions

virtual double read(const double x) const = 0

virtual double read(const double x, const double y) const = 0

virtual double read(const double x, const double y, const double z) const = 0

virtual bool isOverFlow(const double x) const = 0

virtual bool isOverFlow(const double x, const double y) const = 0

virtual bool isOverFlow(const double x, const double y, const double z) const = 0

virtual ~IExternalLookUpTable()

virtual std::shared_ptr<IExternalLookUpTable> clone() const = 0

virtual bool applyUncertainty(double w) = 0

class IExternalWeight

#include <DataDrivenWeights.h>

Generic interface class to evaluate weights given from external histograms. Like fake-factors for particle or event-variable based reweighting

Subclassed by XAMPP::FakeFactor

Public Functions

virtual double Evaluate(size_t entry = 0) = 0

Calculate the fake-factor weight finally.

virtual bool init(TTree *t) = 0

Initialize the access to the TTree as usual.

void setCut(std::shared_ptr<Condition> Cut)

Only apply the external weight if some condition is satisfied The method is optionally

void setLookUp(const std::shared_ptr<IExternalLookUpTable> &table)

Connect the Weighting class with the external data. The LookUp can either be a TH1 or TF1 object… Other implementations also possible

IExternalLookUpTable *lookup_table() const

bool LoadHistogramFromFile(std::stringstream &sstr)

Load the histogram table from the file.

bool LoadHistogramFromFile(const std::string &file, const std::string &histo_path)

virtual ~IExternalWeight()

IExternalWeight()

IExternalWeight(const IExternalWeight &other)

bool applyUncertainty(double w)

Apply an uncertainty based on +- w*sigma.

bool passCut() const

Private Members

std::shared_ptr<Condition> m_Cut

std::shared_ptr<IExternalLookUpTable> m_table

class IfDefFlags

#include <IfDefHelpers.h>

Public Functions

void AddFlag(const std::string &Flag)

bool IsFlagDefined(const std::string &Flag) const

bool IsVariableDefined(const std::string &variable) const

bool DefineVariable(const std::string &varname, const std::vector<std::string> &values)

Variable_Ptr RetrieveVariable(const std::string &varName) const

~IfDefFlags()

bool HasVariableCached(std::string &line)

bool CacheVariable(const std::string &name)

bool allVarsValid() const

Public Static Functions

IfDefFlags *Instance()

Protected Functions

IfDefFlags()

IfDefFlags(const IfDefFlags&)

void operator=(const IfDefFlags&)

Protected Static Attributes

IfDefFlags *m_Inst = nullptr

Private Members

StringVector m_Flags

std::vector<Variable_Ptr> m_Variables

Variable_Ptr m_VarToRead

class IfDefLineParser

#include <IfDefHelpers.h>

Public Types

enum LineStatus

Values:

NewProperty

EndOfFile

ReadError

Public Functions

IfDefLineParser()

IfDefLineParser::LineStatus operator()(std::ifstream &inf, std::string &line)

IfDefLineParser::LineStatus read(std::ifstream &inf, std::string &line)

void AddFlag(const std::string &Flag)

Private Functions

bool SkipLines(std::ifstream &inf, std::string &line)

int SkipLine(const std::string &line)

Returns 0 if the lines does not need to be skipped 1 if there is a skip statement and -1 if an endif statement is found

Private Members

bool m_InErrorState

bool m_ResolveVars

bool m_GlobalSkip

class IfDefVariable

#include <IfDefHelpers.h>

Public Functions

IfDefVariable(const std::string &name, const StringVector &values)

std::string name() const

bool Next(std::string &line)

bool isValid() const

unsigned int nLines() const

std::string getFirstElement() const

const StringVector &values() const

void clearRegister()

void Print() const

Private Members

std::string m_name

StringVector m_lines

Variable_Ptr m_cross_ref

bool m_isValid

size_t m_LineToRead

class IHistoVariable

#include <HistoHelpers.h>

Subclassed by XAMPP::CutFlowHistoVariable, XAMPP::EventHistoVariable< T >

Public Functions

virtual bool Fill() = 0

virtual TH1 *GetTemplate() const = 0

bool FillBin(int Bin)

bool WriteHisto(TH1 *Histo, HistoLib::LibType T)

bool Finalize()

void SetName(const std::string &Name)

void SetPath(const std::string &Path)

std::string name() const

std::string basepath() const

std::string path() const

unsigned int Identifier() const

double W() const

double W2() const

~IHistoVariable()

Protected Functions

IHistoVariable(HistoBase *Base, const CutFlow *Flow, const std::string &Name)

IHistoVariable(HistoBase *Base, const CutFlow *Flow)

void UpdateWeight()

Private Members

HistoBase *m_Base

const CutFlow *m_CutFlow

std::string m_Name

std::string m_Path

HistoLib m_RawLib

HistoLib m_WeightLib

class IJetSelector : public virtual IAsgTool

#include <IJetSelector.h>

Subclassed by XAMPP::SUSYJetSelector

Public Functions

virtual StatusCode LoadContainers() = 0

virtual StatusCode InitialFill(const CP::SystematicSet &systset) = 0

virtual StatusCode FillJets(const CP::SystematicSet &systset) = 0

virtual xAOD::JetContainer *GetJets() const = 0

virtual xAOD::JetContainer *GetPreJets(int Radius = 4) const = 0

virtual xAOD::JetContainer *GetBaselineJets(int Radius = 4) const = 0

virtual xAOD::JetContainer *GetSignalJets(int Radius = 4) const = 0

virtual xAOD::JetContainer *GetSignalNoORJets(int Radius = 4) const = 0

virtual xAOD::JetContainer *GetBJets() const = 0

virtual xAOD::JetContainer *GetLightJets() const = 0

virtual xAOD::JetContainer *GetCustomJets(const std::string &kind) const = 0

virtual StatusCode ReclusterJets(const xAOD::IParticleContainer *inputJets, float Rcone, float minPtKt4 = -1, std::string PreFix = "", float minPtRecl = -1, float rclus = 0., float ptfrac = -1) = 0

virtual StatusCode SaveScaleFactor() = 0

virtual std::shared_ptr<JetDecorations> GetJetDecorations() const = 0

virtual ~IJetSelector()

class IKinematicSyst

#include <EventService.h>

Subclassed by XAMPP::TreeSystematic, XAMPP::WeightSystematic

Public Functions

virtual ~IKinematicSyst()

virtual std::string syst_name() const = 0

virtual std::string tree_name() const = 0

virtual bool is_nominal() const = 0

virtual bool apply_syst() = 0

virtual void reset() = 0

class IMatrixReader : public XAMPP::ITreeMatrixReader

#include <TreeVarReader.h>

Subclassed by XAMPP::MatrixBlockReader, XAMPP::MatrixVarReader< T >, XAMPP::ParticleBlockReader, XAMPP::ParticleCorrelationReader

Public Functions

size_t entries() const

double read() const

double readEntry(const size_t I) const

bool update()

bool setIndex(const size_t I)

bool setMatrixIndex(const size_t i, const size_t j)

void reset()

size_t index() const

size_t row_index() const

size_t column_index() const

Protected Functions

IMatrixReader()

IMatrixReader(const IMatrixReader&)

void operator=(const IMatrixReader&)

std::pair<size_t, size_t> get_indices(const size_t I) const

Private Members

size_t m_row_idx

size_t m_col_idx

EventService *m_service

Long64_t m_ev_number

size_t m_tot_entries

std::vector<size_t> m_row_sizes

class IMetaDataTree : public virtual IAsgTool

#include <MetaDataTree.h>

Subclassed by XAMPP::MetaDataTree

Public Functions

virtual StatusCode initialize() = 0

virtual StatusCode beginInputFile() = 0

virtual StatusCode beginEvent() = 0

virtual StatusCode finalize() = 0

virtual StatusCode fillLHEMetaData(unsigned int Idx) = 0

virtual void subtractEventFromMetaData() = 0

virtual void subtractEventFromMetaData(unsigned int index) = 0

virtual std::vector<std::string> getLHEWeightNames() const = 0

virtual ~IMetaDataTree()

class IMetSelector : public virtual IAsgTool

#include <IMetSelector.h>

Subclassed by XAMPP::SUSYMetSelector

Public Functions

virtual StatusCode LoadContainers() = 0

virtual StatusCode SaveScaleFactor() = 0

virtual StatusCode FillMet(const CP::SystematicSet &systset) = 0

virtual xAOD::MissingETContainer *GetCustomMet(const std::string &kind = "") const = 0

virtual StatusCode addToInvisible(xAOD::IParticle *particle, const std::string &invis_container) = 0

virtual StatusCode addToInvisible(xAOD::IParticle &particle, const std::string &invis_container) = 0

virtual StatusCode addToInvisible(const xAOD::IParticleContainer *container, const std::string &invis_container) = 0

virtual StatusCode addToInvisible(const xAOD::IParticleContainer &container, const std::string &invis_container) = 0

virtual xAOD::IParticleContainer *getInvisible(const std::string &invis_container = "") const = 0

virtual ~IMetSelector()

class IMuonSelector : public virtual IAsgTool

#include <IMuonSelector.h>

Subclassed by XAMPP::SUSYMuonSelector

Public Functions

virtual StatusCode LoadContainers() = 0

virtual StatusCode InitialFill(const CP::SystematicSet &systset) = 0

virtual StatusCode FillMuons(const CP::SystematicSet &systset) = 0

virtual StatusCode LoadSelection(const CP::SystematicSet &systset) = 0

virtual MuoLink GetLink(const xAOD::Muon &mu) const = 0

virtual MuoLink GetOrigLink(const xAOD::Muon &mu) const = 0

virtual const xAOD::MuonContainer *GetMuonContainer() const = 0

virtual xAOD::MuonContainer *GetMuons() const = 0

Returns the unskimmed container of all calibrated Muon objects.

virtual xAOD::MuonContainer *GetPreMuons() const = 0

The pre container only contains Muonss passing the basic kinematic requirements and the baseline selection WP.

virtual xAOD::MuonContainer *GetBaselineMuons() const = 0

Baseline Muon candidates are preMuons surviving the overlap removal procedure No additional quality requirement is made

virtual xAOD::MuonContainer *GetSignalMuons() const = 0

Signal Muons have to pass all final selection requirements.

virtual xAOD::MuonContainer *GetSignalNoORMuons() const = 0

Signal quality muons are all objects which pass the baseline & signal kinematics as well as the quality selection criteria. No overlap removal is considered.

virtual xAOD::MuonContainer *GetCustomMuons(const std::string &kind) const = 0

virtual StatusCode SaveScaleFactor() = 0

virtual std::shared_ptr<MuonDecorations> GetMuonDecorations() const = 0

virtual ~IMuonSelector()

class InfoKeeper

Public Functions

InfoKeeper(const IEventInfo *Info = nullptr)

const IEventInfo *GetInfo() const

template <class T>
Storage<T> *RetrieveEventStorage(const std::string &Name) const

template <class T>
std::vector<Storage<T> *> GetEventStorages() const

bool EventStorageExists(const std::string &Name) const

DataVectorStorage *GetContainerStorage(const std::string &Name) const

std::vector<DataVectorStorage *> GetContainerStorages() const

bool ParticleDefined(const std::string &Name) const

bool Register(IStorage *Storage)

~InfoKeeper()

Private Members

const IEventInfo *m_RefInfo

std::map<std::string, std::shared_ptr<IStorage>> m_Storages

std::map<std::string, std::shared_ptr<IStorage>> m_ParticleStores

class InvariantDiMassReader : public XAMPP::ParticleCorrelationReader

#include <ObservableReader.h>

Public Functions

std::string name() const

Public Static Functions

ParticleCorrelationReader *GetReader(const std::string &FirstParticle, const std::string &SecondParticle)

Protected Functions

InvariantDiMassReader(const std::string &FirstParticle, const std::string &SecondParticle)

InvariantDiMassReader(const InvariantDiMassReader&)

void operator=(const InvariantDiMassReader&)

class InvariantDiPtReader : public XAMPP::ParticleCorrelationReader

#include <ObservableReader.h>

Public Functions

std::string name() const

Public Static Functions

ParticleCorrelationReader *GetReader(const std::string &FirstParticle, const std::string &SecondParticle)

Protected Functions

InvariantDiPtReader(const std::string &FirstParticle, const std::string &SecondParticle)

InvariantDiPtReader(const InvariantDiPtReader&)

void operator=(const InvariantDiPtReader&)

class IParticleCollection : public XAMPP::IParticleReader

#include <TreeVarReader.h>

Subclassed by XAMPP::CombinedParticleReader, XAMPP::DiParticleReader, XAMPP::OverlapRemovalParticleReader, XAMPP::ParticleReader, XAMPP::ResortedParticleReader, XAMPP::SubSetParticleReader

Public Functions

size_t Index() const

double read() const

double readEntry(const size_t) const

bool update()

void reset()

bool At(size_t I)

size_t entries() const

Protected Functions

IParticleCollection()

IParticleCollection(const IParticleCollection&)

void operator=(const IParticleCollection&)

Private Members

size_t m_Idx

class IParticleReader : public XAMPP::ITreeVarReader

#include <TreeVarReader.h>

Subclassed by XAMPP::IParticleCollection

Public Functions

virtual size_t Size() = 0

virtual IParticleVarReader *RetrieveVariable(const std::string &Var) = 0

virtual const TLorentzVector &P4() const = 0

virtual TLorentzVector GetP4(size_t E) = 0

virtual bool At(size_t I) = 0

virtual size_t ReaderIndex() const = 0

virtual size_t ReaderIndex(size_t I) = 0

virtual size_t Index() const = 0

virtual unsigned int GetCollectionHash() const = 0

class IParticleTagger

#include <ParticleTagger.h>

Public Functions

IParticleTagger(IParticleReader *P, unsigned int pos_inContainer, const std::string &tagger_name, std::shared_ptr<Condition> C)

IParticleTagger(IParticleReader *P, unsigned int pos_inContainer, unsigned int tagger_name, std::shared_ptr<Condition> C)

~IParticleTagger()

void newEvent()

bool isTagged() const

bool isTagged(IParticleReader *P) const

bool isTagged(IParticleReader *P, size_t particle_index) const

unsigned int particle_index() const

unsigned int tree_index() const

unsigned int hash() const

std::shared_ptr<Condition> Cut() const

IParticleReader *Particle() const

int taggerID() const

std::string name() const

std::shared_ptr<IParticleTagger> Clone(unsigned target_index)

Private Functions

IParticleTagger(const IParticleTagger&)

void operator=(const IParticleTagger&)

Private Members

IParticleReader *m_Particle

unsigned int m_ParticleIdx

std::shared_ptr<Condition> m_Cut

unsigned int m_TreeIdx

unsigned int m_Hash

int m_Id

bool m_Tagged

class IParticleVariable : public XAMPP::IParticleVarReader

#include <TreeVarReader.h>

Subclassed by XAMPP::AbsIParticleVarReader, XAMPP::CombinedP4VarReader, XAMPP::CombinedParticleVarReader, XAMPP::DeltaPhiToMetReader, XAMPP::DiParticleComponentReader, XAMPP::DiParticleVarReader, XAMPP::L1CaloReader, XAMPP::MtMetReader, XAMPP::OverlapRemovalParticleVarReader, XAMPP::ParticleVarReader, XAMPP::ResortedParticleVarReader, XAMPP::SubSetParticleVariableReader

Public Functions

size_t entries() const

size_t index() const

bool At(size_t I)

IParticleReader *getParticle() const

bool update()

void reset()

double read() const

Protected Functions

IParticleVariable(IParticleReader *particle)

IParticleVariable(const IParticleVariable&)

void operator=(const IParticleVariable&)

Private Members

IParticleReader *m_Particle

bool m_updated

size_t m_Idx

class IParticleVarReader : public XAMPP::ITreeVarReader

#include <TreeVarReader.h>

Subclassed by XAMPP::IParticleVariable, XAMPP::IParticleVectorReader

Public Functions

virtual bool At(size_t I) = 0

virtual IParticleReader *getParticle() const = 0

class IParticleVector : public XAMPP::IParticleVectorReader

#include <TreeVarReader.h>

Subclassed by XAMPP::ParticleVectorVarReader

Public Functions

IParticleReader *getParticle() const

size_t entries() const

double read() const

double readEntry(const size_t I) const

bool At(size_t I)

bool update()

bool setMatrixIndex(size_t I, size_t J)

void reset()

Protected Functions

IParticleVector(IParticleReader *particle)

IParticleVector(const IParticleVariable&)

void operator=(const IParticleVariable&)

std::pair<size_t, size_t> get_indices(const size_t I) const

Private Members

IParticleReader *m_Particle

size_t m_par_idx

size_t m_var_idx

EventService *m_service

Long64_t m_ev_number

size_t m_tot_entries

std::vector<size_t> m_row_sizes

class IParticleVectorReader : public XAMPP::IParticleVarReader

#include <TreeVarReader.h>

Subclassed by XAMPP::IParticleVector

Public Functions

virtual double readMatrixEntry(size_t I, size_t J) const = 0

virtual size_t row_entries(size_t I) const = 0

virtual bool setMatrixIndex(size_t I, size_t J) = 0

class IParticleWeightDecorator

#include <ParticleSelector.h>

Subclassed by XAMPP::ElectronWeightDecorator, XAMPP::JetWeightDecorator, XAMPP::JetWeightHandler, XAMPP::MuonWeightDecorator, XAMPP::PhotonWeightDecorator, XAMPP::SUSYMuonTriggerSFHandler, XAMPP::TauWeightDecorator

Public Functions

IParticleWeightDecorator()

~IParticleWeightDecorator()

StatusCode applySF()

StatusCode initEvent()

double getSF(const xAOD::IParticle &particle) const

bool isSFcalculated(const xAOD::IParticle &particle) const

double getBaselineEventSF() const

double getSignalEventSF() const

bool hasBaselineSF() const

bool hasSignalSF() const

void setEventSfStores(XAMPP::Storage<double> *base, XAMPP::Storage<double> *signal)

void setSfDecorators(std::shared_ptr<DoubleDecorator> dec, std::shared_ptr<DoubleAccessor> acc)

Protected Functions

StatusCode saveEventSF(const xAOD::IParticle &particle, double SF, bool isSignal)

StatusCode saveEventSF(double SF, bool isSignal)

StatusCode saveBaselineSF(double SF)

StatusCode saveSignalSF(double SF)

Private Functions

bool isStoreLocked(XAMPP::Storage<double> *&event_store) const

StatusCode applyEventSF(XAMPP::Storage<double> *&event_store, const double &SF)

StatusCode applyEventSF(XAMPP::Storage<double> *&event_store)

Private Members

std::shared_ptr<DoubleDecorator> m_part_SF_decor

std::shared_ptr<DoubleAccessor> m_part_SF_acc

std::unique_ptr<BoolDecorator> m_part_isEval_decor

std::unique_ptr<BoolAccessor> m_part_isEval_acc

XAMPP::Storage<double> *m_event_base_SF

XAMPP::Storage<double> *m_event_signal_SF

class IPermutationElement

#include <CombinatoricSelection.h>

Subclassed by XAMPP::FakeFactor

Public Functions

~IPermutationElement()

virtual IParticleReader *particle() const = 0

virtual unsigned int n_combinations() const = 0

virtual bool include_combinatorics() const = 0

virtual std::shared_ptr<DrawElementsFromSet> combinatoric_set() const = 0

virtual const std::vector<unsigned int> &get_entered() const = 0

IPermutationElement()

class IPhotonSelector : public virtual IAsgTool

#include <IPhotonSelector.h>

Subclassed by XAMPP::SUSYPhotonSelector

Public Functions

virtual StatusCode LoadContainers() = 0

virtual StatusCode InitialFill(const CP::SystematicSet &systset) = 0

virtual StatusCode FillPhotons(const CP::SystematicSet &systset) = 0

virtual PhoLink GetLink(const xAOD::Photon &ph) const = 0

virtual PhoLink GetOrigLink(const xAOD::Photon &ph) const = 0

virtual const xAOD::PhotonContainer *GetPhotonContainer() const = 0

virtual xAOD::PhotonContainer *GetPhotons() const = 0

Returns the unskimmed container of all calibrated photon objects.

virtual xAOD::PhotonContainer *GetPrePhotons() const = 0

The pre container only contains photons passing the basic kinematic requirements and the baseline selection WP.

virtual xAOD::PhotonContainer *GetBaselinePhotons() const = 0

Baseline photon candidates are preTaus surviving the overlap removal procedure No additional quality requirement is made

virtual xAOD::PhotonContainer *GetSignalPhotons() const = 0

Signal photons have to pass all final selection requirements.

virtual xAOD::PhotonContainer *GetSignalNoORPhotons() const = 0

Signal quality taus are all taus which pass the baseline & signal kinematics as well as the quality selection criteria. No overlap removal is considered.

virtual xAOD::PhotonContainer *GetCustomPhotons(const std::string &kind) const = 0

virtual StatusCode SaveScaleFactor() = 0

virtual ~IPhotonSelector()

virtual std::shared_ptr<PhotonDecorations> GetPhotonDecorations() const = 0

class IReconstructedParticles : public virtual IAsgTool

#include <ReconstructedParticles.h>

Subclassed by XAMPP::ReconstructedParticles

Public Functions

virtual StatusCode PrepareContainer(const CP::SystematicSet *Set) = 0

virtual xAOD::Particle *CreateEmptyParticle() = 0

virtual xAOD::ParticleContainer *GetContainer() = 0

virtual void WellDefined(xAOD::IParticle *P, bool W = true) = 0

virtual StatusCode CreateSubContainer(const std::string &Name) = 0

virtual xAOD::ParticleContainer *GetSubContainer(const std::string &Name) = 0

virtual StatusCode LoadSubContainer(const std::string &Name) = 0

virtual void DetachSubContainer() = 0

virtual bool HasSubContainer(const std::string &name) const = 0

virtual ~IReconstructedParticles()

class IScalarReader : public XAMPP::ITreeVarReader

#include <TreeVarReader.h>

Subclassed by XAMPP::ScalarVarReader< float >, XAMPP::ScalarVarReader< int >, XAMPP::ScalarVarReader< unsigned int >, XAMPP::ScalarVarReader< unsigned long long >, XAMPP::BinnedDataTakingReader, XAMPP::ConditionalWeightAppliedReader, XAMPP::CutAppliedReader, XAMPP::DataLumiReader, XAMPP::ExtremumVarReader, XAMPP::ParticleNthEntryReader, XAMPP::ParticleSizeReader, XAMPP::PeriodReader, XAMPP::PileUpReader, XAMPP::PseudoScalarVarReader, XAMPP::ScalarVarReader< T >, XAMPP::SumUpReader, XAMPP::VectorNthEntryReader, XAMPP::VectorSizeReader

Public Functions

bool update()

void reset()

double readEntry(const size_t I) const

size_t entries() const

Protected Functions

IScalarReader()

IScalarReader(const IScalarReader&)

void operator=(const IScalarReader&)

Private Members

bool m_updated

class IStorage

#include <EventStorage.h>

Subclassed by XAMPP::Storage< char >, XAMPP::Storage< double >, XAMPP::Storage< float >, XAMPP::Storage< int >, XAMPP::Storage< unsigned int >, XAMPP::Storage< XAMPPmet >, XAMPP::DataVectorStorage, XAMPP::Storage< T >

Public Functions

void SetSaveTrees(bool B)

void SetSaveHistos(bool B)

void SetSaveVariations(bool B)

bool SaveTrees() const

bool SaveVariations() const

bool IsParticleVariable() const

bool IsCommonVariable() const

bool SaveHistos() const

bool SaveVariable() const

~IStorage()

std::string name() const

IEventInfo *XAMPPInfo() const

std::vector<std::string> GetHistoVariables() const

TH1 *Template(const std::string &Name) const

StatusCode CreateHistogram(const std::string &variable, TH1 *Template)

StatusCode CreateHistogram(const std::string &variable, std::shared_ptr<TH1> Template)

std::shared_ptr<SystematicGroup> getSystematicGroup() const

StatusCode setSystematicGroup(const std::string &name)

Protected Functions

IStorage(const std::string &Name, IEventInfo *Info, bool IsParticleVariable, bool IsCommonVariable = false)

bool isRegistered() const

Private Types

typedef std::shared_ptr<TH1> TH1Ptr

Private Members

std::string m_Name

IEventInfo *m_Info

bool m_IsParticleVariable

bool m_Registered

bool m_SaveHisto

bool m_SaveTree

bool m_SaveAlways

bool m_IsCommon

std::map<std::string, std::shared_ptr<TH1>> m_HistoTemplates

std::shared_ptr<SystematicGroup> m_systGroup

class IStorageDefaultValues

#include <BaseAnalysisModule.h>

Subclassed by XAMPP::StorageDefaultValues< T >

Public Functions

virtual ~IStorageDefaultValues()

virtual StatusCode Fill() = 0

class ISystematics : public virtual IAsgTool

#include <ISystematics.h>

Subclassed by XAMPP::SUSYSystematics

Public Functions

virtual std::vector<const CP::SystematicSet *> GetAllSystematics() const = 0

virtual std::vector<const CP::SystematicSet *> GetKinematicSystematics(XAMPP::SelectionObject T = XAMPP::SelectionObject::Other) const = 0

virtual std::vector<const CP::SystematicSet *> GetWeightSystematics(XAMPP::SelectionObject T = SelectionObject::Other) const = 0

virtual const CP::SystematicSet *GetNominal() const = 0

virtual const CP::SystematicSet *GetCurrent() const = 0

virtual bool AffectsOnlyMET(const CP::SystematicSet *Set) const = 0

virtual bool ProcessObject(XAMPP::SelectionObject T) const = 0

virtual bool isData() const = 0

virtual bool isAF2() const = 0

virtual StatusCode resetSystematics() = 0

virtual StatusCode setSystematic(const CP::SystematicSet *Set) = 0

virtual StatusCode InsertKinematicSystematic(const CP::SystematicSet &set, XAMPP::SelectionObject T = XAMPP::SelectionObject::Other) = 0

virtual StatusCode InsertWeightSystematic(const CP::SystematicSet &set, XAMPP::SelectionObject T = XAMPP::SelectionObject::Other) = 0

virtual StatusCode InsertSystematicToolService(ISystematicToolService *Service) = 0

virtual bool SystematicsFixed() const = 0

virtual StatusCode FixSystematics() = 0

virtual ~ISystematics()

class ISystematicToolService

#include <ISystematics.h>

Subclassed by XAMPP::SUSYToolsSystematicToolHandle, XAMPP::ToolHandleSystematics< T >

Public Functions

virtual StatusCode resetSystematic() = 0

virtual StatusCode setSystematic(const CP::SystematicSet *Set) = 0

virtual StatusCode initialize() = 0

virtual std::string name() const = 0

virtual ~ISystematicToolService()

class ITauSelector : public virtual IAsgTool

#include <ITauSelector.h>

Subclassed by XAMPP::SUSYTauSelector

Public Functions

virtual StatusCode LoadContainers() = 0

virtual StatusCode InitialFill(const CP::SystematicSet &systset) = 0

virtual StatusCode FillTaus(const CP::SystematicSet &systset) = 0

virtual TauLink GetLink(const xAOD::TauJet &tau) const = 0

virtual TauLink GetOrigLink(const xAOD::TauJet &tau) const = 0

virtual const xAOD::TauJetContainer *GetTauContainer() const = 0

virtual xAOD::TauJetContainer *GetTaus() const = 0

Returns the unskimmed container of all calibrated tau objects.

virtual xAOD::TauJetContainer *GetPreTaus() const = 0

The pre container only contains taus passing the basic kinematic requirements and the baseline selection WP.

virtual xAOD::TauJetContainer *GetBaselineTaus() const = 0

Baseline Tau candidates are preTaus surviving the overlap removal procedure No additional quality requirement is made

virtual xAOD::TauJetContainer *GetSignalTaus() const = 0

Signal taus have to pass all final selection requirements.

virtual xAOD::TauJetContainer *GetSignalNoORTaus() const = 0

Signal quality taus are all taus which pass the baseline & signal kinematics as well as the quality selection criteria. No overlap removal is considered.

virtual xAOD::TauJetContainer *GetCustomTaus(const std::string &kind) const = 0

virtual StatusCode SaveScaleFactor() = 0

virtual ~ITauSelector()

virtual std::shared_ptr<TauDecorations> GetTauDecorations() const = 0

class ITreeBranchVariable

#include <TreeHelpers.h>

General interface class to communicate with the single branches throughout the data types considered

Subclassed by XAMPP::EventBranchVariable< T >, XAMPP::ITreeContainerAccessor, XAMPP::TreeBranch< T >, XAMPP::TreeHelperMet

Public Functions

virtual bool Init() = 0

virtual std::string name() const = 0

virtual bool Fill() = 0

virtual ~ITreeBranchVariable()

class ITreeContainerAccessor : public XAMPP::ITreeBranchVariable, public XAMPP::TreeHelper

#include <TreeHelpers.h>

Subclassed by XAMPP::ITreeDataVectorAccessor, XAMPP::ITreeParticleAccessor

Public Functions

virtual void Clear(size_t Reserve = 0) = 0

std::string name() const

Protected Functions

ITreeContainerAccessor(DataVectorStorage *store, TreeBase *tree, const std::string &Name)

ITreeContainerAccessor(const ITreeContainerAccessor&)

const CP::SystematicSet *systematic() const

DataVectorStorage *getStore() const

template <typename T>
bool AddBranch(T &Element)

Private Members

TreeBase *m_tree_base

DataVectorStorage *m_store

std::string m_name

class ITreeDataVectorAccessor : public XAMPP::ITreeContainerAccessor

#include <TreeHelpers.h>

Subclassed by XAMPP::TreeDataVectorAccessor< T >

Public Functions

bool Fill()

Protected Functions

ITreeDataVectorAccessor(DataVectorStorage *store, TreeBase *tree, const std::string &Name)

virtual bool PushBack(const SG::AuxElement *element, bool Resize, size_t Reserve) = 0

class ITreeMatrixReader : public virtual XAMPP::ITreeVectorReader

#include <TreeVarReader.h>

Subclassed by XAMPP::IMatrixReader

Public Functions

virtual bool setMatrixIndex(const size_t i, const size_t j) = 0

virtual double readMatrixEntry(const size_t i, const size_t j) const = 0

virtual size_t num_rows() const = 0

virtual size_t row_entries(size_t i) const = 0

virtual size_t row_index() const = 0

virtual size_t column_index() const = 0

class ITreeParticleAccessor : public XAMPP::ITreeContainerAccessor

#include <TreeHelpers.h>

Subclassed by XAMPP::ITreeParticleFourMomentConstAccessor

Public Functions

bool Fill()

Protected Functions

ITreeParticleAccessor(DataVectorStorage *store, TreeBase *tree, const std::string &Name)

virtual bool PushBack(const xAOD::IParticle *P, bool Resize, size_t Reserve) = 0

class ITreeParticleFourMomentConstAccessor : public XAMPP::ITreeParticleAccessor

#include <TreeHelpers.h>

Public Functions

bool PushBack(const xAOD::IParticle *P, bool Resize, size_t Reserve)

void Clear(size_t Reserve = 0)

bool Init()

ITreeParticleFourMomentConstAccessor(ParticleStorage *store, TreeBase *tree, Momentum Mom)

Protected Attributes

Momentum m_Momentum

std::vector<float> m_Vector

class ITreeVarReader

#include <TreeVarReader.h>

Subclassed by XAMPP::IParticleReader, XAMPP::IParticleVarReader, XAMPP::IScalarReader, XAMPP::ITreeVectorReader

Public Functions

virtual std::string name() const = 0

virtual bool init(TTree *t) = 0

virtual double read() const = 0

virtual bool update() = 0

virtual void reset() = 0

virtual size_t entries() const = 0

virtual double readEntry(const size_t I) const = 0

virtual ~ITreeVarReader()

class ITreeVarReaderStorage

#include <TreeVarReader.h>

Public Functions

bool Register(ITreeVarReader *R)

ITreeVarReader *GetReader(const std::string &Name) const

~ITreeVarReaderStorage()

Public Static Functions

ITreeVarReaderStorage *GetInstance()

Private Functions

ITreeVarReaderStorage()

ITreeVarReaderStorage(const ITreeVarReaderStorage&)

void operator=(const ITreeVarReaderStorage&)

Private Members

std::map<size_t, std::shared_ptr<ITreeVarReader>> m_DB

Private Static Attributes

ITreeVarReaderStorage *m_Inst = nullptr

class ITreeVarWriter

#include <TreeVarWriter.h>

Subclassed by XAMPP::ScalarTreeVarWriter< T >, XAMPP::VectorTreeVarWriter< T >

Public Functions

bool init(TTree *t)

virtual bool fill() = 0

std::string name() const

virtual ~ITreeVarWriter()

Protected Functions

ITreeVarWriter(const std::string &Name, ITreeVarReader *Reader)

template <typename T>
bool AddBranch(std::string Name, T &Element)

std::string RemoveProblematicStr(const std::string &str) const

Protected Attributes

std::string m_Name

bool m_Registered

TTree *m_tree

ITreeVarReader *m_Reader

class ITreeVarWriterStorage

#include <TreeVarWriter.h>

Public Functions

bool Register(ITreeVarWriter *R)

ITreeVarWriter *GetWriter(const std::string &Name)

~ITreeVarWriterStorage()

Public Static Functions

ITreeVarWriterStorage *GetInstance()

Protected Functions

ITreeVarWriterStorage()

ITreeVarWriterStorage(const ITreeVarWriterStorage&)

void operator=(const ITreeVarWriterStorage&)

Protected Static Attributes

ITreeVarWriterStorage *m_Inst = nullptr

Private Members

std::map<std::string, std::shared_ptr<ITreeVarWriter>> m_DB

class ITreeVectorReader : public virtual XAMPP::ITreeVarReader

#include <TreeVarReader.h>

Subclassed by XAMPP::ITreeMatrixReader, XAMPP::IVectorReader

Public Functions

virtual bool setIndex(const size_t I) = 0

virtual size_t index() const = 0

class ITriggerTool : public virtual IAsgTool

#include <ITriggerTool.h>

Subclassed by XAMPP::SUSYTriggerTool

Public Functions

virtual bool CheckTrigger() = 0

virtual bool CheckTriggerMatching() = 0

virtual bool CheckTrigger(const std::string &trigger_name) = 0

virtual bool IsMatchedObject(const xAOD::IParticle *el, const std::string &Trig) const = 0

virtual StatusCode SaveObjectMatching(ParticleStorage *Storage, xAOD::Type::ObjectType Type) = 0

virtual std::vector<std::shared_ptr<TriggerInterface>> GetActiveTriggers() const = 0

virtual std::shared_ptr<TriggerInterface> GetActiveTrigger(const std::string &trig_name) const = 0

virtual std::vector<std::string> GetTriggerOR(const std::string &trig_string) = 0

virtual ~ITriggerTool()

class ITruthSelector : public virtual IAsgTool

#include <ITruthSelector.h>

Subclassed by XAMPP::SUSYTruthSelector

Public Functions

virtual StatusCode LoadContainers() = 0

virtual StatusCode InitialFill(const CP::SystematicSet &systset) = 0

virtual StatusCode FillTruth(const CP::SystematicSet &systset) = 0

virtual int classifyWDecays(const xAOD::TruthParticle *particle) = 0

virtual int GetInitialState() = 0

virtual bool IsBJet(const xAOD::IParticle *j) = 0

virtual xAOD::TruthParticleContainer *GetTruthPreElectrons() const = 0

virtual xAOD::TruthParticleContainer *GetTruthBaselineElectrons() const = 0

virtual xAOD::TruthParticleContainer *GetTruthSignalElectrons() const = 0

virtual xAOD::TruthParticleContainer *GetTruthPreMuons() const = 0

virtual xAOD::TruthParticleContainer *GetTruthBaselineMuons() const = 0

virtual xAOD::TruthParticleContainer *GetTruthSignalMuons() const = 0

virtual xAOD::TruthParticleContainer *GetTruthPrePhotons() const = 0

virtual xAOD::TruthParticleContainer *GetTruthBaselinePhotons() const = 0

virtual xAOD::TruthParticleContainer *GetTruthSignalPhotons() const = 0

virtual xAOD::TruthParticleContainer *GetTruthPreTaus() const = 0

virtual xAOD::TruthParticleContainer *GetTruthBaselineTaus() const = 0

virtual xAOD::TruthParticleContainer *GetTruthSignalTaus() const = 0

virtual xAOD::TruthParticleContainer *GetTruthNeutrinos() const = 0

virtual xAOD::TruthParticleContainer *GetTruthPrimaryParticles() const = 0

virtual xAOD::JetContainer *GetTruthPreJets() const = 0

virtual xAOD::JetContainer *GetTruthBaselineJets() const = 0

virtual xAOD::JetContainer *GetTruthSignalJets() const = 0

virtual xAOD::JetContainer *GetTruthBJets() const = 0

virtual xAOD::JetContainer *GetTruthLightJets() const = 0

virtual xAOD::JetContainer *GetTruthFatJets() const = 0

virtual xAOD::JetContainer *GetTruthCustomJets(const std::string &kind) const = 0

virtual xAOD::TruthParticleContainer *GetTruthParticles() const = 0

virtual const xAOD::TruthParticleContainer *GetTruthInContainer() const = 0

virtual xAOD::TruthParticleContainer *GetTruthBSM() const = 0

virtual xAOD::TruthParticleContainer *GetTruthTop() const = 0

virtual xAOD::TruthParticleContainer *GetTruthBottom() const = 0

virtual std::shared_ptr<TruthDecorations> GetTruthDecorations() const = 0

virtual StatusCode ReclusterTruthJets(const xAOD::IParticleContainer *inputJets, float Rcone, float minPtKt4 = -1, std::string PreFix = "", float minPtRecl = -1, float rclus = 0., float ptfrac = -1) = 0

virtual ~ITruthSelector()

class IVectorReader : public XAMPP::ITreeVectorReader

#include <TreeVarReader.h>

Subclassed by XAMPP::ArrayReader< T >, XAMPP::ClassificationReader, XAMPP::MathITreeVarReader, XAMPP::MatrixNthColumnReader, XAMPP::MatrixNthRowReader, XAMPP::ParticleNthRowReader, XAMPP::ParticleRangeReader, XAMPP::ParticleRowSizeReader, XAMPP::SetReader, XAMPP::VectorColumnSizeReader, XAMPP::VectorRangeReader, XAMPP::VectorRowSizeReader, XAMPP::VectorVarReader< T >

Public Functions

double read() const

size_t index() const

bool update()

bool setIndex(const size_t I)

void reset()

Protected Functions

IVectorReader()

IVectorReader(const IVectorReader&)

void operator=(const IVectorReader&)

Private Members

size_t m_index

class IWeightElement

#include <Weight.h>

Subclassed by XAMPP::ConditionalWeight, XAMPP::FakeFactorWeight, XAMPP::FixedExternalWeight, XAMPP::NormalizationWeight, XAMPP::PileUpWeightElement, XAMPP::WeightElementFromTree

Public Types

enum SystStatus

Values:

Affected

NotAffected

SystError

Public Functions

virtual bool init(TTree *tree) = 0

virtual double read() = 0

virtual std::string name() const = 0

virtual std::vector<std::string> FindWeightVariations(TTree *Tree) = 0

virtual IWeightElement::SystStatus ApplySystematic(const std::string &variation) = 0

virtual void ResetSystematic() = 0

virtual std::vector<std::string> GetWeightVariations() = 0

virtual ITreeVarReader *GetTreeVarReader() = 0

virtual ITreeVarReader *GetSystematicReader(const std::string &Syst = "") = 0

virtual ~IWeightElement()

Public Static Functions

void FillSystSimul(bool B)

bool SimultaneousSyst()

Private Static Attributes

bool m_FillSystSimul = false

class JetDecorations : public XAMPP::ParticleDecorations

#include <JetDecorations.h>

Public Functions

JetDecorations()

void populateDefaults(SG::AuxElement &ipart)

Public Members

Decoration<char> isBadJet

Decoration<char> isBJet

Decoration<char> isBJet_Loose

Decoration<char> passJVT

Decoration<int> nTracks

Decoration<int> jetAlgorithm

Decoration<double> MV2c10

Decoration<char> DFCommonJets_jetClean_LooseBad

Decoration<float> rawJVT

class JetWeightDecorator : public XAMPP::IParticleWeightDecorator

#include <SUSYJetSelector.h>

Subclassed by XAMPP::BTagJetWeight, XAMPP::JvtJetWeight

Public Functions

JetWeightDecorator()

~JetWeightDecorator()

StatusCode saveSF(const xAOD::Jet &Jet)

virtual bool PassSelection(const xAOD::Jet &jet) const = 0

void setupDecorations(std::shared_ptr<JetDecorations> input)

Protected Functions

StatusCode calculateScaleFactor(const xAOD::Jet &Jet, float &SF)

virtual StatusCode calculateEfficiencySF(const xAOD::Jet &Jet, float &SF) = 0

virtual StatusCode calculateInefficiencySF(const xAOD::Jet &Jet, float &SF) = 0

Protected Attributes

std::shared_ptr<JetDecorations> m_jetDecorations

class JetWeightHandler : public XAMPP::IParticleWeightDecorator

#include <SUSYJetSelector.h>

Public Functions

JetWeightHandler(const CP::SystematicSet *set)

~JetWeightHandler()

const CP::SystematicSet *systematic() const

StatusCode tagTruth(const xAOD::IParticleContainer *jets, const xAOD::IParticleContainer *truthJets)

StatusCode saveSF(const xAOD::Jet &Jet)

StatusCode applySF()

bool append(const BTagJetWeightMap &sfs, const CP::SystematicSet *nominal)

bool append(const JvtJetWeightMap &sfs, const CP::SystematicSet *nominal)

void setupDecorations(std::shared_ptr<JetDecorations> decos)

Private Members

const CP::SystematicSet *m_syst

JvtJetWeight_Ptr m_JvtWeighter

BTagJetWeight_Ptr m_BTagWeighter

class JvtJetWeight : public XAMPP::JetWeightDecorator

#include <SUSYJetSelector.h>

Public Functions

JvtJetWeight(ToolHandle<CP::IJetJvtEfficiency> &SFTool)

~JvtJetWeight()

bool PassSelection(const xAOD::Jet &jet) const

StatusCode tagTruth(const xAOD::IParticleContainer *jets, const xAOD::IParticleContainer *truthJets)

Protected Functions

StatusCode calculateEfficiencySF(const xAOD::Jet &Jet, float &SF)

StatusCode calculateInefficiencySF(const xAOD::Jet &Jet, float &SF)

Private Members

CP::JetJvtEfficiency *m_SFTool_Raw_Ptr

ToolHandle<CP::IJetJvtEfficiency> m_SFTool

class L1CaloReader : public XAMPP::IParticleVariable

#include <ObservableReader.h>

Public Functions

double readEntry(size_t I) const

std::string name() const

bool init(TTree *t)

Public Static Functions

IParticleVarReader *GetReader(const std::string &Name)

Protected Functions

L1CaloReader(ParticleReader *Jets)

L1CaloReader(const L1CaloReader&)

void operator=(const L1CaloReader&)

Protected Attributes

IParticleVarReader *m_EMFrac

IParticleVarReader *m_HECFrac

class LessCondition : public XAMPP::Condition

#include <Cuts.h>

Public Functions

bool PassScalar() const

bool PassVector(size_t entry) const

bool PassMatrix(size_t column, size_t row) const

std::string name() const

class LessEqualCondition : public XAMPP::Condition

#include <Cuts.h>

Public Functions

bool PassScalar() const

bool PassVector(size_t entry) const

bool PassMatrix(size_t column, size_t row) const

std::string name() const

struct LibEntry

Public Functions

LibEntry(TH1 *Hist)

Public Members

TH1 *H

unsigned int N

bool Finalized

class LumiCalculator

#include <LumiCalculator.h>

Public Functions

double getExpectedLumiFromRun(unsigned int runNumber) const

double getExpectedLumiFromRun(unsigned int run, unsigned int block) const

double getRecordedLumiFromRun(unsigned int runNumber) const

double getExpectedLumi(unsigned int begin, unsigned int end) const

double getRecordedLumi(unsigned int begin, unsigned int end) const

bool isGoodLumiBlock(unsigned int run, unsigned int block) const

std::vector<unsigned int> good_runs() const

bool InitPileUpTool()

void SetPRWlumi(const std::vector<std::string> &lumi)

void SetPRWconfig(const std::vector<std::string> &config)

const std::vector<std::string> &GetPRWconfig() const

const std::vector<std::string> &GetPRWlumi() const

std::shared_ptr<CP::PileupReweightingTool> GetPileUpTool() const

unsigned int GetNLumiBlocks(unsigned int run) const

~LumiCalculator()

Public Static Functions

LumiCalculator *getCalculator()

Private Types

typedef std::pair<unsigned int, unsigned int> Run_Nblocks

Private Functions

LumiCalculator()

LumiCalculator(const LumiCalculator&)

void operator=(const LumiCalculator&)

void ReadLumiCalcFile(const std::string &path, std::vector<LumiCalculator::Run_Nblocks> &runset) const

Private Members

std::vector<Run_Nblocks> m_recorded_runs

std::shared_ptr<CP::PileupReweightingTool> m_prwTool

std::vector<std::string> m_PRWlumiFiles

std::vector<std::string> m_PRWconfigFiles

Private Static Attributes

LumiCalculator *m_Inst = nullptr

class LumiInterval

#include <LumiCalculator.h>

Public Functions

LumiInterval(unsigned int bin)

void set_start(unsigned int run, unsigned int lumi_block)

void set_end(unsigned int run, unsigned int lumi_block)

unsigned int bin_number() const

bool in_interval(unsigned int run, unsigned int lumi_block) const

unsigned int start_run() const

unsigned int end_run() const

unsigned int start_block() const

unsigned int end_block() const

void set_lumi(double l)

double lumi() const

Private Members

unsigned int m_start_run

unsigned int m_start_block

unsigned int m_end_run

unsigned int m_end_block

double m_lumi

unsigned int m_bin

class LumiSlicer

#include <LumiCalculator.h>

Public Functions

LumiSlicer(double slice_size)

LumiSlicer()

unsigned int find_bin(unsigned int run, unsigned int lumi_block) const

std::shared_ptr<LumiInterval> get_block(unsigned int bin) const

size_t size() const

Private Members

std::vector<std::shared_ptr<LumiInterval>> m_blocks

class MathITreeVarReader : public virtual XAMPP::IVectorReader

#include <ArithmetricReaders.h>

Subclassed by XAMPP::MathVectorScalarReader

Public Types

enum ArithmetricOperators

Values:

Unknown = 0

Plus

Minus

Times

Divide

MinusOnCirc

Modulo

Absolute

Sqrt

Ln

Exp

Inverse

Cos

Sin

Cosh

Sinh

Atanh

Acos

Public Functions

std::string name() const

bool init(TTree *t)

double readEntry(const size_t I) const

size_t entries() const

~MathITreeVarReader()

Public Static Functions

MathITreeVarReader::ArithmetricOperators operator_name(const std::string &O)

std::string operator_name(MathITreeVarReader::ArithmetricOperators O)

std::string reader_name(ITreeVarReader *R1, ITreeVarReader *R2, MathITreeVarReader::ArithmetricOperators O)

bool isBinary(MathITreeVarReader::ArithmetricOperators O)

ITreeVectorReader *GetReader(ITreeVarReader *V1, ITreeVarReader *V2, const std::string &op, const std::string &alias = "")

static ITreeVectorReader *GetReader(ITreeVarReader *V1, ITreeVarReader *V2, ArithmetricOperators op, const std::string &alias = "")

static ITreeVectorReader *GetReader(ITreeVarReader *V1, int modulo, const std::string &alias = "")

Protected Functions

void inputMustNotTheSame()

std::shared_ptr<UnaryFunc> create_functional(ArithmetricOperators O)

MathITreeVarReader(ITreeVarReader *V1, ITreeVarReader *V2, ArithmetricOperators O = ArithmetricOperators::Unknown, const std::string &alias = "")

MathITreeVarReader(ITreeVarReader *V1, int modulo, const std::string &alias = "")

MathITreeVarReader(const MathITreeVarReader&)

void operator=(const MathITreeVarReader&)

Protected Attributes

ITreeVarReader *m_V1

ITreeVarReader *m_V2

int m_modulo

Private Members

ArithmetricOperators m_operator

std::shared_ptr<UnaryFunc> m_unary_fct

std::string m_alias

bool m_Register

bool m_inReaderDiffer

std::vector<double> m_cache

Long64_t m_eventNumber

EventService *m_service

class MathVectorScalarReader : public XAMPP::MathITreeVarReader

#include <ArithmetricReaders.h>

Public Functions

size_t entries() const

Public Static Functions

ITreeVectorReader *GetReader(ITreeVarReader *V1, ITreeVarReader *V2, const std::string &op, const std::string &alias = "")

ITreeVectorReader *GetReader(ITreeVarReader *V1, ITreeVarReader *V2, ArithmetricOperators op, const std::string &alias = "")

Protected Functions

MathVectorScalarReader(ITreeVarReader *V1, ITreeVarReader *V2, ArithmetricOperators O = ArithmetricOperators::Unknown, const std::string &alias = "")

MathVectorScalarReader(const MathVectorScalarReader&)

void operator=(const MathVectorScalarReader&)

std::shared_ptr<UnaryFunc> create_functional(ArithmetricOperators O)

class MatrixBlockReader : public XAMPP::IMatrixReader

#include <UtilityReader.h>

Public Functions

bool init(TTree *t)

std::string name() const

size_t num_rows() const

size_t row_entries(const size_t I) const

double readMatrixEntry(const size_t I, const size_t J) const

Public Static Functions

ITreeMatrixReader *GetReader(ITreeMatrixReader *Reader, Cube C)

Private Functions

size_t min(size_t I, size_t J) const

MatrixBlockReader(ITreeMatrixReader *Variable, Cube C)

MatrixBlockReader(const MatrixBlockReader&)

void operator=(const MatrixBlockReader&)

Private Members

ITreeMatrixReader *m_Variable

Cube m_Cube

bool m_Registered

class MatrixNthColumnReader : public XAMPP::IVectorReader

#include <UtilityReader.h>

Public Functions

double read() const

double readEntry(size_t I) const

std::string name() const

size_t entries() const

size_t index() const

bool update()

bool init(TTree *t)

void reset()

bool setIndex(size_t I)

Public Static Functions

ITreeVectorReader *GetReader(ITreeMatrixReader *Variable, size_t C)

Protected Functions

MatrixNthColumnReader(ITreeMatrixReader *Variable, size_t C)

MatrixNthColumnReader(const MatrixNthColumnReader&)

void operator=(const MatrixNthColumnReader&)

Protected Attributes

ITreeMatrixReader *m_Var

size_t m_ColIdx

size_t m_Idx

bool m_Registered

class MatrixNthRowReader : public XAMPP::IVectorReader

#include <UtilityReader.h>

Public Functions

double readEntry(size_t I) const

bool init(TTree *t)

std::string name() const

size_t entries() const

Public Static Functions

ITreeVectorReader *GetReader(ITreeMatrixReader *Variable, size_t C)

Protected Functions

MatrixNthRowReader(ITreeMatrixReader *Variable, size_t C)

MatrixNthRowReader(const MatrixNthRowReader&)

void operator=(const MatrixNthRowReader&)

Protected Attributes

ITreeMatrixReader *m_Var

size_t m_ColIdx

bool m_Registered

template <class T>
class MatrixVarReader : public XAMPP::IMatrixReader

#include <TreeVarReader.h>

Subclassed by XAMPP::MatrixVarReaderGeV< T >

Public Functions

std::string name() const

bool init(TTree *t)

double readMatrixEntry(const size_t i, const size_t j) const

size_t num_rows() const

size_t row_entries(size_t i) const

virtual ~MatrixVarReader()

Public Static Functions

MatrixVarReader<T> *GetReader(const std::string &varname)

Protected Functions

MatrixVarReader(const std::string &varname)

MatrixVarReader(const MatrixVarReader&)

void operator=(const MatrixVarReader&)

Private Members

bool m_Registered

std::string m_var_name

std::vector<std::vector<T>> *m_var

Long64_t m_lastEvent

unsigned int m_TreeNumber

TBranch *m_branch

EventService *m_evService

TreeIndexer *m_indexer

template <class T>
class MatrixVarReaderGeV : public XAMPP::MatrixVarReader<T>

#include <TreeVarReader.h>

Public Functions

double readMatrixEntry(const size_t i, const size_t j) const

virtual ~MatrixVarReaderGeV()

Public Static Functions

MatrixVarReaderGeV<T> *GetReader(const std::string &varname)

Protected Functions

MatrixVarReaderGeV(const std::string &varname)

MatrixVarReaderGeV(const MatrixVarReaderGeV&)

void operator=(const MatrixVarReaderGeV&)

class MaximumVarReader : public XAMPP::ExtremumVarReader

#include <ObservableReader.h>

Public Functions

virtual ~MaximumVarReader()

Public Static Functions

MaximumVarReader *GetReader(const std::string &Name, const std::vector<ITreeVarReader *> &Readers)

Protected Functions

bool IsExtremum(double Current, double Test) const

double GetInitial() const

MaximumVarReader(const std::string &Name, const std::vector<ITreeVarReader *> &Readers)

class MergeHelper

#include <MergeHelpers.h>

Public Functions

MergeHelper()

void add_file(const std::string &f)

void add_file(const std::vector<std::string> &files)

std::vector<std::string> get_good_files()

std::vector<Long64_t> get_sizes()

bool split_file(const std::string &f)

Private Functions

void skim_bad_files()

Private Members

std::vector<NtupleFileInfo> m_files

std::vector<NtupleFileInfo>::const_iterator m_last

struct MetaData

Public Functions

MetaData(unsigned int ID)

Public Members

unsigned int ProcID

std::string procName

double xSec

double xSec_err_down

double xSec_err_up

bool has_xSec_err

double kFaktor

double FilterEff

Long64_t NumTotalEvents

Long64_t NumProcessedEvents

double SumW

double SumW2

bool MetaInit

bool KeeperAvailable

double luminosity

class MetaDataElement

#include <MetaDataTree.h>

Subclassed by XAMPP::MetaDataMC, XAMPP::runMetaData

Public Types

enum BookKeeperType

Values:

Original = 1

SUSY = 2

LHE3 = 3

Public Functions

MetaDataElement(ToolHandle<XAMPP::IEventInfo> m_XAMPPInfo)

virtual ~MetaDataElement()

virtual StatusCode newFile(const xAOD::CutBookkeeperContainer *container) = 0

virtual StatusCode newFile(const xAOD::LumiBlockRange *LumiBlock) = 0

virtual void CutBookKeeperAvailable(bool B) = 0

virtual StatusCode newEvent() = 0

virtual StatusCode finalize(TTree *MetaDataTree) = 0

virtual StatusCode CopyStore(const MetaDataElement *Store) = 0

virtual StatusCode fillVariation(unsigned int, double) = 0

void setLHEWeightNames(const std::vector<std::string> &weights)

size_t numOfWeights() const

virtual void SubtractEvent(unsigned int, double)

Protected Functions

bool SetBranchAddress(TTree *tree, const std::string &Name, std::string *Element)

template <typename T>
bool SetBranchAddress(TTree *tree, const std::string &Name, T &Element)

const xAOD::CutBookkeeper *FindCutBookKeeper(const xAOD::CutBookkeeperContainer *container, MetaDataElement::BookKeeperType Type = MetaDataElement::BookKeeperType::Original, unsigned int procID = 0)

Protected Attributes

ToolHandle<XAMPP::IEventInfo> m_XAMPPInfo

std::vector<std::string> m_LHE_WeightNames

class MetaDataMC : public virtual XAMPP::MetaDataElement

#include <MetaDataTree.h>

Public Functions

MetaDataMC(unsigned int mcChannel, unsigned int periodNumber, ToolHandle<XAMPP::IAnalysisHelper> &helper, ToolHandle<XAMPP::IEventInfo> info)

StatusCode newFile(const xAOD::CutBookkeeperContainer *container)

StatusCode newFile(const xAOD::LumiBlockRange *)

StatusCode newEvent()

void CutBookKeeperAvailable(bool B)

StatusCode finalize(TTree *MetaDataTree)

StatusCode CopyStore(const MetaDataElement *Store)

StatusCode fillVariation(unsigned int Id, double W)

~MetaDataMC()

void SubtractEvent(unsigned int Id, double W)

Private Functions

void AddEventInformation(std::shared_ptr<MetaDataMC::MetaData> Meta, double GenWeight)

void AddFileInformation(std::shared_ptr<MetaDataMC::MetaData> Meta, Long64_t TotEv, double SumW, double SumW2)

void SubtractEvent(std::shared_ptr<MetaDataMC::MetaData> Meta, double GenWeight)

void LoadMetaData(unsigned int ID)

bool SaveMetaDataInTree(std::shared_ptr<MetaDataMC::MetaData> Meta, TTree *tree)

Private Members

unsigned int m_MC

unsigned int m_periodNumber

ToolHandle<XAMPP::IAnalysisHelper> m_helper

std::map<unsigned int, std::shared_ptr<MetaDataMC::MetaData>> m_Data

std::map<unsigned int, std::shared_ptr<MetaDataMC::MetaData>>::iterator m_ActMeta

std::shared_ptr<MetaDataMC::MetaData> m_Inclusive

bool m_init

class MetaDataStore

#include <MetaDataTreeReader.h>

Public Functions

MetaDataStore(unsigned int DSID, unsigned int SUSYFinalState, unsigned int runNumber = -1)

MetaDataStore(unsigned int runNumber)

void AddTotalEvents(Long64_t TotEvents)

void AddProcessedEvents(Long64_t ProcessedEvents)

void AddSumW(double SumW)

void AddSumW2(double SumW2)

void SetxSectionInfo(double xSection, double kFactor, double Efficiency)

void SetRelUncertainty(double UnCert)

void ReserveSpaceTotalLumi(unsigned int N)

void ReserveSpaceProcessedLumi(unsigned int N)

void InsertTotalLumiBlock(unsigned int BCID)

void InsertProcessedLumiBlock(unsigned int BCID)

void SetPileUpLuminosity(double prwLumi)

void Lock()

void PinCrossSection()

unsigned int runNumber() const

unsigned int DSID() const

unsigned int ProcID() const

double SumW() const

double SumW2() const

Long64_t TotalEvents() const

Long64_t ProcessedEvents() const

double xSection() const

double kFactor() const

double FilterEfficiency() const

double relUncertainty() const

double prwLuminosity() const

const std::vector<unsigned int> &TotalLumiBlocks() const

const std::vector<unsigned int> &ProcessedLumiBlocks() const

~MetaDataStore()

Private Functions

MetaDataStore()

MetaDataStore(const MetaDataStore&)

void operator=(const MetaDataStore&)

Private Members

unsigned int m_DSID

unsigned int m_ProcID

unsigned int m_runNumber

double m_xSection

double m_kFactor

double m_Efficiency

double m_SumW

double m_SumW2

double m_relUncert

Long64_t m_TotalEvents

Long64_t m_ProcessedEvents

std::vector<unsigned int> m_TotalLumiBlocks

std::vector<unsigned int> m_ProcessedLumiBlocks

bool m_Locked

bool m_xSectLocked

double m_prwLumi

class MetaDataTree : public AsgMetadataTool, public virtual XAMPP::IMetaDataTree

#include <MetaDataTree.h>

Public Functions

MetaDataTree(const std::string &myname)

~MetaDataTree()

StatusCode beginInputFile()

StatusCode beginEvent()

StatusCode finalize()

StatusCode initialize()

StatusCode fillLHEMetaData(unsigned int Idx)

void subtractEventFromMetaData()

void subtractEventFromMetaData(unsigned int ix)

std::vector<std::string> getLHEWeightNames() const

Private Types

typedef std::pair<unsigned int, unsigned int> MetaID

Private Functions

void LoadMCMetaData(unsigned int mcChannel, unsigned int periodNumber)

void LoadRunMetaData(unsigned int run)

StatusCode CheckLumiBlockContainer(const std::string &Container, bool &HasCont)

Private Members

std::string m_TreeName

bool m_UseFileMetaData

bool m_fillLHEWeights

bool m_shiftMetaDSID

Flag determining whether the mcChannelNumber from the file meta-data is shifted by the m_XAMPPInfo->dsidOffSet() call

TTree *m_tree

ServiceHandle<ITHistSvc> m_histSvc

bool m_isData

bool m_init

ToolHandle<XAMPP::IAnalysisHelper> m_analysis_helper

asg::AnaToolHandle<XAMPP::IEventInfo> m_XAMPPInfo

std::map<MetaID, std::shared_ptr<MetaDataElement>> m_MetaDB

std::map<MetaID, std::shared_ptr<MetaDataElement>>::iterator m_ActDB

std::shared_ptr<XAMPP::MetaDataElement> m_DummyEntry

class MetSignificanceHandler

#include <SUSYMetSelector.h>

Public Functions

MetSignificanceHandler(const std::string &grp_name, SUSYMetSelector *MetSelector, const std::string &description = "", bool isDisabled = false)

MetSignificanceHandler(const MetSignificanceHandler&)

void operator=(const MetSignificanceHandler&)

StatusCode initialize()

StatusCode fill()

void setMissingEt(xAOD::MissingETContainer *&Met)

void storeSqrtVariables(bool B = true)

void useSofTrackTerm(bool B = true)

bool isInitialized() const

bool isDisabled() const

bool isUserConfigured() const

std::string group() const

template <class T2>
StatusCode setProperty(const std::string &property, const T2 &value)

Private Members

std::string m_grp_name

const SUSYMetSelector *m_met_selector

bool m_init

bool m_enabled

bool m_use_track_term

asg::AnaToolHandle<IMETSignificance> m_metSignif

ToolHandle<XAMPP::IEventInfo> m_event_info_handle

bool m_propertySet

xAOD::MissingETContainer **m_met_container

XAMPP::Storage<float> *m_Significance

XAMPP::Storage<float> *m_Significance_Rho

XAMPP::Storage<float> *m_Significance_VarL

bool m_store_sqrt_vars

XAMPP::Storage<float> *m_OverSqrtSumET

XAMPP::Storage<float> *m_OverSqrtHT

class MinimumVarReader : public XAMPP::ExtremumVarReader

#include <ObservableReader.h>

Public Functions

virtual ~MinimumVarReader()

Public Static Functions

MinimumVarReader *GetReader(const std::string &Name, const std::vector<ITreeVarReader *> &Readers)

Protected Functions

MinimumVarReader(const std::string &Name, const std::vector<ITreeVarReader *> &Readers)

bool IsExtremum(double Current, double Test) const

double GetInitial() const

class MomentumImbalanceReader : public XAMPP::ParticleCorrelationReader

#include <ObservableReader.h>

Public Functions

std::string name() const

Public Static Functions

ParticleCorrelationReader *GetReader(const std::string &FirstParticle, const std::string &SecondParticle)

Protected Functions

MomentumImbalanceReader(const std::string &FirstParticle, const std::string &SecondParticle)

MomentumImbalanceReader(const MomentumImbalanceReader&)

void operator=(const MomentumImbalanceReader&)

class MonoHAnalysisConfig : public XAMPP::AnalysisConfig

#include <MonoHAnalysisConfig.h>

Class to specify (on detector level, typical data/MC comparison) the event selection of the Mono-h(bb) analysis for multiple channels:

• 0 lepton signal region,
• 1 lepton control region,
• 2 lepton control region.

Public Functions

MonoHAnalysisConfig(std::string Analysis = "MonoH")

Create a proper constructor for Athena.

Parameters

• Analysis: The name of the analysis (default: MonoH)

virtual ~MonoHAnalysisConfig()

Default destructor.

Public Members

bool m_doproduction

Toggles whether a certain set cuts are applied as skimming cuts (True, for production) or applied as cutflow cuts (False, for testing purposes, creates much larger output files)

bool m_blinding

Toggles whether the mass window from 70 GeV to 140 GeV should be written to the ntuples (False: no blinding) or not (True: apply blinding). This only affects data samples, MC samples will never be blinded.

bool m_doMETTrigger

Toggles whether the MET trigger cut should be initialized (True) or not (False)

bool m_doSingleElecTrigger

Toggles whether the single electron trigger cut should be initialized (True) or not (False)

bool m_doSingleMuonTrigger

Toggles whether the single muon trigger cut should be initialized (True) or not (False)

bool m_doMETTriggerCalibration

Toggles whether the single lepton trigger cut should be used in the 1 lepton channel (True) or not (False) For the MET trigger calibration it is required to set this to true, for the analysis it should be set to false.

Protected Functions

StatusCode initializeCustomCuts()

Initialize cutflows for Mono-h(bb) analysis code.

Return

StatusCode, needs to be checked with ATH_CHECK(initializeCustomCuts); to check if the method was successful or failed.

class MonoHAnalysisHelper : public XAMPP::SUSYAnalysisHelper

#include <MonoHAnalysisHelper.h>

Class for mono h analysis helper.

Public Functions

MonoHAnalysisHelper(const std::string &myname)

Constructor.

Parameters

• myname: Name of the class instance.

~MonoHAnalysisHelper()

Default destructor.

StatusCode initialize()

Initialize MonoHAnalysisHelper: currently only calls the initialize method of the parent class SUSYAnalysisHelper.

Return

StatusCode, needs to be checked with ATH_CHECK(initialize); to check if the method was successful or failed.

StatusCode RemoveOverlap()

Re-implementation of the overlap removal method of the parent class. The difference to the standard overlap removal the large-R jets are excluded from the standard overlap removal and a custom electron - large-R jet overlap removal is performed to make sure that it is done properly (i.e. in the correct sequence).

Return

StatusCode, needs to be checked with ATH_CHECK(RemoveOverlap); to check if the method was successful or failed.

bool AcceptEvent()

Re-implementation of parent class method. Always returns true to ensure that all events are contained in the ntuple. This is done in order to add SUSYTools trigger check.

Return

Returns boolean value: true means accept event, false means discard event

Protected Types

typedef std::pair<int, int> dsid_ident

Protected Functions

StatusCode initializeAnalysisTools()

Re-implements method of parent class. Calls parent class-method and in addition sets up MET trigger SF tool and SM shape weights tool (only for MC) + configures them accordingly.

Return

StatusCode, needs to be checked with ATH_CHECK(initializeAnalysisTools); to check if the method was successful or failed.

StatusCode initializeEventVariables()

This method defines all event-level variables that should be written to the ntuple and initializes them. If you plan to add a new variable, you need to first initialize it with.

        ATH_CHECK(m_XAMPPInfo->NewEventVariable<int/float/double/bool>("name"));

        Please note that this will only initialize the storage.
        You still need to write the values, for this you must
        implement some code in the
        MonoHAnalysisHelper::ComputeEventVariables method.

        In MonoHAnalysisHelper::ComputeEventVariables you need
        first to define a XAMPP::Storage object

        static XAMPP::Storage<int/float/double/bool>*
        dec_variable =
        m_XAMPPInfo->GetVariableStorage<int/float/double/bool>("variable");

        Then you need to compute the variable and assign it to a
        variable of the desired type:

        int variable = 42;

        Finally you can store it using the storage element:

        ATH_CHECK(dec_variable->Store(variable));


        You can also initialize storage for particles or jets.
        This will store the four-momenta of the particles/jets
        and also all decorators that you list. You can do this
        with

        ATH_CHECK(m_XAMPPInfo->BookParticleStorage("particle",
        true));

        XAMPP::ParticleStorage* ParticleStore =
        m_XAMPPInfo->GetParticleStorage("particle");
        ATH_CHECK(ParticleStore->SaveInteger("some_integer_value_decorator"));
        ATH_CHECK(ParticleStore->SaveFloat("some_float_value_decorator"));
        ATH_CHECK(ParticleStore->SaveDouble("some_double_value_decorator"));
        ATH_CHECK(ParticleStore->SaveChar("some_boolean_value_decorator"));

        Note that this will only initialize the storage objects.
        You still need to specify what to fill in the
        MonoHAnalysisHelper::ComputeEventVariables method. There
        you also need to define a JetContainer or a
        ParticleContainer that should be filled in the particle
        storage.

        You can add a piece of code to the
        MonoHAnalysisHelper::ComputeEventVariables method like
        this (particle here is a placeholder for either Muon,
        Electron, Tau or Jet):

        xAOD::ParticleContainer* particles =
        m_particle_selection->GetSignalParticles();

        static XAMPP::ParticleStorage* ParticleStore =
        m_XAMPPInfo->GetParticleStorage("particle");
        ATH_CHECK(ParticleStore->Fill(particles));

Return

StatusCode, needs to be checked with ATH_CHECK(initializeEventVariables); to check if the method was successful or failed.

StatusCode ComputeEventVariables()

Calculates the event variables and fills them to the storage elements defined in MonoHAnalysisHelper::initializeEventVariables.

        You need to first initialize the storage in
        MonoHAnalysisHelper::initializeEventVariables by adding a
        piece of code to
        MonoHAnalysisHelper::initializeEventVariables like this:

        ATH_CHECK(m_XAMPPInfo->NewEventVariable<int/float/double/bool>("name"));

        Then you can compute the event level variable in the
        MonoHAnalysisHelper::ComputeEventVariables method and
        store the result.

        Here is a generic example, how to calculate and store
        event level variables:

        First you need to define a XAMPP::Storage element to
        access the storage defined in
        MonoHAnalysisHelper::initializeEventVariables.

        static XAMPP::Storage<int/float/double/bool>*
        dec_variable =
        m_XAMPPInfo->GetVariableStorage<int/float/double/bool>("variable");

        Then you need to compute the variable and assign it to a
        variable of the desired type:

        int variable = 42;  // just an example, in reality you
        would compute here e.g. the angular separation between
        two jets or retrieve a tagger score.

        Finally you can store it using the storage element
        defined earlier.

        ATH_CHECK(dec_variable->Store(variable));


        It is also possible to write the four-vector content of
        particle or jet containers with selected decorator
        information to the ntuples. This will store the
        four-momenta of the particles/jets and also all
        decorators that you list. Before you can do this, you
        need to initialize in
        MonoHAnalysisHelper::initializeEventVariables the storage
        with with

        ATH_CHECK(m_XAMPPInfo->BookParticleStorage("particle",
        true));

        XAMPP::ParticleStorage* ParticleStore =
        m_XAMPPInfo->GetParticleStorage("particle");
        ATH_CHECK(ParticleStore->SaveInteger("some_integer_value_decorator"));
        ATH_CHECK(ParticleStore->SaveFloat("some_float_value_decorator"));
        ATH_CHECK(ParticleStore->SaveDouble("some_double_value_decorator"));
        ATH_CHECK(ParticleStore->SaveChar("some_boolean_value_decorator"));

        Note that this will only initialize the storage objects.

        You then can specify what to fill in the
        MonoHAnalysisHelper::ComputeEventVariables method. Here
        you also need to define a JetContainer or a
        ParticleContainer that should be filled in the particle
        storage.

        You can add a piece of code to the
        MonoHAnalysisHelper::ComputeEventVariables method like
        this (particle here is a placeholder for either Muon,
        Electron, Tau or Jet):

        xAOD::ParticleContainer* particles =
        m_particle_selection->GetSignalParticles();

        static XAMPP::ParticleStorage* ParticleStore =
        m_XAMPPInfo->GetParticleStorage("particle");
        ATH_CHECK(ParticleStore->Fill(particles));

Return

StatusCode, needs to be checked with ATH_CHECK(ComputeEventVariables); to check if the method was successful or failed.

double getSumW(int dsid, int period_number)

Protected Attributes

bool m_doDiagnosticVariables

Toggles if variables used for initial skimming and event quality cuts are written out to the ntuple or not.

bool m_metTriggerSF

Boolean to store if MET trigger scale factor tool should be set up and applied (true) or not (false).

bool m_SMShapeWeights

Boolean to store if SM shape weight tool should be set up and applied (true) or not (false).

asg::AnaToolHandle<CP::IMetTriggerSF> m_met_trigger_sf_tool

Tool handle for the MET trigger scale factor tool.

asg::AnaToolHandle<CP::ISMShapeWeights> m_sm_shape_weights_tool_0lep

Tool handle for the standard model background modeling uncertainties tool for 0 lepton selection.

asg::AnaToolHandle<CP::ISMShapeWeights> m_sm_shape_weights_tool_1lep

Tool handle for the standard model background modeling uncertainties tool for 1 lepton selection.

asg::AnaToolHandle<CP::ISMShapeWeights> m_sm_shape_weights_tool_2lep

Tool handle for the standard model background modeling uncertainties tool for 2 lepton selection.

std::map<const CP::SystematicSet *, XAMPP::Storage<double> *> m_corrs_syst_weights

Storage element for the standard model background modeling uncertainties (stored as weights, named CorrsAndSysts according to the name used for SM background modeling uncertainties by the VHbb group)

bool m_useSystematicGroups

Boolean variable to enable storing objects without overlap removal criterium, needs to be active when running with common tree mechanism for systematics. If active, write output objects in ntuple for which systematic groups are active (should be electrons, muons, default jets) with and without overlap removal and store passOR decorator if not active, only write objects with passOR == True and do not store passOR decorator in ntuple (since it would be always True).

bool m_storeExtendedTriggerInfo

Store trigger information in ntuple output.

float m_ORfatjetElectronDR

Float value of the maximum delta R used for the electron - large-R jet overlap removal (can be set in job option file).

bool m_useTTBarMETFiltered0LepSamples

bool m_useVZqqVZbb

bool m_useZnunuBfilPTV0LepSamples

ToolHandle<CP::IPileupReweightingTool> m_prw_tool

std::map<dsid_ident, double> m_cached_sum_w

class MonoHJetSelector : public XAMPP::SUSYJetSelector

#include <MonoHJetSelector.h>

Public Functions

MonoHJetSelector(std::string myname)

Default constructor.

Parameters

• myname: The name of the class instance

virtual ~MonoHJetSelector()

Default destructor.

StatusCode InitialFill(const CP::SystematicSet &systset)

Re-implementation of parent class method. Calls parent class method. Calibrates large-R jets and track jets.

Return

StatusCode, needs to be checked with ATH_CHECK(InitialFill); to check if the method was successful or failed.

Parameters

• systset: The current systematic set

StatusCode FillJets(const CP::SystematicSet &systset)

Re-implementation of the parent class FillJets method. Calls parent class method. Then sorts these jet collections by their jet pt to ensure that the jets are ordered:

        - m_BJets
        - m_LightJets
        - m_R10PreSelJets
        - m_R02PreSelJets

        Creates view container for forward jets and fills it with
        jets satisfying 2.5 < |eta| < 4.5

        Applies muon in jet correction to small-R jets.

        Creates view container for "centralforward" jets that
        contains in this order the pt-sorted central jets and the
        pt-sorted forward jets (used for min dPhi cut).

        Creates view container for "btaggedLight" jets that
        containes in this order the pt-sorted b-tagged central
        jets and the pt-sorted light (i.e. non b-tagged) central
        jets.

        Fills baseline large-R jets and baseline track jets.

        Creates view container for track jets associated to
        large-R jet.

        The track jet containers used for b-tagging are filled.

Return

StatusCode, needs to be checked with ATH_CHECK(FillJets); to check if the method was successful or failed.

Parameters

• systset: The current systematic set

xAOD::JetContainer *GetPreJets(int Radius = 99) const

Re-implementation of the parent class method. Returns the pre jets. Depending on the radius parameter different jet collections can be obtained:

        - radius = 10: large-R jets (usually anti-kt 10)
        - radius = 2: track jets (usually anti-kt 02)
        - radius = 4: small-R jets (usually anti-kt 04) (via
          parent class method)

Return

The pre jet container of a desired jet collection (selected by the radius parameter).

Parameters

• Radius: The radius parameter of the desired jet collection

double BtagDL1r_pb(const xAOD::Jet &jet) const

Function that uses the b-tagging tool to retrieve the DL1r_pb variable.

Return

”pb” variable of DL1r (DL1r_pb)

double BtagDL1r_pc(const xAOD::Jet &jet) const

Function that uses the b-tagging tool to retrieve the DL1r_pc variable.

Return

”pc” variable of DL1r (DL1r_pc)

double BtagDL1r_pu(const xAOD::Jet &jet) const

Function that uses the b-tagging tool to retrieve the DL1r_pu variable.

Return

”pu” variable of DL1r (DL1r_pu)

double recalculate_DL1r(const xAOD::Jet &jet) const

Function that computes the final DL1r tagger. The DL1r is a b-tagging algorithm based on a DeepNeuralNetwork. With respect the previous DL1 tagger, DL1r uses a Recurrent Neural Networks (RNN) version of the low-level b-tagging algorithm and is expected to have a better performance. The output of DL1r tagger (as for the DL1) comes in three variants: DL1r_pb, DL1r_pc, DL1rpu, corresponding to the probability for the jet to a b, c or light-flavour jet, respectively.

        The final DL1r discriminant can be constructed, through the recalculate_DL1r
       function, as:
       DL1r =  ln(DL1r_pb/(DL1r_pc*f + (1-f)DL1r_pu))
       where f represents the fraction of c-jets.

Return

The final DL1r discriminant, given the output of BtagDL1r_pb,BtagDL1r_pc and BtagDL1r_pu

xAOD::JetContainer *GetBaselineJets(int Radius = 99) const

Re-implementation of the parent class method. Returns the baseline jets. Depending on the radius parameter different jet collections can be obtained:

        - radius = 10: large-R jets (usually anti-kt 10)
        - radius = 2: track jets (usually anti-kt 02)
        - radius = 4: small-R jets (usually anti-kt 04) (via
          parent class method)

Return

The baseline jet container of a desired jet collection (selected by the radius parameter).

Parameters

• Radius: The radius parameter of the desired jet collection

StatusCode initialize()

Re-implementation of the parent class initialize method, calls parent class initialize method. Sets up muon tool (for muon in jet correction). Sets up b-tagging tool for track jets and prepares weights for storing b-tagging scale factors.

Return

StatusCode, needs to be checked with ATH_CHECK(initialize); to check if the method was successful or failed.

StatusCode SaveScaleFactor()

Re-implementation of the parent class SaveScaleFactor method. Calls parent class method, then loops over track jets to store track jet b-tagging scale factors.

Return

StatusCode, needs to be checked with ATH_CHECK(SaveScaleFactor); to check if the method was successful or failed.

Protected Functions

bool PassBaseline(const xAOD::IParticle &P) const

Checks if jet passes baseline jet selection. This is currently implemented in a horribly hard-coded manner which could be improved.

        - track jets: need to have at least 2 constituents
        - small-R jets: either pt > 20 GeV and |eta| <= 2.5 or pt
          > 30 GeV and  2.5 |eta| <= 4.5 GeV
        - otherwise: always accepted

Return

True if jet passes the baseline requirements, False otherwise

Parameters

• P: Particle (in this case a jet) to be checked

StatusCode preCalibCorrection(xAOD::JetContainer *Container)

This function allows to add a correction to the jets (e.g. remedy a missing variable by calculating on the fly) before they are calibrated.

Return

StatusCode, needs to be checked with ATH_CHECK(preCalibCorrection); to check if the method was successful or failed.

Parameters

• Container: The jet container for which the correction should be applied.

TLorentzVector getELossTLV(const xAOD::Muon *mu)

Helper function to get energy loss of muon in the calorimeter as a ROOT TLorentzVector.

Return

The energy loss of the muon in the calorimeter as a ROOT TLorentzVector

Parameters

• mu: pointer to xAOD::Muon for which the energy loss in the calorimeter should be retrieved

Protected Attributes

float m_Kt04_ForwardJetMinEta

Minimal eta of forward jets.

float m_Kt04_ForwardJetMaxEta

Maximal eta of forward jets.

float m_Kt04_ForwardJetMinPt

Minimal pt of forward jets.

std::string m_R10name

String storing the name of the large-R jet container in the xAOD input file.

std::string m_R02name

String storing the name of the track jet container in the xAOD input file.

std::string m_R02linkname

String storing the name of the element links of the track jets to the associated large-R jets.

xAOD::JetContainer *m_R10PreSelJets

Jet container for pre large-R jets.

xAOD::JetContainer *m_R10BaselineJets

Jet container for baseline large-R jets.

xAOD::JetContainer *m_R02PreSelJets

Jet container for pre track jets.

xAOD::JetContainer *m_R02BaselineJets

Jet container for baseline track jets.

xAOD::JetContainer *m_R02BtaggingJets

Jet container for track jets used for b-tagging.

xAOD::JetContainer *m_ForwardJets

Jet container for forward jets (those are defined by 2.5 < |eta| < 4.5)

xAOD::JetContainer *m_CentralAndForwardJets

Jet container for pt-sorted central jets followed by pt-sorted forward jets. Those get joined without resorting afterwards, resulting in an order of.

leading central jet, subleading central jet, …, leading forward jet, subleading forward jet, …

Those jets are used for the DeltaPhiMin3 cut.

xAOD::JetContainer *m_BTaggedAndLightJets

Jet container for pt-sorted b-tagged central jets followed by light / non-btagged central jets. Those get joined without resorting afterwards, resulting in an order of.

leading b-jet, subleading b-jet, …, leading light jet, subleading light jet, …

Those jets are used for reconstructing the Higgs candidate mass and pt cuts in the resolved selection.

ToolHandle<XAMPP::IMuonSelector> m_muon_selection

Tool handle for XAMPP muon selector (required to retrieve the muon for the muon in jet correction)

ToolHandle<CP::IMuonSelectionTool> m_muon_selTool

Tool handle for muon selection tool (required to check the quality of muons used for the muon in jet correction)

float m_dR_mu_jet

Float storing maximum delta R for muon to jet matching (required for muon in jet correction)

float m_mu_min_pt

Float storing minimum pt of muons matched to jets for muon to jet correction. (required for muon in jet correction)

int m_mu_quality

Integer storing minimum quality of muons matched to jets for muon to jet correction. (required for muon in jet correction)

For meaning of the muon quality c.f. https://twiki.cern.ch/twiki/bin/view/Atlas/MuonSelectionTool {Tight, Medium, Loose, VeryLoose}, corresponding to 0, 1, 2 and 3 (default is 3 - VeryLoose quality)

ToolHandle<IBTaggingEfficiencyTool> m_TrkJet_bTagEffTool

Tool handle for track jet b-tagging efficiency tool.

ToolHandle<IBTaggingSelectionTool> m_TrkJet_bTagSelTool

Tool handle for track jet b-tagging selection tool.

std::vector<JetWeightHandler_Ptr> m_TrackSF

Vector of JetWeightHandler_Ptr, required to handle and store b-tagging scale factors for track jets.

std::vector<const xAOD::Jet *> m_trackJetsForBtagging

Vector of track jets used for b-tagging in the merged selection.

class MonoHMetSelector : public XAMPP::SUSYMetSelector

#include <MonoHMetSelector.h>

Public Functions

MonoHMetSelector(std::string myname)

Default constructor.

Parameters

• myname: The name of the class instance

~MonoHMetSelector()

Default destructor.

StatusCode initialize()

Re-implementation of the parent class initialize method, calls parent class initialize method. Initializes also.

        - MetTSTmuInvis

        If m_store_significance_muInvis is enabled also the
        object based met significance tool
        "noPUJets_noSoftTerm_muInvis" will be initialized.

        Note that the order in which the parent class method and
        the additional tools are defined is important! One does
        indeed need to first configure the additional object
        based MET significance and AFTER THAT call the parent
        class method.

        The MET trigger scale factor weights ("MET_TriggerSF")
        will be initialized.

Return

StatusCode, needs to be checked with ATH_CHECK(initialize); to check if the method was successful or failed.

StatusCode FillMet(const CP::SystematicSet &systset)

Re-implementation of the parent class FillMet method, calls parent class method. The MET containers.

        - MetTSTmuInvis

        will be filled. These contain the METmuInvis which is
        calculated by making the leading muon invisible for the
        MET calculation. Note that the "conventional" MET
        containers are still written out, this is done in
        the XAMPPbase class.

Return

StatusCode, needs to be checked with ATH_CHECK(FillMet); to check if the method was successful or failed.

Parameters

• systset: The currently active systematic set

StatusCode SaveScaleFactor()

Re-implementation of the parent class SaveScaleFactor method. First the parent class method is called (which just returns True and does nothing else at the time of writing this documentation) and then stores the MET trigger SF . For retrieving the MET trigger SF either MetTST or MetTSTmuInvis (m_doMetOneLepton) is used, depending on the baseline and signal muon multiplicity.

Return

StatusCode, needs to be checked with ATH_CHECK(SaveScaleFactor); to check if the method was successful or failed.

Protected Attributes

bool m_store_significance_muInvis

Boolean variable to enable calculation of object based MET significance for METmuInvis in one lepton control region.

xAOD::MissingETContainer *m_MetTSTMuInvisible

Missing ET container for MetTST with leading muon marked invisible during MET calculation. Relevant for one lepton control region.

XAMPP::Storage<XAMPPmet> *m_sto_MetTSTmuInvis

Storage element for MetTrack with leading muon marked invisible during MET calculation. Relevant for one lepton control region.

MetSignificanceHandler_Ptr m_metSignif_noPUJets_noSoftTerm_muInvis

Pointer to MET significance handler for object-based MET significance based on MetTSTMuInvisible. Relevant for one lepton control region.

asg::AnaToolHandle<CP::IMetTriggerSF> m_met_trigger_sf_tool

Tool handle for MET trigger scale factor tool.

std::map<const CP::SystematicSet *, XAMPP::Storage<double> *> m_SFs

Weights for storing MET trigger scale factors.

class MonoHTruthAnalysisConfig : public XAMPP::TruthAnalysisConfig

#include <MonoHAnalysisConfig.h>

Class to specify (on truth level, typical for signal MC studies) the event selection of the Mono-h(bb) analysis for the channels:

• 0 lepton signal region (truth).

Public Functions

MonoHTruthAnalysisConfig(std::string Analysis = "MonoHTruth")

Create a proper constructor for Athena.

Parameters

• Analysis: The name of the analysis (default: MonoHTruth)

virtual ~MonoHTruthAnalysisConfig()

Default destructor.

Protected Functions

StatusCode initializeCustomCuts()

Initialize cutflows for Mono-h(bb) truth analysis code.

Return

StatusCode, needs to be checked with ATH_CHECK(initializeCustomCuts); to check if the method was successful or failed.

class MonoHTruthAnalysisHelper : public XAMPP::SUSYTruthAnalysisHelper

#include <MonoHTruthAnalysisHelper.h>

Public Functions

MonoHTruthAnalysisHelper(std::string myname)

Constructor.

Parameters

• myname: Name of the class instance.

virtual ~MonoHTruthAnalysisHelper()

Default destructor.

unsigned int finalState()

Overwrite finalState method of parent class to always always return the value 1. Note about finalState: SUSY analysis uses this concept to distinguish background: 0 and signal: 1 and higher values. The FS in cross-section file must also have the value 1 to have the correct cross-section assigned.

Return

Returns the final state encoded as integer (background 0, signal 1 or higher value)

Protected Functions

StatusCode initializeEventVariables()

This method defines all event-level variables that should be written to the ntuple and initializes them. If you plan to add a new variable, you need to first initialize it with.

        ATH_CHECK(m_XAMPPInfo->NewEventVariable<int/float/double/bool>("name"));

        Please note that this will only initialize the storage.
        You still need to write the values, for this you must
        implement some code in the
        MonoHTruthAnalysisHelper::ComputeEventVariables method.

        In MonoHTruthAnalysisHelper::ComputeEventVariables you need
        first to define a XAMPP::Storage object

        static XAMPP::Storage<int/float/double/bool>*
        dec_variable =
        m_XAMPPInfo->GetVariableStorage<int/float/double/bool>("variable");

        Then you need to compute the variable and assign it to a
        variable of the desired type:

        int variable = 42;

        Finally you can store it using the storage element:

        ATH_CHECK(dec_variable->Store(variable));


        You can also initialize storage for particles or jets.
        This will store the four-momenta of the particles/jets
        and also all decorators that you list. You can do this
        with

        ATH_CHECK(m_XAMPPInfo->BookParticleStorage("particle",
        true));

        XAMPP::ParticleStorage* ParticleStore =
        m_XAMPPInfo->GetParticleStorage("particle");
        ATH_CHECK(ParticleStore->SaveInteger("some_integer_value_decorator"));
        ATH_CHECK(ParticleStore->SaveFloat("some_float_value_decorator"));
        ATH_CHECK(ParticleStore->SaveDouble("some_double_value_decorator"));
        ATH_CHECK(ParticleStore->SaveChar("some_boolean_value_decorator"));

        Note that this will only initialize the storage objects.
        You still need to specify what to fill in the
        MonoHTruthAnalysisHelper::ComputeEventVariables method. There
        you also need to define a JetContainer or a
        ParticleContainer that should be filled in the particle
        storage.

        You can add a piece of code to the
        MonoHTruthAnalysisHelper::ComputeEventVariables method like
        this (particle here is a placeholder for either Muon,
        Electron, Tau or Jet):

        xAOD::ParticleContainer* particles =
        m_particle_selection->GetSignalParticles();

        static XAMPP::ParticleStorage* ParticleStore =
        m_XAMPPInfo->GetParticleStorage("particle");
        ATH_CHECK(ParticleStore->Fill(particles));

Return

StatusCode, needs to be checked with ATH_CHECK(initializeEventVariables); to check if the method was successful or failed.

StatusCode ComputeEventVariables()

Calculates the event variables and fills them to the storage elements defined in MonoHTruthAnalysisHelper::initializeEventVariables.

        You need to first initialize the storage in
        MonoHTruthAnalysisHelper::initializeEventVariables by adding a
        piece of code to
        MonoHTruthAnalysisHelper::initializeEventVariables like this:

        ATH_CHECK(m_XAMPPInfo->NewEventVariable<int/float/double/bool>("name"));

        Then you can compute the event level variable in the
        MonoHTruthAnalysisHelper::ComputeEventVariables method and
        store the result.

        Here is a generic example, how to calculate and store
        event level variables:

        First you need to define a XAMPP::Storage element to
        access the storage defined in
        MonoHTruthAnalysisHelper::initializeEventVariables.

        static XAMPP::Storage<int/float/double/bool>*
        dec_variable =
        m_XAMPPInfo->GetVariableStorage<int/float/double/bool>("variable");

        Then you need to compute the variable and assign it to a
        variable of the desired type:

        int variable = 42;  // just an example, in reality you
        would compute here e.g. the angular separation between
        two jets or retrieve a tagger score.

        Finally you can store it using the storage element
        defined earlier.

        ATH_CHECK(dec_variable->Store(variable));


        It is also possible to write the four-vector content of
        particle or jet containers with selected decorator
        information to the ntuples. This will store the
        four-momenta of the particles/jets and also all
        decorators that you list. Before you can do this, you
        need to initialize in
        MonoHTruthAnalysisHelper::initializeEventVariables the storage
        with with

        ATH_CHECK(m_XAMPPInfo->BookParticleStorage("particle",
        true));

        XAMPP::ParticleStorage* ParticleStore =
        m_XAMPPInfo->GetParticleStorage("particle");
        ATH_CHECK(ParticleStore->SaveInteger("some_integer_value_decorator"));
        ATH_CHECK(ParticleStore->SaveFloat("some_float_value_decorator"));
        ATH_CHECK(ParticleStore->SaveDouble("some_double_value_decorator"));
        ATH_CHECK(ParticleStore->SaveChar("some_boolean_value_decorator"));

        Note that this will only initialize the storage objects.

        You then can specify what to fill in the
        MonoHTruthAnalysisHelper::ComputeEventVariables method. Here
        you also need to define a JetContainer or a
        ParticleContainer that should be filled in the particle
        storage.

        You can add a piece of code to the
        MonoHTruthAnalysisHelper::ComputeEventVariables method like
        this (particle here is a placeholder for either Muon,
        Electron, Tau or Jet):

        xAOD::ParticleContainer* particles =
        m_particle_selection->GetSignalParticles();

        static XAMPP::ParticleStorage* ParticleStore =
        m_XAMPPInfo->GetParticleStorage("particle");
        ATH_CHECK(ParticleStore->Fill(particles));

Return

StatusCode, needs to be checked with ATH_CHECK(ComputeEventVariables); to check if the method was successful or failed.

bool isBJet(const xAOD::Jet &jet) const

Private Members

std::unique_ptr<TRandom3> m_r3

Random number generator (TRandom3 reference: https://root.cern.ch/doc/master/classTRandom3.html) used for emulating b-tagging efficiency on truth level.

class MonoHTruthSelector : public XAMPP::SUSYTruthSelector

#include <MonoHTruthSelector.h>

Public Functions

MonoHTruthSelector(std::string myName)

Default constructor.

Parameters

• myName: Name of the class instance

virtual ~MonoHTruthSelector()

Default destructor.

StatusCode initialize()

Re-implements the parent class initialize method. Calls parent class initialize method, then (if doTruthJets is enabled) initializes TruthFatJet and TruthTrackJet containers.

Return

StatusCode, needs to be checked with ATH_CHECK(initialize); to check if the method was successful or failed.

StatusCode LoadContainers()

Re-implements the parent class LoadContainers method. Calls parent class LoadContainers method, then (if doTruthParticles is enabled) fill W, Z, top containers with four momenta of the corresponding truth particles.

Return

StatusCode, needs to be checked with ATH_CHECK(LoadContainers); to check if the method was successful or failed.

StatusCode InitialFill(const CP::SystematicSet &systset)

Re-implements the parent class InitialFill method. Calls parent class InitialFill method, then (if doTruthJets is enabled) fills preFatJets, baselineFatJets, signalFatJets and preTrackJets, baselineTrackJets, signalTrackJets containers.

Return

StatusCode, needs to be checked with ATH_CHECK(InitialFill); to check if the method was successful or failed.

Parameters

• systset: The current systematic set

StatusCode FillTruth(const CP::SystematicSet &systset)

Re-implements the parent class FillTruth method. Calls parent class FillTruth method, then fills the preselection, baseline and signal containers for TruthFatJets and TruthTrackJets.

Return

StatusCode, needs to be checked with ATH_CHECK(FillTruth); to check if the method was successful or failed.

Parameters

• systset: The current systematic set

virtual xAOD::JetContainer *GetTruthFatJets() const

Gets the truth large-R jets.

Return

Returns pointer to xAOD::JetContainer which contains the truth signal large-R jets

virtual const FourMomentumContainer &GetTruthWbosonMomenta() const

Gets the truth W boson momenta.

Return

Returns vector of TLorentzVector with truth W boson momenta

virtual const FourMomentumContainer &GetTruthZbosonMomenta() const

Gets the truth Z boson momenta.

Return

Returns vector of TLorentzVector with truth Z boson momenta

virtual const FourMomentumContainer &GetTruthTopQuarkMomenta() const

Gets the truth top quark momenta.

Return

Returns vector of TLorentzVector with truth top quark momenta

Private Functions

bool doTruthFatJets() const

Boolean to enable/disable processing of truth large-R jets.

Return

Returns True if truth large-R jets should be processed, False otherwise

std::string FatJetKey() const

String storing truth large-R jet container name (if you don’t know this, you can inspect the contents of the xAOD file to learn the truth large-R jet container name)

Return

Returns string storing the truth large-R jet container name

bool doTruthTrackJets() const

Boolean to enable/disable processing of truth track jets.

Return

Returns True if truth track jets should be processed, False otherwise

std::string TrackJetKey() const

String storing truth track jet container name (if you don’t know this, you can inspect the contents of the xAOD file to learn the truth track jet container name - note that not in all xAOD files, e.g. TRUTH3 derivations there is such an container)

Return

Returns string storing the truth track jet container name

StatusCode ConstructMotherOfPrimaryDecay(const std::vector<std::pair<int, int>> &&daughterPdgIdPairs, FourMomentumContainer &motherFourMomenta)

Helper function for constructing mother particle four momenta out of primary decay. This function gets the four momentum of a heavy particle which decayed into a pair of particles provided by the pdg id pairs. The function fails if there are ambiguities, e.g. in ZZ->llll events.

Return

StatusCode, needs to be checked with ATH_CHECK(ConstructMotherOfPrimaryDecay); to check if the method was successful or failed.

Parameters

• daughterPdgIdPairs: The daughter pdg identifier pairs
• motherFourMomenta: The mother four momenta

bool IsFromSecondaryDecay(const xAOD::TruthParticle &truthPrt)

Helper function to check if truth particle originates from secondary decay.

Return

True if from secondary decay, False otherwise.

Parameters

• truthPrt: The truth particle to be checked.

bool IsBremsProduct(const xAOD::TruthParticle &truthPrt)

Helper function to check if truth particle originates from Bremsstrahlung.

Return

True if brems product, False otherwise.

Parameters

• truthPrt: The truth particle to be checked.

Private Members

ObjectDefinition m_FatJetDefs

XAMPP ObjectDefinition for truth large-R jets.

xAOD::JetContainer *m_PreFatJets

Jet container for storing truth pre large-R jets.

xAOD::JetContainer *m_BaselineFatJets

Jet container for storing truth baseline large-R jets.

xAOD::JetContainer *m_SignalFatJets

Jet container for storing truth signal large-R jets.

ObjectDefinition m_TrackJetDefs

XAMPP ObjectDefinition for truth track jets.

xAOD::JetContainer *m_InitialTrackJets

Pointer to xAOD truth track jet container.

xAOD::JetContainer *m_PreTrackJets

Jet container for storing truth pre track jets.

xAOD::JetContainer *m_BaselineTrackJets

Jet container for storing truth baseline track jets.

xAOD::JetContainer *m_SignalTrackJets

Jet container for storing truth signal track jets.

FourMomentumContainer m_truthWbosonMomenta

Container of truth W boson momenta stored as TLorentzVector.

FourMomentumContainer m_truthZbosonMomenta

Container of truth Z boson momenta stored as TLorentzVector.

FourMomentumContainer m_truthTopQuarkMomenta

Container of truth top quark momenta stored as TLorentzVector.

class MonteCarloPeriodHandler

#include <MetaDataTreeReader.h>

Public Functions

MonteCarloPeriodHandler(unsigned int DSID)

unsigned int DSID() const

std::vector<unsigned int> getMCcampaigns() const

MonteCarloStoreHandler_Ptr getHandler(unsigned int run = -1) const

MonteCarloStoreHandler_Ptr insertHandler(unsigned int run)

double prwTotalLuminosity(unsigned int procID) const

MetaDataStore_Ptr getStore(unsigned int procID, unsigned int run = -1) const

MetaDataStore_Ptr insertStore(unsigned int procID, unsigned int run)

void AddTotalEvents(Long64_t TotEvents, unsigned procID, unsigned int run = -1)

void AddProcessedEvents(Long64_t ProcessedEvents, unsigned procID, unsigned int run = -1)

void AddSumW(double SumW, unsigned procID, unsigned int run = -1)

void AddSumW2(double SumW2, unsigned procID, unsigned int run = -1)

void SetPileUpLuminosity(double prwLumi, unsigned int procID, unsigned int run = -1)

void SetxSectionInfo(double xSection, double kFactor, double Efficiency, unsigned int procID)

void SetRelUncertainty(double UnCert, unsigned int procID)

void Lock()

void PinCrossSection()

Private Functions

MonteCarloPeriodHandler(const MonteCarloPeriodHandler&)

void operator=(const MonteCarloPeriodHandler&)

Private Members

std::vector<MonteCarloStoreHandler_Ptr> m_periods

MonteCarloStoreHandler_Ptr m_summary_period

bool m_locked

class MonteCarloStoreHandler

#include <MetaDataTreeReader.h>

Public Functions

MonteCarloStoreHandler(unsigned int DSID, unsigned int runNumber)

MetaDataStore_Ptr getSubProcess(unsigned int processID) const

MetaDataStore_Ptr insertSubProcess(unsigned int processID)

void Lock()

unsigned int DSID() const

unsigned int runNumber() const

std::vector<unsigned int> getListOfProcesses() const

double SumW(unsigned int procID) const

double SumW2(unsigned int procID) const

double prwLuminosity(unsigned int procID) const

Long64_t TotalEvents(unsigned int procID) const

Long64_t ProcessedEvents(unsigned int procID) const

double xSection(unsigned int procID) const

double kFactor(unsigned int procID) const

double FilterEfficiency(unsigned int procID) const

double relUncertainty(unsigned int procID) const

Private Functions

MonteCarloStoreHandler(const MonteCarloStoreHandler&)

void operator=(const MonteCarloStoreHandler&)

Private Members

std::vector<MetaDataStore_Ptr> m_processes

MetaDataStore_Ptr m_current

unsigned int m_DSID

unsigned int m_runNumber

bool m_locked

class MtMetReader : public XAMPP::IParticleVariable

#include <ObservableReader.h>

Public Functions

double readEntry(size_t I) const

std::string name() const

bool init(TTree *t)

Public Static Functions

IParticleVarReader *GetReader(const std::string &Particle, const std::string &Met)

Protected Functions

MtMetReader(const std::string &Particle, const std::string &Met)

MtMetReader(const MtMetReader&)

void operator=(const MtMetReader&)

Protected Attributes

IParticleVarReader *m_par_pt

IParticleVarReader *m_par_phi

std::string m_met

ITreeVarReader *m_met_value

ITreeVarReader *m_met_phi

bool m_Registered

class MuonDecorations : public XAMPP::ParticleDecorations

#include <MuonDecorations.h>

Public Functions

MuonDecorations()

void populateDefaults(SG::AuxElement &ipart)

Public Members

Decoration<char> isCosmicMuon

Decoration<char> enterCosmicSelection

Decoration<char> isBadMuon

Decoration<char> enterBadMuonSelection

Decoration<float> z0sinTheta

Decoration<float> d0sig

Decoration<float> d0raw

Decoration<ElementLink<xAOD::TruthParticleContainer>> truthParticleLink

Decoration<int> truthType

Decoration<int> truthOrigin

class MuonWeight : public XAMPP::MuonWeightDecorator

#include <SUSYMuonSelector.h>

Public Functions

MuonWeight(ToolHandle<CP::IMuonEfficiencyScaleFactors> &SFTool, XAMPP::EventInfo *info)

void setValidityRangeAbsEta(double min, double max)

void setValidityRangePt(double min, double max)

~MuonWeight()

Protected Functions

StatusCode calculateSF(const xAOD::Muon &muon, float &SF)

Private Members

ToolHandle<CP::IMuonEfficiencyScaleFactors> &m_SFTool

XAMPP::EventInfo *m_XAMPPInfo

double m_validity_eta_min

double m_validity_eta_max

double m_validity_pt_min

double m_validity_pt_max

class MuonWeightDecorator : public XAMPP::IParticleWeightDecorator

#include <SUSYMuonSelector.h>

Subclassed by XAMPP::MuonWeight, XAMPP::MuonWeightHandler

Public Functions

MuonWeightDecorator()

~MuonWeightDecorator()

StatusCode saveSF(const xAOD::Muon &muon, bool isSignal)

Protected Functions

virtual StatusCode calculateSF(const xAOD::Muon &muon, float &SF) = 0

class MuonWeightHandler : public XAMPP::MuonWeightDecorator

#include <SUSYMuonSelector.h>

Public Functions

MuonWeightHandler(const CP::SystematicSet *syst_set)

const CP::SystematicSet *systematic() const

size_t nWeights() const

StatusCode saveBaselineTriggerSF(const xAOD::MuonContainer *muons)

StatusCode saveSignalTriggerSF(const xAOD::MuonContainer *muons)

void multipleTriggerSF(bool B = true)

StatusCode saveSF(const xAOD::Muon &muon, bool isSignal)

StatusCode applySF()

bool append(MuonWeightMap &map, const CP::SystematicSet *nominal)

bool setBaseTriggerSF(SUSYMuonTriggerSFHandler_Map &map, const CP::SystematicSet *nominal)

bool setSignalTriggerSF(SUSYMuonTriggerSFHandler_Map &map, const CP::SystematicSet *nominal)

Protected Functions

StatusCode calculateSF(const xAOD::Muon &muon, float &SF)

Private Members

const CP::SystematicSet *m_Syst

std::vector<MuonWeight_Ptr> m_Weights

bool m_init

SUSYMuonTriggerSFHandler_Vector m_baseline_trig_SF

SUSYMuonTriggerSFHandler_Vector m_signal_trig_SF

bool m_multiple_trig_sf

class NonZeroWeightSystCheck

#include <NTupleWriter.h>

Public Functions

NonZeroWeightSystCheck(IWeightElement *element)

bool nominal_nonZero() const

bool systematics_nonZero() const

bool has_nonZeroComponents() const

std::string name() const

Private Members

IWeightElement *m_element

ITreeVarReader *m_nominal

std::vector<ITreeVarReader *> m_Systematics

class NormalizationDataBase

#include <MetaDataTreeReader.h>

Public Functions

const double &getNormalization(unsigned int DSID, unsigned int ProcID = 0)

const double &getNormTimesXsec(unsigned int DSID, unsigned int ProcID = 0)

bool init(const std::vector<std::string> &In)

bool isData() const

void SetLumi(double Lumi)

void PromptMetaDataTree()

void LoadCrossSections(const std::string &xSecDir_Bkg, const std::string &xSecDir_Sig)

std::vector<unsigned int> GetRunNumbers()

const std::vector<unsigned int> &GetProcessedLumiBlocks(unsigned int runNumber)

const std::vector<unsigned int> &GetTotalLumiBlocks(unsigned int runNumber)

Long64_t GetTotalEvents(unsigned int runNumber)

Long64_t GetProcessedEvents(unsigned int runNumber)

std::vector<unsigned int> GetListOfMCSamples()

unsigned int GetNumMCsamples()

unsigned int GetNumberOfProcesses(unsigned int DSID)

std::vector<unsigned int> GetListOfProcesses(unsigned int DSID)

MonteCarloPeriodHandler_Ptr getMCperiodHandler(unsigned int DSID)

Long64_t GetTotalEvents(unsigned int DSID, unsigned int ProcID)

Long64_t GetProcessedEvents(unsigned int DSID, unsigned int ProcID)

double GetSumW(unsigned int DSID, unsigned int ProcID = 0)

double GetSumW2(unsigned int DSID, unsigned int ProcID = 0)

double GetxSection(unsigned int DSID, unsigned int ProcID = 0)

double GetFilterEfficiency(unsigned int DSID, unsigned int ProcID = 0)

double GetkFactor(unsigned int DSID, unsigned int ProcID = 0)

double GetxSectTimes(unsigned int DSID, unsigned int ProcID = 0)

Returns cross-section times filter efficiency times kFactor.

double GetRelUncertainty(unsigned int DSID, unsigned int ProcID = 0)

void SetxSection(double xSec, double kFac, double filtEff, double relUnc, unsigned int DSID, unsigned int ProcID = 0)

~NormalizationDataBase()

Public Static Functions

NormalizationDataBase *getDataBase()

void resetDataBase()

Protected Types

enum DSIDStatus

Values:

Present

Updated

Failed

Protected Functions

NormalizationDataBase()

NormalizationDataBase(const NormalizationDataBase&)

void operator=(const NormalizationDataBase&)

bool ReadTree(TTree *t)

void initialized()

bool isInitialized() const

Protected Static Attributes

NormalizationDataBase *m_Inst = nullptr

Private Types

typedef std::map<unsigned int, MetaDataStore_Ptr> MetaID

Private Functions

void PromptMCMetaDataTree()

void PromptRunMetaDataTree()

bool ReadMCTree(TTree *t)

bool ReadDataTree(TTree *t)

void LockStores()

NormalizationDataBase::DSIDStatus GetDSIDStatus(unsigned int DSID)

NormalizationDataBase::DSIDStatus GetDSIDStatus(unsigned int DSID, unsigned int ProcID)

NormalizationDataBase::DSIDStatus GetRunStatus(unsigned int runNumber)

Private Members

std::vector<MonteCarloPeriodHandler_Ptr> m_mcDB

MonteCarloPeriodHandler_Ptr m_ActMC

MetaID m_dataDB

MetaDataStore_Ptr m_ActMeta

double m_Lumi

double m_weight

double m_Norm

bool m_xSecLoaded

bool m_init

class NormalizationVariation

#include <Weight.h>

Public Functions

NormalizationVariation(const std::string &norm)

~NormalizationVariation()

double Read()

ITreeVarReader *GetReader() const

int LHEvariation() const

int processID() const

Private Members

int m_LHE

PseudoScalarVarReader *m_PseudoReader

ITreeVarReader *m_eventWeight

int m_DSID

int m_FinalState

NormalizationDataBase *m_MetaData

Weight *m_weighter

std::vector<int> m_known_FS

double m_NormCache

PseudoScalarVarReader *m_xSection

PseudoScalarVarReader *m_xSectUncert

class NormalizationWeight : public XAMPP::IWeightElement

#include <Weight.h>

Public Functions

bool init(TTree *tree)

double read()

std::vector<std::string> FindWeightVariations(TTree *Tree)

IWeightElement::SystStatus ApplySystematic(const std::string &variation)

void ResetSystematic()

std::string name() const

ITreeVarReader *GetTreeVarReader()

ITreeVarReader *GetSystematicReader(const std::string &Syst)

std::vector<std::string> GetWeightVariations()

int processID() const

Public Static Functions

NormalizationWeight *getElement()

Protected Functions

NormalizationWeight()

NormalizationWeight(const NormalizationWeight&)

void operator=(const NormalizationWeight&)

std::shared_ptr<NormalizationVariation> newVariation(const std::string &variation)

Private Functions

std::shared_ptr<NormalizationVariation> getVariation(const std::string &var) const

std::shared_ptr<NormalizationVariation> getVariation(int L) const

void checkNorm()

Private Members

IWeightElement *m_eventWeight

Weight *m_weighter

std::vector<std::shared_ptr<NormalizationVariation>> m_LHE

std::shared_ptr<NormalizationVariation> m_Norm

class NotEqualCondition : public XAMPP::Condition

#include <Cuts.h>

Public Functions

bool PassScalar() const

bool PassVector(size_t entry) const

bool PassMatrix(size_t column, size_t row) const

std::string name() const

class NtupleFileInfo

#include <MergeHelpers.h>

Public Functions

NtupleFileInfo(const std::string &in_path)

bool is_good() const

unsigned int num_trees() const

unsigned int num_lhe() const

std::string path() const

Long64_t file_size() const

bool share_same_trees(const NtupleFileInfo &other) const

bool can_be_merged(const NtupleFileInfo &other) const

Private Members

std::string m_path

std::vector<std::string> m_trees

std::vector<unsigned int> m_lhe

Long64_t m_size

class NTupleWriter : public XAMPP::Analysis

#include <NTupleWriter.h>

Subclassed by XAMPP::SubSetNTupleWriter

Public Functions

NTupleWriter()

virtual ~NTupleWriter()

bool Process(long int nMax = -1, long int nSkip = 0)

Process the loop on the events.

Return

{ description_of_the_return_value }

Parameters

• nMax: The maximum
• nSkip: The skip

void SetBranches(const std::vector<XAMPP::ITreeVarWriter *> &B)

void SetWeightNames(const std::map<std::string, std::string> &WeightNames)

void SetSystReplaceStrings(const std::map<std::string, std::string> &SystReplaceStr)

Protected Functions

bool initBranches(const std::string &Syst)

{ function_description }

Return

{ description_of_the_return_value }

Parameters

• Syst: The syst

bool AnalyzeEvent()

{ function_description }

Return

{ description_of_the_return_value }

bool HandleWeightVariations()

{ function_description }

Return

{ description_of_the_return_value }

Parameters

• nMax: The maximum
• nSkip: The skip

void WriteOutput()

Writes an output.

std::string WeightBranchName(IWeightElement *element, const std::string variation = "") const

bool FillTree()

Protected Attributes

std::shared_ptr<TTree> m_OutTree

std::vector<XAMPP::ITreeVarWriter *> m_Branches

std::vector<XAMPP::ITreeVarWriter *> m_wBranches

std::vector<std::shared_ptr<NonZeroWeightSystCheck>> m_WeightVar

std::map<std::string, std::string> m_WeightNames

std::map<std::string, std::string> m_ReplaceStringOfSyst

bool m_isNominal

Long64_t m_writtenEv

struct ObjectDefinition

#include <SUSYTruthSelector.h>

Public Functions

ObjectDefinition()

Public Members

float BaselinePt

float BaselineEta

float SignalPt

float SignalEta

StringVector ExclBaseEta_Property

StringVector ExclSignalEta_Property

EtaRangeVector BaseEtaExclude

EtaRangeVector SignalEtaExclude

bool hasBaseEtaToExclude

bool hasSignalEtaToExclude

std::string ContainerKey

bool hasContainer

bool doObject

struct OfflineMatching

Public Members

float PtThreshold = 0.

int Object = xAOD::Type::ObjectType::Other

bool ObjectMatched = false

class OverlapRemovalParticleReader : public XAMPP::IParticleCollection

#include <ReconstructedParticleReaders.h>

Public Functions

std::string name() const

bool init(TTree *t)

IParticleVarReader *RetrieveVariable(const std::string &Var)

size_t Size()

size_t ReaderIndex() const

size_t ReaderIndex(size_t P)

unsigned int GetCollectionHash() const

const TLorentzVector &P4() const

TLorentzVector GetP4(size_t E)

size_t removeOR(size_t I)

IParticleReader *underyling_particle() const

Public Static Functions

IParticleReader *GetReader(const std::string &resulting_part, const std::string &rem_from, const std::string &rem_with, float dR)

IParticleReader *GetReader(const std::string &resulting_part, const std::string &rem_from, const std::string &rem_with, const std::string &from_label, const std::string &cont_idx)

Private Functions

OverlapRemovalParticleReader(const std::string &r_name, const std::string &rem_from, const std::string &rem_with)

OverlapRemovalParticleReader(const std::string &r_name, const std::string &rem_from, const std::string &rem_with, float dR)

OverlapRemovalParticleReader(const std::string &r_name, const std::string &rem_from, const std::string &rem_with, const std::string &from_label, const std::string &cont_idx)

OverlapRemovalParticleReader(const OverlapRemovalParticleReader&)

void operator=(const OverlapRemovalParticleReader&)

Private Members

std::string m_name

IParticleReader *m_from

IParticleReader *m_with

float m_dR

dR based overlap removal

float m_dR2

IParticleVarReader *m_from_phi

IParticleVarReader *m_from_eta

IParticleVarReader *m_with_phi

IParticleVarReader *m_with_eta

IParticleVarReader *m_overlap_idx_from

overlap removal has already been performed at the n-tuple production stage

IParticleVarReader *m_idx_with

Weight *m_weighter

weighter to cache the variable

Long64_t m_last_cached_ev

std::vector<size_t> m_surviving

bool m_registered

class OverlapRemovalParticleVarReader : public XAMPP::IParticleVariable

#include <ReconstructedParticleReaders.h>

Public Functions

std::string name() const

double readEntry(size_t I) const

bool init(TTree *t)

Public Static Functions

IParticleVarReader *GetReader(OverlapRemovalParticleReader *particle, const std::string &var)

Private Functions

OverlapRemovalParticleVarReader(OverlapRemovalParticleReader *particle, const std::string &var_name)

OverlapRemovalParticleVarReader(const OverlapRemovalParticleVarReader&)

void operator=(const OverlapRemovalParticleVarReader&)

Private Members

OverlapRemovalParticleReader *m_or_part

std::string m_var_name

IParticleVarReader *m_variable

bool m_Registered

class ParReaderStorage

#include <TreeVarReader.h>

Public Functions

IParticleReader *GetReader(const std::string &Name) const

bool Register(IParticleReader *R)

~ParReaderStorage()

Public Static Functions

ParReaderStorage *GetInstance()

Protected Functions

ParReaderStorage()

ParReaderStorage(const ParReaderStorage&)

void operator=(const ParReaderStorage&)

Protected Static Attributes

ParReaderStorage *m_Inst = nullptr

Private Members

std::map<size_t, std::shared_ptr<IParticleReader>> m_DB

class ParticleBlockReader : public XAMPP::IMatrixReader

#include <UtilityReader.h>

Public Functions

bool init(TTree *t)

std::string name() const

size_t num_rows() const

size_t row_entries(const size_t I) const

double readMatrixEntry(const size_t I, const size_t J) const

Public Static Functions

ITreeMatrixReader *GetReader(IParticleVectorReader *Var, Cube C)

Protected Functions

ParticleBlockReader(IParticleVectorReader *Variable, Cube C)

ParticleBlockReader(const ParticleBlockReader&)

void operator=(const ParticleRangeReader&)

Private Functions

size_t min(size_t I, size_t J) const

Private Members

IParticleVectorReader *m_Variable

Cube m_Cube

Ranges m_Current

bool m_Registered

class ParticleCorrelationReader : public XAMPP::IMatrixReader

#include <ObservableReader.h>

Subclassed by XAMPP::DeltaEtaReader, XAMPP::DeltaPhiReader, XAMPP::DeltaRReader, XAMPP::InvariantDiMassReader, XAMPP::InvariantDiPtReader, XAMPP::MomentumImbalanceReader, XAMPP::TransverseMassReader

Public Functions

double readMatrixEntry(const size_t i, const size_t j) const

size_t row_entries(size_t i) const

size_t num_rows() const

bool init(TTree *t)

virtual ~ParticleCorrelationReader()

IParticleReader *First() const

IParticleReader *Second() const

double DeltaPhi(size_t I, size_t J) const

double DeltaEta(size_t I, size_t J) const

double DeltaY(size_t I, size_t J) const

Protected Functions

ParticleCorrelationReader(const std::string &First, const std::string &Second, std::function<double(size_t, size_t)> corr_fkt)

ParticleCorrelationReader(const ParticleCorrelationReader&)

void operator=(const ParticleCorrelationReader&)

void Register()

Protected Attributes

IParticleVarReader *m_FirstPt

IParticleVarReader *m_SecondPt

IParticleVarReader *m_FirstEta

IParticleVarReader *m_SecondEta

IParticleVarReader *m_FirstPhi

IParticleVarReader *m_SecondPhi

Private Functions

bool PointsToSameObject(size_t first, size_t second) const

Private Members

IParticleReader *m_FirstParticle

IParticleReader *m_SecondParticle

std::function<double(size_t, size_t)> m_CorrelFct

template <class T>
class ParticleCutElement : public XAMPP::ICutElement

#include <Cuts.h>

Public Functions

bool ApplyCut(bool ForCutFlow = false) const

bool initialize(T Value, Cut::Relation R, bool IsSkimmingCut)

ParticleCutElement(XAMPP::IEventInfo *XAMPPInfo, const std::string &Particle, unsigned int N_th, const std::string &Variable)

std::string name() const

Protected Types

template<>
typedef bool (ParticleCutElement::*Application)() const

Protected Functions

const xAOD::IParticle *Particle() const

bool PassGreaterThan() const

bool PassGreaterEqual() const

bool PassEqual() const

bool PassLessThan() const

bool PassLessEqual() const

Protected Attributes

ParticleStorage *m_ParticleStore

SG::AuxElement::Accessor<T> m_Acc

std::string m_VarName

unsigned int m_Idx

T m_CutValue

bool m_CutSkims

Application m_Relation

class ParticleDecorations

#include <ParticleDecorations.h>

Subclassed by XAMPP::ElectronDecorations, XAMPP::JetDecorations, XAMPP::MuonDecorations, XAMPP::PhotonDecorations, XAMPP::TauDecorations, XAMPP::TruthDecorations

Public Functions

ParticleDecorations()

void populateDefaults(SG::AuxElement &ipart)

Public Members

Decoration<char> passPreselection

Decoration<char> passBaseline

Decoration<char> passSignal

Decoration<char> passIsolation

Decoration<char> enterOverlapRemoval

class ParticleFourVectorCutElement : public XAMPP::ICutElement

#include <Cuts.h>

Public Functions

bool ApplyCut(bool ForCutFlow = false) const

bool initialize(float Value, Cut::Relation R, bool IsSkimmingCut)

std::string name() const

ParticleFourVectorCutElement(XAMPP::IEventInfo *XAMPPInfo, const std::string &Particle, unsigned int Nth, Momentum Mom)

Protected Types

typedef bool (ParticleFourVectorCutElement::*Application)() const

Protected Functions

const xAOD::IParticle *Particle() const

bool PassGreaterThan() const

bool PassGreaterEqual() const

bool PassEqual() const

bool PassLessThan() const

bool PassLessEqual() const

Protected Attributes

ParticleStorage *m_ParticleStorage

Momentum m_Momentum

Application m_Relation

unsigned int m_Idx

float m_CutValue

bool m_CutSkims

class ParticleNthEntryReader : public XAMPP::IScalarReader

#include <UtilityReader.h>

Public Functions

double read() const

size_t entries() const

bool update()

bool init(TTree *t)

std::string name() const

virtual ~ParticleNthEntryReader()

Public Static Functions

ITreeVarReader *GetReader(IParticleVarReader *Reader, size_t N)

Protected Functions

ParticleNthEntryReader(IParticleVarReader *Reader, size_t N)

ParticleNthEntryReader(const ParticleNthEntryReader&)

void operator=(const ParticleNthEntryReader&)

Private Members

IParticleVarReader *m_Var

size_t m_Entry

bool m_Registered

class ParticleNthRowReader : public XAMPP::IVectorReader

#include <UtilityReader.h>

Public Functions

double readEntry(const size_t I) const

size_t entries() const

std::string name() const

bool init(TTree *t)

Public Static Functions

ITreeVectorReader *GetReader(IParticleVectorReader *Variable, size_t P)

Protected Functions

ParticleNthRowReader(IParticleVectorReader *Variable, size_t P)

ParticleNthRowReader(const ParticleNthRowReader&)

void operator=(const ParticleNthRowReader&)

Protected Attributes

IParticleVectorReader *m_Var

size_t m_PartIdx

class ParticleRangeReader : public XAMPP::IVectorReader

#include <UtilityReader.h>

Public Functions

double readEntry(const size_t I) const

size_t entries() const

bool init(TTree *t)

std::string name() const

Public Static Functions

ITreeVectorReader *GetReader(IParticleVarReader *Var, size_t begin, size_t end)

Protected Functions

ParticleRangeReader(IParticleVarReader *Variable, size_t begin, size_t end)

ParticleRangeReader(const ParticleRangeReader&)

void operator=(const ParticleRangeReader&)

Private Members

IParticleVarReader *m_Variable

size_t m_begin

size_t m_end

bool m_Registered

class ParticleReader : public XAMPP::IParticleCollection

#include <TreeVarReader.h>

Subclassed by XAMPP::ParticleReaderM

Public Functions

template <typename T>
std::shared_ptr<Condition> AddSimpleCut(const std::string &name, const std::string &condition, float CutValue, bool InGeV = false)

template <typename T>
bool AttachVariable(const std::string &var_name, bool UseGeV = false)

template <typename T>
bool AttachVector(const std::string &var_name, bool UseGeV = false)

std::shared_ptr<Condition> CombineCuts(std::shared_ptr<Condition> cut1, std::shared_ptr<Condition> cut2, Condition::Mode mode)

bool AddVariable(std::string V)

bool AddArithmetricVariable(const std::string &alias, const std::string &first, const std::string &second, const std::string &math_operator)

void SetupDone()

std::string name() const

size_t Size()

size_t ReaderIndex() const

size_t ReaderIndex(size_t I)

unsigned int GetCollectionHash() const

std::string GetCollectionName() const

size_t GetTargetEntry(size_t Idx) const

ITreeVectorReader *RetrieveBranchAccess(const std::string &Var) const

IParticleVarReader *RetrieveVariable(const std::string &Var)

bool init(TTree *t)

const TLorentzVector &P4() const

TLorentzVector GetP4(size_t E)

bool Setup(std::ifstream &InStream)

~ParticleReader()

Public Static Functions

ParticleReader *GetReader(const std::string &Name, const std::string &Coll = "")

Protected Functions

ParticleReader(const std::string &Name, const std::string &Coll)

ParticleReader(const ParticleReader&)

void operator=(const ParticleReader&)

std::string time_component() const

void DisableMeVtoGeV()

ITreeVectorReader *AddVariable(std::stringstream &sstr)

template <typename T>
ITreeVectorReader *NewVariable(const std::string &Name)

template <typename T>
ITreeVectorReader *NewVariableGeV(const std::string &Name)

template <typename T>
ITreeMatrixReader *NewMatrixVariable(const std::string &Name)

template <typename T>
ITreeMatrixReader *NewMatrixVariableGeV(const std::string &Name)

ITreeVectorReader *NewArithmetricVariable(const std::string &alias, const std::string &first, const std::string &second, const std::string &math_operator)

ITreeVectorReader *GetVariable(const std::string &Name) const

ITreeMatrixReader *GetMatrixVariable(const std::string &Name) const

bool InsertVariable(const std::string &Name, ITreeVectorReader *Variable)

bool IsVariableDefined(const std::string &Name) const

void SetParticleCollection(const std::string &Coll)

Protected Attributes

ITreeVectorReader *m_TimeComReader

ITreeVectorReader *m_PtReader

ITreeVectorReader *m_EtaReader

ITreeVectorReader *m_PhiReader

TLorentzVector m_P4

Private Functions

void AddP4Readers()

bool AddCombinedCut(std::ifstream &InStream, Condition::Mode Mode)

bool AddCut(std::stringstream &sstr)

bool PassCuts(size_t I) const

Private Members

std::string m_Name

std::string m_ParCollection

unsigned int m_ParCollectionHash

bool m_Setup

bool m_Registered

bool m_UseGeVReader

std::map<std::string, ITreeVectorReader *> m_Vars

std::vector<ITreeVectorReader *> m_VarsVec

std::vector<std::shared_ptr<Condition>> m_Cuts

Long64_t m_CurrentEv

std::vector<size_t> m_Skipped

std::unordered_map<size_t, size_t> m_TargetMap

std::unordered_map<size_t, size_t>::const_iterator m_TargetEnd

size_t m_Size

size_t m_FistLookUp

EventService *m_service

class ParticleReaderM : public XAMPP::ParticleReader

#include <TreeVarReader.h>

Subclassed by XAMPP::ParticleReaderMTAR

Public Functions

TLorentzVector GetP4(size_t E)

const TLorentzVector &P4() const

virtual ~ParticleReaderM()

Public Static Functions

ParticleReaderM *GetReader(const std::string &Name, const std::string &Coll = "")

Protected Functions

ParticleReaderM(const std::string &Name, const std::string &Coll)

ParticleReaderM(const ParticleReaderM&)

void operator=(const ParticleReaderM&)

std::string time_component() const

class ParticleReaderMTAR : public XAMPP::ParticleReaderM

#include <TreeVarReader.h>

Public Functions

virtual ~ParticleReaderMTAR()

Public Static Functions

ParticleReaderMTAR *GetReader(const std::string &Name, const std::string &Coll = "")

Protected Functions

ParticleReaderMTAR(const std::string &Name, const std::string &Coll)

ParticleReaderMTAR(const ParticleReaderMTAR&)

void operator=(const ParticleReaderMTAR&)

std::string time_component() const

class ParticleRowSizeReader : public XAMPP::IVectorReader

#include <UtilityReader.h>

Public Functions

std::string name() const

bool init(TTree *t)

double readEntry(const size_t I) const

size_t entries() const

Public Static Functions

ITreeVectorReader *GetReader(IParticleVectorReader *Reader)

Protected Functions

ParticleRowSizeReader(IParticleVectorReader *Variable)

ParticleRowSizeReader(const ParticleRowSizeReader&)

void operator=(const ParticleRowSizeReader&)

Protected Attributes

IParticleVectorReader *m_Var

bool m_Registered

class ParticleSelector : public AsgTool

#include <ParticleSelector.h>

Subclassed by XAMPP::ReconstructedParticles, XAMPP::SUSYParticleSelector, XAMPP::SUSYTruthSelector

Public Types

enum LinkStatus

Values:

Created

Loaded

Failed

enum ScaleFactorMapContains

Values:

SignalSf

BaselineSf

SignalAndBaseSf

typedef std::pair<float, float> EtaRange

typedef std::vector<EtaRange> EtaRangeVector

Public Functions

ParticleSelector(const std::string &myname)

~ParticleSelector()

StatusCode initialize()

template <typename Container>
ParticleSelector::LinkStatus CreateContainerLinks(const std::string &Key, Container *&Cont, bool linkOriginal)

template <typename Container>
ParticleSelector::LinkStatus CreateContainerLinks(const std::string &Key, Container *&Cont, xAOD::ShallowAuxContainer *&AuxContainer, bool linkOriginal)

Protected Functions

void SetSystematics(const CP::SystematicSet &Set)

void SetSystematics(const CP::SystematicSet *Set)

void SetContainerKey(const std::string &Key)

void SetObjectType(SelectionObject Type)

const std::string &ContainerKey() const

XAMPP::SelectionObject ObjectType() const

bool isInitialized() const

bool ProcessObject(XAMPP::SelectionObject T) const

bool ProcessObject() const

bool isData() const

bool PassBaselineKinematics(const xAOD::IParticle &P) const

bool PassSignalKinematics(const xAOD::IParticle &P) const

bool PassBaselineKinematics(const xAOD::IParticle *P) const

bool PassSignalKinematics(const xAOD::IParticle *P) const

bool PassSignal(const xAOD::IParticle &P) const

bool PassBaseline(const xAOD::IParticle &P) const

bool PassPreSelection(const xAOD::IParticle &P) const

bool PassIsolation(const xAOD::IParticle &P) const

bool PassSignalNoOR(const xAOD::IParticle &P) const

bool PassSignal(const xAOD::IParticle *P) const

bool PassBaseline(const xAOD::IParticle *P) const

bool PassPreSelection(const xAOD::IParticle *P) const

bool PassIsolation(const xAOD::IParticle *P) const

bool PassSignalNoOR(const xAOD::IParticle *P) const

void SetSelectionDecorators(const xAOD::IParticle &P, bool Pass) const

void SetPreSelectionDecorator(const xAOD::IParticle &P, bool Pass) const

void SetOverlapInDecorator(const xAOD::IParticle &P, int Pass) const

void SetIsolationDecorator(const xAOD::IParticle &P, int Pass) const

void SetBaselineDecorator(const xAOD::IParticle &P, bool Pass) const

void SetSignalDecorator(const xAOD::IParticle &P, bool Pass) const

bool GetPreSelectionDecorator(const xAOD::IParticle &P_PGID) const

int GetOverlapInDecorator(const xAOD::IParticle &P) const

bool GetBaselineDecorator(const xAOD::IParticle &P_PGID) const

bool GetSignalDecorator(const xAOD::IParticle &P_PGID) const

void SetSelectionDecorators(const xAOD::IParticle *P, bool Pass) const

void SetPreSelectionDecorator(const xAOD::IParticle *P, bool Pass) const

void SetOverlapInDecorator(const xAOD::IParticle *P, int Pass) const

void SetIsolationDecorator(const xAOD::IParticle *P, int Pass) const

void SetBaselineDecorator(const xAOD::IParticle *P, bool Pass) const

void SetSignalDecorator(const xAOD::IParticle *P, bool Pass) const

bool GetPreSelectionDecorator(const xAOD::IParticle *P_PGID) const

int GetOverlapInDecorator(const xAOD::IParticle *P) const

bool GetBaselineDecorator(const xAOD::IParticle *P_PGID) const

bool GetSignalDecorator(const xAOD::IParticle *P_PGID) const

StatusCode CreateAuxElements(std::string &name, SelectionAccessor &acc, SelectionDecorator &dec)

StatusCode ExtractEtaRanges(StringVector &propertyVector, EtaRangeVector &rangeVector)

bool IsInEtaRange(const xAOD::IParticle &P, const EtaRangeVector &ranges) const

StatusCode ReclusterJets(const xAOD::IParticleContainer *inputJets, float Rcone, float minPtKt4 = -1, std::string PreFix = "", float minPtRecl = -1, float rclus = 0, float ptfrac = -1)

template <typename Container>
StatusCode ViewElementsContainer(const std::string &Key, Container *&Cont)

template <typename Container>
StatusCode LoadViewElementsContainer(const std::string &Key, Container *&Cont, bool LoadNominal = false) const

template <typename Container>
StatusCode LoadContainer(const std::string &Key, const Container *&Cont) const

template <typename Container>
StatusCode LoadContainer(const std::string &Key, Container *&Cont) const

template <typename T>
StatusCode DeclareAsWeightSyst(ToolHandle<T> &handle, XAMPP::SelectionObject O = XAMPP::SelectionObject::Other)

template <typename T>
StatusCode DeclareAsKineSyst(ToolHandle<T> &handle, XAMPP::SelectionObject O = XAMPP::SelectionObject::Other)

template <typename T>
StatusCode DeclareAsWeightSyst(asg::AnaToolHandle<T> &handle, XAMPP::SelectionObject O = XAMPP::SelectionObject::Other)

template <typename T>
StatusCode DeclareAsKineSyst(asg::AnaToolHandle<T> &handle, XAMPP::SelectionObject O = XAMPP::SelectionObject::Other)

const std::string &StoreName() const

std::string SystName(bool InclUnderScore = true) const

bool SystematicAffects(const CP::SystematicSet &Set) const

bool SystematicAffects(const CP::SystematicSet *Set) const

template <typename Container>
ParticleSelector::LinkStatus CreateContainerLinks(const std::string &Key, Container *&Cont, bool linkOriginal = true)

template <typename Container>
ParticleSelector::LinkStatus CreateContainerLinks(const std::string &Key, Container *&Cont, xAOD::ShallowAuxContainer *&AuxContainer, bool linkOriginal = true)

StatusCode SaveObjectSF(ParticleStorage *Storage)

StatusCode initIParticleWeight(IParticleWeightDecorator &weighter, const std::string &sf_type, const CP::SystematicSet *syst_set, unsigned int content, bool save = true, const std::string &base_name = "")

StatusCode initEventSignalSf(XAMPP::Storage<double> *&store_ptr, const std::string &suffix, const CP::SystematicSet *set, bool save, const std::string &basename = "")

StatusCode initEventBaselineSf(XAMPP::Storage<double> *&store_ptr, const std::string &suffix, const CP::SystematicSet *set, bool save, const std::string &basename = "")

void setupDecorations(std::shared_ptr<ParticleDecorations> input = nullptr)

Protected Attributes

ToolHandle<XAMPP::ISystematics> m_systematics

XAMPP::EventInfo *m_XAMPPInfo

Private Functions

bool checkForValidSystematics() const

std::shared_ptr<DoubleDecorator> getParticleSfDecorator(XAMPP::Storage<double> *SF_decorator)

std::shared_ptr<DoubleAccessor> getParticleSfAccessor(XAMPP::Storage<double> *SF_decorator)

Private Members

float m_baselinePt

float m_baselineEta

float m_signalPt

float m_signalEta

StringVector m_baseEtaExcludeProperty

EtaRangeVector m_baseEtaExclude

StringVector m_signalEtaExcludeProperty

EtaRangeVector m_signalEtaExclude

bool m_hasBaseToExclude

bool m_hasSignalToExclude

const CP::SystematicSet *m_ActSys

std::string m_ContainerKey

std::string m_storeName

SelectionObject m_ObjectType

bool m_init

std::string m_PreSelDecorName

SelectionAccessor m_acc_presel

SelectionDecorator m_dec_presel

std::string m_BaselineDecorName

SelectionAccessor m_acc_baseline

SelectionDecorator m_dec_baseline

std::string m_SignalDecorName

SelectionAccessor m_acc_signal

SelectionDecorator m_dec_signal

std::string m_IsolDecorName

SelectionAccessor m_acc_isol

SelectionDecorator m_dec_isol

std::string m_ORutilsDecorName

SelectionAccessor m_acc_ORUtils_in

SelectionDecorator m_dec_ORUtils_in

int m_ORUtils_InFlag

bool m_syst_checked

std::vector<XAMPP::Storage<double> *> m_eventSFstores

bool m_WriteSFperParticle

asg::AnaToolHandle<XAMPP::IEventInfo> m_EvInfoHandle

std::shared_ptr<ParticleDecorations> m_particleDecorations

class ParticleSizeReader : public XAMPP::IScalarReader

#include <UtilityReader.h>

Public Functions

bool init(TTree *t)

double read() const

std::string name() const

virtual ~ParticleSizeReader()

Public Static Functions

ParticleSizeReader *GetReader(std::string Name)

Protected Functions

ParticleSizeReader(std::string Name)

ParticleSizeReader(const ParticleSizeReader&)

void operator=(const ParticleSizeReader&)

Protected Attributes

IParticleReader *m_Particle

bool m_Registered

class ParticleStorage : public XAMPP::DataVectorStorage

#include <EventStorage.h>

Public Functions

ParticleStorage(const std::string &Name, XAMPP::IEventInfo *info, bool isCommon = false)

std::vector<std::shared_ptr<ITreeBranchVariable>> CreateParticleTree(TreeBase *base_tree)

xAOD::IParticleContainer *Container(const CP::SystematicSet *set)

xAOD::IParticleContainer *Container()

void SaveMassInP4(bool B)

virtual ~ParticleStorage()

Private Members

bool m_UseMass

class ParticleTaggerCut : public XAMPP::Condition

#include <ParticleTagger.h>

Subclassed by XAMPP::ContainerTaggerCut

Public Functions

bool Pass() const

bool PassScalar() const

bool PassVector(size_t entry) const

bool PassMatrix(size_t column, size_t row) const

std::string name() const

ParticleTaggerCut(IParticleReader *reader, const std::string tagger_name)

Protected Functions

bool loadTaggers() const

Protected Attributes

ParticleTaggerManager *m_manager

IParticleReader *m_particle

std::string m_tagger_name

unsigned int m_tagger_hash

bool m_taggers_loaded

const TaggerVector *m_taggers

class ParticleTaggerManager

#include <ParticleTagger.h>

Public Functions

~ParticleTaggerManager()

void Register(IParticleTagger *P)

void Register(std::shared_ptr<IParticleTagger> P)

bool AddCommonTagger(std::ifstream &ifstream, std::vector<ITreeVarReader *> &Readers)

void TagParticles()

const TaggerVector *findTaggers(unsigned int particle_hash, unsigned int tagger_ID) const

void SetSampleName(const std::string &name)

std::string sampleName() const

size_t sampleHash() const

void clearStore()

std::shared_ptr<IParticleTagger> smartPointer(IParticleTagger *tagger) const

std::shared_ptr<IParticleTagger> smartPointer(std::shared_ptr<IParticleTagger> tagger)

Public Static Functions

ParticleTaggerManager *Instance()

Private Types

typedef std::map<unsigned int, TaggerVector> TaggerID_Map

Private Functions

ParticleTaggerManager()

ParticleTaggerManager(const ParticleTaggerManager&)

void operator=(const ParticleTaggerManager&)

bool isTagged(const TaggerVector &Taggers, IParticleReader *P, int ID)

bool isTaggerInList(const TaggerVector &Taggers, std::shared_ptr<IParticleTagger> toTest) const

Private Members

IfDefLineParser ReadLine

Long64_t m_CurrentEvent

std::string m_SampleName

size_t m_SampleHash

TaggerVector m_TaggerStore

std::map<unsigned int, TaggerID_Map> m_Taggers

Private Static Attributes

ParticleTaggerManager *m_Inst = nullptr

class ParticleTimeReader : public XAMPP::ParticleVarReader

#include <TreeVarReader.h>

Public Types

enum MomentumComponent

Values:

Energy

Mass

Public Functions

double readEntry(size_t I) const

bool init(TTree *t)

virtual ~ParticleTimeReader()

Public Static Functions

ParticleTimeReader *GetReader(ParticleReader *P, MomentumComponent C)

Protected Functions

ParticleTimeReader(ParticleReader *P, MomentumComponent C)

ParticleTimeReader(const ParticleTimeReader&)

void operator=(const ParticleTimeReader&)

Private Members

MomentumComponent m_Component

bool m_Registered

class ParticleVarReader : public XAMPP::IParticleVariable

#include <TreeVarReader.h>

Subclassed by XAMPP::ParticleTimeReader

Public Functions

double readEntry(size_t I) const

std::string name() const

std::string variable_name() const

bool init(TTree *t)

Public Static Functions

ParticleVarReader *GetReader(ParticleReader *P, const std::string &VarName)

Protected Functions

ParticleVarReader(ParticleReader *Particle, const std::string &VarName)

ParticleVarReader(const ParticleVarReader&)

void operator=(const ParticleVarReader&)

ParticleVarReader(ParticleReader *Particle)

Protected Attributes

ParticleReader *m_Particle

ITreeVectorReader *m_Var

std::string m_Name

class ParticleVectorVarReader : public XAMPP::IParticleVector

#include <TreeVarReader.h>

Public Functions

double readMatrixEntry(size_t I, size_t J) const

size_t row_entries(size_t I) const

std::string name() const

std::string variable_name() const

bool init(TTree *t)

virtual ~ParticleVectorVarReader()

Public Static Functions

ParticleVectorVarReader *GetReader(ParticleReader *P, const std::string &VarName)

Protected Functions

ParticleVectorVarReader(ParticleReader *Particle, const std::string &VarName)

ParticleVectorVarReader(const ParticleVectorVarReader&)

void operator=(const ParticleVarReader&)

Protected Attributes

ParticleReader *m_Particle

ITreeMatrixReader *m_Var

std::string m_Name

class PeriodReader : public XAMPP::IScalarReader

#include <ObservableReader.h>

Public Functions

double read() const

std::string name() const

bool init(TTree *t)

virtual ~PeriodReader()

Public Static Functions

ITreeVarReader *GetReader()

Protected Functions

PeriodReader()

PeriodReader(const PeriodReader&)

void operator=(const PeriodReader&)

unsigned int GetRndRunNumber() const

Protected Attributes

ITreeVarReader *m_Reader

bool m_Registered

bool m_UsePRWTool

class PhotonDecorations : public XAMPP::ParticleDecorations

#include <PhotonDecorations.h>

Public Functions

PhotonDecorations()

void populateDefaults(SG::AuxElement &ipart)

class PhotonWeight : public XAMPP::PhotonWeightDecorator

#include <SUSYPhotonSelector.h>

Public Functions

PhotonWeight(PhotonEffToolHandle &SFTool)

~PhotonWeight()

Protected Functions

StatusCode calculateSF(const xAOD::Photon &Photon, double &SF)

Private Members

PhotonEffToolHandle m_SFTool

class PhotonWeightDecorator : public XAMPP::IParticleWeightDecorator

#include <SUSYPhotonSelector.h>

Subclassed by XAMPP::PhotonWeight, XAMPP::PhotonWeightHandler

Public Functions

PhotonWeightDecorator()

~PhotonWeightDecorator()

StatusCode saveSF(const xAOD::Photon &Photon, bool isSignal)

Protected Functions

virtual StatusCode calculateSF(const xAOD::Photon &Photon, double &SF) = 0

class PhotonWeightHandler : public XAMPP::PhotonWeightDecorator

#include <SUSYPhotonSelector.h>

Public Functions

PhotonWeightHandler(const CP::SystematicSet *syst_set)

const CP::SystematicSet *systematic() const

StatusCode saveSF(const xAOD::Photon &Photon, bool isSignal)

StatusCode applySF()

bool append(const PhotonWeightMap &map, const CP::SystematicSet *nominal)

Protected Functions

StatusCode calculateSF(const xAOD::Photon &Photon, double &SF)

Private Members

const CP::SystematicSet *m_Syst

std::vector<PhotonWeight_Ptr> m_Weights

bool m_init

struct PileUpDecorators

Public Members

XAMPP::Storage<double> *muWeight

XAMPP::Storage<float> *AverageCross

XAMPP::Storage<unsigned int> *RandomRunNumber

XAMPP::Storage<unsigned int> *RandomLumiBlock

class PileupHelper

#include <PileupUtils.h>

Public Functions

PileupHelper(const std::string &name)

void setLumiCalcFiles(const std::vector<std::string> &files)

void setConfigFiles(const std::vector<std::string> &files)

bool initialize()

const CP::IPileupReweightingTool *getTool() const

bool isDSIDvalid(unsigned int dsid)

double GetSumW(unsigned int dsid)

Long64_t GetNumberOfEvents(unsigned int dsid)

Long64_t nEventsPerPRWperiod_full(int dsid, unsigned int runNumber) const

Long64_t nEventsPerPRWperiod_faststim(int dsid, unsigned int runNumber) const

void loadPRWperiod_fastsim(const std::vector<std::string> &files)

void loadPRWperiod_fullsim(const std::vector<std::string> &files)

std::vector<unsigned int> getPRWperiods_fullsim() const

std::vector<unsigned int> getPRWperiods_fastsim() const

Public Static Functions

std::map<std::string, XAMPP::prwElement> load_prw_configFiles(const std::vector<std::string> &config_files, bool only_OneHistPerChannel = false)

Private Functions

Long64_t nEvents(const std::vector<XAMPP::prwElement> &pileupInfo, int dsid, unsigned int runNumber) const

std::vector<unsigned int> getPRWperiods(const std::vector<XAMPP::prwElement> &pileupInfo) const

void loadPrwConfig(const std::vector<std::string> &files, std::vector<XAMPP::prwElement> &pileupInfo)

Private Members

asg::AnaToolHandle<CP::IPileupReweightingTool> m_tool

std::vector<XAMPP::prwElement> m_mc_pileupInfo_full

std::vector<XAMPP::prwElement> m_mc_pileupInfo_fast

class PileUpReader : public XAMPP::IScalarReader

#include <ObservableReader.h>

Public Functions

double read() const

bool init(TTree *t)

std::string name() const

Protected Functions

PileUpReader()

PileUpReader(const PileUpReader&)

void operator=(const PileUpReader&)

Protected Attributes

ITreeVarReader *m_Reader

Weight *m_Weight

bool m_UsePRWTool

class PileUpWeightElement : public XAMPP::IWeightElement

#include <Weight.h>

Public Types

enum LumiPeriod

Values:

data15_16 = 1 << 0

data17 = 1 << 1

data18 = 1 << 2

All = data15_16 | data17 | data18

data15_17 = data15_16 | data17

data17_18 = data17 | data18

data15_18 = data15_16 | data18

Public Functions

bool init(TTree *tree)

double read()

std::vector<std::string> FindWeightVariations(TTree *Tree)

IWeightElement::SystStatus ApplySystematic(const std::string &variation)

void ResetSystematic()

std::string name() const

ITreeVarReader *GetTreeVarReader()

ITreeVarReader *GetSystematicReader(const std::string &Syst)

std::vector<std::string> GetWeightVariations()

virtual ~PileUpWeightElement()

void reWeightToPeriod(PileUpWeightElement::LumiPeriod P)

double getPeriodWeight() const

Public Static Functions

PileUpWeightElement *getElement()

Protected Functions

PileUpWeightElement()

PileUpWeightElement(const PileUpWeightElement&)

void operator=(const PileUpWeightElement&)

Protected Attributes

Weight *m_Weighter

XAMPP::NormalizationDataBase *m_MetaData

Private Functions

void loadSystematics(const std::vector<std::string> &systs)

Private Members

WeightElementFromTree *m_TreePRW

std::vector<FinalPRWWeight> m_variationReaders

std::vector<FinalPRWWeight>::const_iterator m_current_syst

LumiPeriod m_periodMode

std::shared_ptr<MonteCarloPeriodHandler> m_current_mc

std::vector<unsigned int> m_allowed_periods

class PlotAnalysis

#include <FinalPlotHelpers.h>

Public Functions

PlotAnalysis(const FileStructure *ref_structure, const std::string &ana_name)

PlotAnalysis(const PlotAnalysis&)

void operator=(const PlotAnalysis&)

std::string name() const

std::string nominal() const

std::vector<std::string> get_systematics() const

std::vector<PlotRegion_Ptr> get_regions() const

PlotRegion_Ptr get_region(const std::string &reg_name) const

std::vector<std::string> get_region_names() const

const FileStructure *get_reference() const

std::shared_ptr<TFile> get_file() const

void setNominal(const std::string &syst)

Private Functions

void update_regions()

Private Members

const FileStructure *m_reference

std::string m_name

std::string m_nominal

std::vector<std::string> m_systematics

std::vector<PlotRegion_Ptr> m_regions

class PlotRegion

#include <FinalPlotHelpers.h>

Public Functions

PlotRegion(TDirectory *File_Dir)

PlotRegion(const PlotRegion&)

void operator=(const PlotRegion&)

const std::vector<std::string> &variables() const

std::string name() const

Private Members

std::string m_region_name

std::vector<std::string> m_variables

struct prwElement

#include <PileupUtils.h>

Public Functions

prwElement(UInt_t dsid, UInt_t run, std::string name)

void AddStart(const std::vector<UInt_t> &run)

void AddEnd(const std::vector<UInt_t> &run)

Public Members

std::string histName

Int_t channel = 0

UInt_t runNumber = 0

std::vector<UInt_t> pStarts

std::vector<UInt_t> pEnds

std::shared_ptr<TH1> histo

class PseudoScalarVarReader : public XAMPP::IScalarReader

#include <UtilityReader.h>

Public Functions

std::string name() const

double read() const

bool init(TTree *t)

void SetValue(double V)

virtual ~PseudoScalarVarReader()

Public Static Functions

PseudoScalarVarReader *GetReader(const std::string &varname)

PseudoScalarVarReader *GetReader(const std::string &varname, double value)

Protected Functions

PseudoScalarVarReader(const std::string &varname)

PseudoScalarVarReader(const PseudoScalarVarReader&)

void operator=(const PseudoScalarVarReader&)

Protected Attributes

std::string m_Name

bool m_Registered

double m_Value

class ReaderProvider

#include <ReaderProvider.h>

Public Functions

ITreeVarReader *CreateReader(std::stringstream &sstr)

ITreeVarReader *CreateReader(std::ifstream &inf, std::stringstream &sstr)

IParticleReader *CreateParticle(const std::string &line)

ITreeVarReader *CreateReader(const std::string &line)

ITreeVarReader *CreateReader(std::ifstream &inf, const std::string &line)

IParticleReader *CreateParticle(std::ifstream &inf, const std::string &line)

ParticleReader *GetParticle(XAMPP::TimeComponent t, const std::string &Name, const std::string &Coll = "")

~ReaderProvider()

Public Static Functions

ReaderProvider *GetInstance()

Protected Functions

ReaderProvider()

ReaderProvider(const ReaderProvider&)

void operator=(const ReaderProvider&)

ITreeVarReader *CreateScalarReader(std::stringstream &sstr)

Protected Attributes

IfDefLineParser ReadLine

Protected Static Attributes

ReaderProvider *m_Inst = nullptr

Private Functions

ITreeVarReader *CreateParticleVarReader(std::stringstream &sstr)

ITreeVarReader *CreateParticleVecVarSizeReader(std::stringstream &sstr)

ITreeVarReader *CreatePseudoReader(std::stringstream &sstr)

ITreeVarReader *CreateNumParticleReader(std::stringstream &sstr)

ITreeVarReader *CreateMeffReader(std::stringstream &sstr)

ITreeVarReader *CreateHtReader(std::stringstream &sstr)

ITreeVarReader *CreateMultiNumParticleReader(std::stringstream &sstr)

ITreeVarReader *CreateInvariantDiMassReader(std::stringstream &sstr)

ITreeVarReader *CreateInvariantDiPtReader(std::stringstream &sstr)

ITreeVarReader *CreateMomentumImbalanceReader(std::stringstream &sstr)

ITreeVarReader *CreateClosestDeltaRReader(std::stringstream &sstr)

ITreeVarReader *CreateFixedDeltaRReader(std::stringstream &sstr)

ITreeVarReader *CreateClosestDeltaPhiReader(std::stringstream &sstr)

ITreeVarReader *CreateFixedDeltaPhiReader(std::stringstream &sstr)

ITreeVarReader *CreateFixedDeltaEtaReader(std::stringstream &sstr)

ITreeVarReader *CreateDeltaPhiToMetReader(std::stringstream &sstr)

ITreeVarReader *CreateMtMetReader(std::stringstream &sstr)

ITreeVarReader *CreateDiPartCompReader(std::stringstream &sstr)

ITreeVarReader *CreateTaggerReader(std::stringstream &sstr)

ITreeVarReader *CreateExtremumReader(std::ifstream &inf, const std::string &Name, bool Max)

ITreeVarReader *CreateClassificationReader(const std::string &Name, std::ifstream &inf)

ITreeVarReader *CreateSumUpReader(const std::string &Name, std::ifstream &inf)

ITreeVarReader *CreateSignificanceReader(const std::string &Name, std::ifstream &inf)

ITreeVarReader *CreateTaggerReader(std::ifstream &inf)

ITreeVarReader *CreateSetReader(const std::string &Name, std::ifstream &inf)

ITreeVarReader *ConstrainRanges(IParticleVarReader *Variable, Ranges Rng)

ITreeVarReader *CreateArithmetricReader(std::ifstream &inf, const std::string &math_op)

IParticleReader *CreateParticleORReader(std::ifstream &inf, const std::string &r_name)

class ReconstructedParticles : public XAMPP::ParticleSelector, public virtual XAMPP::IReconstructedParticles

#include <ReconstructedParticles.h>

Public Functions

ReconstructedParticles(std::string myname)

~ReconstructedParticles()

StatusCode initialize()

StatusCode PrepareContainer(const CP::SystematicSet *Set)

xAOD::Particle *CreateEmptyParticle()

xAOD::ParticleContainer *GetContainer()

void WellDefined(xAOD::IParticle *P, bool W = true)

StatusCode CreateSubContainer(const std::string &Name)

xAOD::ParticleContainer *GetSubContainer(const std::string &Name)

StatusCode LoadSubContainer(const std::string &Name)

void DetachSubContainer()

bool HasSubContainer(const std::string &name) const

Protected Attributes

SelectionDecorator m_DecWell

SelectionAccessor m_AccWell

xAOD::ParticleContainer *m_Container

xAOD::ParticleContainer *m_AutoFillContainer

xAOD::ParticleContainer *m_ViewCont

xAOD::ParticleAuxContainer *m_AuxContainer

class ReplicatedClassification : public XAMPP::ClassificationReader::Classification

#include <UtilityReader.h>

Replicated classification replicates the entries of the First one according to the size

Public Functions

ReplicatedClassification(ITreeVarReader *R, std::shared_ptr<Condition> C, ITreeVarReader *S)

double readEntry(size_t e) const

size_t entries()

Private Members

ITreeVarReader *m_sizeReader

class ResortedParticleReader : public XAMPP::IParticleCollection

#include <ReconstructedParticleReaders.h>

Subclassed by XAMPP::EventVarSortedParticleReader, XAMPP::ResortedParticleReaderASC, XAMPP::ResortedParticleReaderDESC

Public Types

enum Sorting

Values:

ASC

DESC

Public Functions

bool init(TTree *t)

std::string name() const

IParticleVarReader *RetrieveVariable(const std::string &Var)

IParticleVarReader *RetrieveBranchAccess(const std::string &Var) const

TLorentzVector GetP4(size_t E)

virtual ~ResortedParticleReader()

size_t Size()

size_t ReaderIndex() const

size_t ReaderIndex(size_t P)

size_t Permute(size_t Idx)

unsigned int GetCollectionHash() const

const TLorentzVector &P4() const

Protected Functions

ResortedParticleReader(const std::string &Name, const std::string &Sorter, const std::string &Appendix = "")

ResortedParticleReader(const ResortedParticleReader&)

void operator=(const ResortedParticleReader&)

virtual bool Sort(size_t Old, size_t New) const = 0

Protected Attributes

IParticleReader *m_Particle

IParticleVarReader *m_Sorter

Private Members

std::string m_Name

size_t m_Idx

std::vector<size_t> m_Sorted

unsigned int m_EventNumber

EventService *m_eventService

class ResortedParticleReaderASC : public XAMPP::ResortedParticleReader

#include <ReconstructedParticleReaders.h>

Public Static Functions

ResortedParticleReaderASC *GetReader(const std::string &Name, const std::string &Sorter, float Ref = 0)

Protected Functions

bool Sort(size_t Old, size_t New) const

ResortedParticleReaderASC(const std::string &Name, const std::string &Sorter, float Ref = 0)

ResortedParticleReaderASC(const ResortedParticleReaderASC&)

void operator=(const ResortedParticleReaderASC&)

Protected Attributes

float m_ReferenceValue

class ResortedParticleReaderDESC : public XAMPP::ResortedParticleReader

#include <ReconstructedParticleReaders.h>

Public Static Functions

ResortedParticleReaderDESC *GetReader(const std::string &Name, const std::string &Sorter, float Ref = 0)

Protected Functions

ResortedParticleReaderDESC(const std::string &Name, const std::string &Sorter, float Ref = 0)

ResortedParticleReaderDESC(const ResortedParticleReaderDESC&)

void operator=(const ResortedParticleReaderDESC&)

bool Sort(size_t Old, size_t New) const

Protected Attributes

float m_ReferenceValue

class ResortedParticleVarReader : public XAMPP::IParticleVariable

#include <ReconstructedParticleReaders.h>

Public Functions

std::string name() const

double readEntry(size_t I) const

bool init(TTree *t)

Public Static Functions

IParticleVarReader *GetReader(ResortedParticleReader *Reader, const std::string &Var)

Private Functions

ResortedParticleVarReader(ResortedParticleReader *Reader, const std::string &Var)

ResortedParticleVarReader(const ResortedParticleVarReader&)

void operator=(const ResortedParticleVarReader&)

Private Members

ResortedParticleReader *m_Reader

std::string m_VarName

IParticleVarReader *m_Var

class RevCumulativeHisto : public XAMPP::CumulativeHisto

#include <Histo.h>

Public Functions

RevCumulativeHisto(XAMPP::ITreeVarReader *Reader, const std::string &Name, const std::string &Template)

RevCumulativeHisto(const std::string &Name, const std::string &Template)

RevCumulativeHisto(const std::string &Name, unsigned int Nbins, double low, double high)

RevCumulativeHisto(const std::string &Name, unsigned int Nbins, const double *xbins)

RevCumulativeHisto(XAMPP::ITreeVarReader *Reader, const std::string &Name, unsigned int Nbins, double low, double high)

RevCumulativeHisto(XAMPP::ITreeVarReader *Reader, const std::string &Name, unsigned int Nbins, const double *xbins)

std::shared_ptr<Histo> Clone()

Protected Functions

void Finalize()

class RevCumulativeHisto2D : public XAMPP::CumulativeHisto2D

#include <Histo.h>

Public Functions

RevCumulativeHisto2D(std::string Name, std::string Template)

RevCumulativeHisto2D(XAMPP::ITreeVarReader *xReader, XAMPP::ITreeVarReader *yReader, std::string Name, std::string Template)

std::shared_ptr<Histo> Clone()

Protected Functions

void Finalize()

class runMetaData : public virtual XAMPP::MetaDataElement

#include <MetaDataTree.h>

Public Functions

runMetaData(unsigned int runNumber, ToolHandle<XAMPP::IEventInfo> info)

StatusCode newFile(const xAOD::CutBookkeeperContainer *Container)

StatusCode newFile(const xAOD::LumiBlockRange *LumiBlock)

StatusCode newEvent()

void CutBookKeeperAvailable(bool B)

StatusCode finalize(TTree *MetaDataTree)

StatusCode CopyStore(const MetaDataElement *Store)

StatusCode fillVariation(unsigned int, double)

~runMetaData()

Private Members

unsigned int m_runNumber

Long64_t m_NumTotalEvents

Long64_t m_NumProcessedEvents

std::set<unsigned int> m_ProcessedBlocks

std::set<unsigned int> m_TotalBlocks

bool m_KeeperAvailable

class SampleHisto

#include <SampleHisto.h>

Public Types

enum SampleType

Values:

UnDefined = 0

Data

Signal

Irreducible

Reducible

Exceeds

enum SystErrorSorting

Values:

Naming = 1

LargestUp

LargestDown

SmallestUp

SmallestDown

typedef std::pair<std::shared_ptr<TH1>, std::shared_ptr<TH1>> variation_pair

Public Functions

SampleHisto(const std::string &sample_name, const std::string &variable, const std::string &analysis, const std::string &region, const std::vector<std::string> &files)

SampleHisto(const std::string &sample_name, const std::string &variable, const std::string &analysis, const std::string &region, const std::string &root_file)

SampleHisto(const std::string &sample_name, const SampleHisto &signal_histo, const SampleHisto &background_histo)

SampleHisto(const std::string &sample_name, const SampleHisto *signal_histo, const SampleHisto *background_histo)

SampleHisto(const std::string &sample_name, const std::shared_ptr<SampleHisto> &signal_histo, const std::shared_ptr<SampleHisto> &background_histo)

bool isData() const

bool isIrreducible() const

bool isReducible() const

bool isBackground() const

bool isSignal() const

void setSampleType(unsigned int T)

unsigned int getSampleType() const

std::string getSampleTypeName() const

bool isHistoLoaded() const

bool loadIntoMemory()

bool isValid()

TH1_Ptr GetHistogram() const

std::vector<std::shared_ptr<TFile>> get_in_files() const

SampleHisto::variation_pair GetSystErrorBands() const

std::vector<std::shared_ptr<SystematicPairHistos>> GetSystComponents(unsigned int sorting = SystErrorSorting::Naming) const

bool isTH1() const

bool isTH2() const

bool isTH3() const

bool isTH2Poly() const

unsigned int GetDimension() const

unsigned int GetNbins() const

unsigned int GetNbinsX() const

unsigned int GetNbinsY() const

unsigned int GetNbinsZ() const

double GetBinContent(int X, int Y = -1, int Z = -1) const

double GetBinError(int X, int Y = -1, int Z = -1) const

int FindBin(double x, double y = -1, double z = -1) const

TAxis *GetAxis(unsigned int D) const

TAxis *GetXaxis() const

TAxis *GetYaxis() const

TAxis *GetZaxis() const

void SetLumi(double lumi)

void Scale(double scale)

double GetLumi() const

double Integral() const

std::pair<double, double> IntegrateWithError(unsigned int xStart = 0, int xEnd = -1, unsigned int yStart = 0, int yEnd = -1, unsigned int zStart = 0, int zEnd = -1) const

std::string GetDrawStyle() const

void setDrawStyle(const std::string &style)

std::string GetLegendDrawStyle() const

std::string GetTitle() const

std::string GetName() const

std::string GetRegion() const

std::string GetVariableName() const

std::string GetAnalysis() const

void SetTitle(const std::string &title)

int GetLegendOrder() const

void setLegendOrder(int I)

void SetLineColor(Color_t C)

void SetFillColor(Color_t C)

void SetFillColorAlpha(float C)

void SetMarkerColor(Color_t C)

void SetFillStyle(Style_t S)

void SetLineStyle(Style_t S)

void SetMarkerStyle(Style_t S)

void SetMarkerSize(Size_t S)

void SetLineWidth(Width_t W)

bool Add(SampleHisto *other, double scale = 1.)

bool Add(std::shared_ptr<TH1> Histo, double scale = 1.)

bool Add(const TH1 *Histo, double scale = 1.)

std::shared_ptr<TH1> Sqrt()

std::shared_ptr<TH1> ApplyTansformation(const std::function<std::pair<double, double>(unsigned int)> &trans_func)

void Draw(const std::string &options = "")

void Write()

void exclude_systematics(const std::vector<std::string> &to_exclude)

void set_systematics(const std::vector<std::string> &syst_to_use)

void set_nominal(const std::string &nominal)

void setTheoryUncertainty(double unc)

double GetMaximum(double max = DBL_MAX) const

double GetMinimum(double min = DBL_MIN) const

int GetMaximumBin(double max = DBL_MAX) const

int GetMinimumBin(double min = DBL_MIN) const

Protected Functions

std::shared_ptr<TH1> load_from_files(const std::string &systematic) const

bool add_in_quadrature(std::shared_ptr<TH1> add, std::shared_ptr<TH1> to) const

SampleHisto::variation_pair evaluate_sys(std::shared_ptr<TH1> down, std::shared_ptr<TH1> up) const

bool isOverFlow(int bin) const

bool hasAlphaNumericLabels() const

Private Functions

SampleHisto(const SampleHisto&)

void operator=(const SampleHisto&)

std::string GetPlotPath(const std::string &systematic) const

void reset()

Private Members

std::string m_analysis

std::string m_region

std::string m_variable

std::string m_name

std::string m_label

std::shared_ptr<TH1> m_nominal_histo

unsigned int m_sample_type

std::vector<std::shared_ptr<TFile>> m_root_files

bool m_tried_to_load

std::vector<std::shared_ptr<SystematicPairHistos>> m_variations

std::shared_ptr<TH1> m_up_syst_histo

std::shared_ptr<TH1> m_down_syst_histo

int m_legend_order

double m_integral

double m_lumi

std::string m_nominal

std::vector<std::string> m_syst

std::vector<std::string> m_excluded_syst

bool m_syst_set_external

bool m_nominal_set_external

double m_theo_uncert

std::string m_drawStyle

template <class T>
class ScalarCutElement : public XAMPP::ICutElement

#include <Cuts.h>

Public Functions

ScalarCutElement(XAMPP::Storage<T> *Store, XAMPP::IEventInfo *XAMPPInfo)

bool initialize(T Value, Cut::Relation R, bool IsSkimmingCut)

bool ApplyCut(bool ForCutFlow = false) const

Protected Types

template<>
typedef bool (ScalarCutElement::*Application)() const

Protected Functions

bool PassGreaterThan() const

bool PassGreaterEqual() const

bool PassEqual() const

bool PassLessThan() const

bool PassLessEqual() const

Protected Attributes

XAMPP::Storage<T> *m_CutStore

bool m_CutSkims

T m_CutValue

Application m_Relation

template <class T>
class ScalarTreeVarWriter : public XAMPP::ITreeVarWriter

#include <TreeVarWriter.h>

Public Functions

virtual ~ScalarTreeVarWriter()

bool init(TTree *t)

bool fill()

Public Static Functions

ScalarTreeVarWriter<T> *GetWriter(std::string varname, ITreeVarReader *R = nullptr)

Private Functions

ScalarTreeVarWriter(const std::string &Name, ITreeVarReader *R)

ScalarTreeVarWriter(const ScalarTreeVarWriter&)

void operator=(const ScalarTreeVarWriter&)

Private Members

T m_Var

template <class T>
class ScalarVarReader : public XAMPP::IScalarReader

#include <TreeVarReader.h>

Subclassed by XAMPP::ScalarVarReaderGeV< T >

Public Functions

std::string name() const

double read() const

bool init(TTree *t)

virtual ~ScalarVarReader()

const T &get() const

Public Static Functions

ScalarVarReader<T> *GetReader(const std::string &varname)

Protected Functions

ScalarVarReader(const std::string &varname)

ScalarVarReader(const ScalarVarReader&)

void operator=(const ScalarVarReader&)

Private Members

std::string m_var_name

T m_var

unsigned int m_TreeNumber

Long64_t m_lastEvent

TBranch *m_branch

EventService *m_evService

TreeIndexer *m_indexer

bool m_Registered

template <class T>
class ScalarVarReaderGeV : public XAMPP::ScalarVarReader<T>

#include <TreeVarReader.h>

Public Functions

double read() const

virtual ~ScalarVarReaderGeV()

Public Static Functions

ScalarVarReaderGeV<T> *GetReader(const std::string &varname)

Protected Functions

ScalarVarReaderGeV(const std::string &varname)

ScalarVarReaderGeV(const ScalarVarReaderGeV&)

void operator=(const ScalarVarReaderGeV&)

class Selector : public XAMPP::Analysis

#include <Selector.h>

Subclassed by XAMPP::EventIndexer

Public Functions

Selector(const std::string &Name, const std::string &TreeName, const std::vector<std::string> &Files)

bool Process(long int nMax = -1, long int nSkip = 0)

Process the loop on the events.

Return

{ description_of_the_return_value }

Parameters

• nMax: The maximum
• nSkip: The skip

bool ReadHistoConfig(const std::string &Config)

~Selector()

bool userPartialList(const std::vector<std::string> &files, unsigned int begin, unsigned int end)

bool begin(TTree *t)

Protected Functions

bool isData() const

bool CreateNewAnalysisRegion(const std::string &Region)

bool InsertHistogramInRegion(const std::string &Region, Histo *H)

bool InsertHistogramInRegion(const std::string &Region, std::shared_ptr<Histo> H)

bool SetupHistograms(const std::string &Syst)

{ function_description }

Return

{ description_of_the_return_value }

Parameters

• Syst: The syst

bool AnalyzeEvent()

{ function_description }

Return

{ description_of_the_return_value }

bool InitHistos()

void SetupReaders()

bool isRegionDefined(const std::string &region_name) const

template <typename T>
bool ConnectVariable(TTree *t, T &Var, const std::string Branch)

Private Members

std::vector<EventRegion> m_RegionDefinitions

class SetItem

Public Functions

SetItem(ITreeVarReader *R)

double readEntry(const size_t I) const

bool init(TTree *t)

size_t begin() const

size_t end() const

size_t entries() const

void setBegin(size_t b)

Private Members

ITreeVarReader *m_reader

size_t m_begin

class SetReader : public XAMPP::IVectorReader

#include <UtilityReader.h>

Public Functions

double readEntry(const size_t I) const

size_t entries() const

bool init(TTree *t)

std::string name() const

Public Static Functions

ITreeVarReader *GetReader(const std::string &name, const std::vector<ITreeVarReader *> &Set)

Private Functions

SetReader(const std::string &name, const std::vector<ITreeVarReader *> &Set)

SetReader(const SetReader&)

void operator=(const SetReader&)

Private Members

std::vector<std::shared_ptr<SetItem>> m_readers

std::string m_name

Long64_t m_currentEv

size_t m_n_entries

std::shared_ptr<SetItem> m_currentObj

EventService *m_service

class SortedMetParticleReader_ASC : public XAMPP::EventVarSortedParticleReader

#include <ReconstructedParticleReaders.h>

Public Static Functions

SortedMetParticleReader_ASC *GetReader(const std::string Particle, const std::string &Met)

Protected Functions

SortedMetParticleReader_ASC(const std::string &Name, const std::string &Met)

SortedMetParticleReader_ASC(const SortedMetParticleReader_ASC&)

void operator=(const SortedMetParticleReader_ASC&)

bool Sort(size_t Old, size_t New) const

class SortedMetParticleReader_DESC : public XAMPP::EventVarSortedParticleReader

#include <ReconstructedParticleReaders.h>

Public Static Functions

SortedMetParticleReader_DESC *GetReader(const std::string Particle, const std::string &Met)

Protected Functions

SortedMetParticleReader_DESC(const std::string &Name, const std::string &Met)

SortedMetParticleReader_DESC(const SortedMetParticleReader_DESC&)

void operator=(const SortedMetParticleReader_DESC&)

bool Sort(size_t Old, size_t New) const

template <class T>
class Storage : public XAMPP::IStorage

#include <EventStorage.h>

Public Functions

Storage(const std::string &Name, IEventInfo *Info, bool IsCommon = false)

StatusCode Store(T Value)

StatusCode ConstStore(T Value)

T &GetValue()

bool isAvailable() const

~Storage()

Private Members

T m_Variable

Variable to connect the tree to.

SG::AuxElement::Decorator<T> m_Decorator

Access elements to the EventInfo objects storing the actual information of the variable

SG::AuxElement::Accessor<T> m_Accessor

template <class T>
class StorageDefaultValues : public XAMPP::IStorageDefaultValues

#include <BaseAnalysisModule.h>

Public Functions

StorageDefaultValues(XAMPP::Storage<T> *store, const T def_value)

StatusCode Fill()

Private Members

XAMPP::Storage<T> *m_store

const T m_def_value

class StorageKeeper

#include <EventStorage.h>

Public Functions

bool Register(IStorage *S)

bool EventStorageExists(const std::string &Name, const IEventInfo *EvInfo = nullptr) const

bool ParticleDefined(const std::string &Name, const IEventInfo *EvInfo = nullptr) const

template <class T>
Storage<T> *RetrieveEventStorage(const std::string &Name, const IEventInfo *EvInfo = nullptr) const

template <class T>
std::vector<Storage<T> *> GetEventStorages(const IEventInfo *EvInfo = nullptr) const

std::vector<DataVectorStorage *> RetrieveContainerStores(const IEventInfo *Info = nullptr) const

DataVectorStorage *RetrieveContainerStorage(const std::string &Name, const IEventInfo *Info = nullptr) const

~StorageKeeper()

void AttachCut(Cut *C)

void DettachCut(Cut *C)

bool isLocked() const

void Lock()

Public Static Functions

StorageKeeper *GetInstance()

Private Functions

StorageKeeper()

StorageKeeper(const StorageKeeper&)

void operator=(const StorageKeeper&)

StorageKeeper::InfoKeeper *FindKeeper(const IEventInfo *Info = nullptr) const

Private Members

std::shared_ptr<InfoKeeper> m_CommonKeeper

std::vector<std::shared_ptr<InfoKeeper>> m_Keepers

std::vector<Cut *> m_Cuts

bool m_Locked

Private Static Attributes

StorageKeeper *m_Inst = nullptr

class SubSetAnalysis : public XAMPP::Analysis

#include <CombinatoricSelection.h>

The SubSet Analysis does the same job for writing the histograms.

Public Functions

SubSetAnalysis()

~SubSetAnalysis()

Private Functions

bool AnalyzeEvent()

{ function_description }

Return

{ description_of_the_return_value }

Private Members

CombinatoricService *m_service

class SubSetNTupleWriter : public XAMPP::NTupleWriter

#include <CombinatoricSelection.h>

The subset n-tuple writer writes hist-fitter trees as well, but with the augmented functionallity to dump a given event twice based on a combinatoric selection applied on Particle Containers

Public Functions

SubSetNTupleWriter()

~SubSetNTupleWriter()

Private Functions

bool AnalyzeEvent()

{ function_description }

Return

{ description_of_the_return_value }

Private Members

CombinatoricService *m_service

class SubSetParticleReader : public XAMPP::IParticleCollection

#include <CombinatoricSelection.h>

Public Functions

std::string name() const

bool init(TTree *t)

IParticleVarReader *RetrieveVariable(const std::string &Var)

size_t Size()

size_t ReaderIndex() const

size_t ReaderIndex(size_t P)

unsigned int GetCollectionHash() const

const TLorentzVector &P4() const

TLorentzVector GetP4(size_t E)

IParticleReader *underyling_particle() const

size_t remap_entry(size_t i)

Public Static Functions

SubSetParticleReader *GetReader(const std::string &alias_name, IParticleReader *collection = nullptr)

Private Functions

SubSetParticleReader(IParticleReader *particle, const std::string &alias_name)

SubSetParticleReader(const SubSetParticleReader&)

void operator=(const SubSetParticleReader&)

Private Members

std::string m_name

IParticleReader *m_particle

Weight *m_weighter

CombinatoricService *m_comb_service

std::vector<IPermutationElement *> m_possible_permutations

IPermutationElement *m_active_element

std::vector<unsigned int> m_active_permutation

Long64_t m_cached_event

class SubSetParticleVariableReader : public XAMPP::IParticleVariable

#include <CombinatoricSelection.h>

Public Functions

std::string name() const

double readEntry(size_t I) const

bool init(TTree *t)

Public Static Functions

IParticleVarReader *GetReader(SubSetParticleReader *particle, const std::string &var)

Private Functions

SubSetParticleVariableReader(SubSetParticleReader *particle, IParticleVarReader *variable)

SubSetParticleVariableReader(const SubSetParticleVariableReader&)

void operator=(const SubSetParticleVariableReader&)

Private Members

SubSetParticleReader *m_subset_part

IParticleVarReader *m_variable

bool m_Registered

class SumUpReader : public XAMPP::IScalarReader

#include <ObservableReader.h>

Public Functions

double read() const

bool init(TTree *t)

std::string name() const

Public Static Functions

SumUpReader *GetReader(const std::string &Name, ITreeVarReader *FirstReader = nullptr, ITreeVarReader *SecondReader = nullptr)

SumUpReader *GetReader(const std::string &Name, const std::vector<ITreeVarReader *> &Sums)

Protected Functions

SumUpReader(const std::string &Name, const std::vector<ITreeVarReader *> &Sums)

double SumUp(ITreeVarReader *R) const

Protected Attributes

std::string m_Name

std::vector<ITreeVarReader *> m_Sums

unsigned int m_EventNumber

double m_Cache

class SUSYAnalysisHelper : public AsgTool, public virtual XAMPP::IAnalysisHelper

#include <SUSYAnalysisHelper.h>

Subclassed by XAMPP::MonoHAnalysisHelper, XAMPP::SUSYTruthAnalysisHelper

Public Functions

SUSYAnalysisHelper(const std::string &myname)

~SUSYAnalysisHelper()

StatusCode initialize()

StatusCode CheckCutFlow(const CP::SystematicSet *systset)

StatusCode finalize()

StatusCode LoadContainers()

StatusCode FillInitialObjects(const CP::SystematicSet *systset)

StatusCode FillObjects(const CP::SystematicSet *systset)

StatusCode RemoveOverlap()

bool AcceptEvent()

bool EventCleaning() const

bool CleanObjects(const CP::SystematicSet *systset)

bool CheckTrigger()

StatusCode FillEvent(const CP::SystematicSet *set)

unsigned int finalState()

double GetMCXsec(unsigned int mc_channel_number, unsigned int finalState = 0)

void GetMCXsecErrors(bool &error_exists, double &rel_err_down, double &rel_err_up, unsigned int mc_channel_number, unsigned int finalState = 0)

double GetMCFilterEff(unsigned int mc_channel_number, unsigned int finalState = 0)

double GetMCkFactor(unsigned int mc_channel_number, unsigned int finalState = 0)

double GetMCXsectTimesEff(unsigned int mc_channel_number, unsigned int finalState = 0)

std::shared_ptr<ElectronDecorations> GetElectronDecorations() const

std::shared_ptr<MuonDecorations> GetMuonDecorations() const

std::shared_ptr<JetDecorations> GetJetDecorations() const

std::shared_ptr<TruthDecorations> GetTruthDecorations() const

Protected Functions

bool isData() const

bool doTruth() const

bool isInitialized() const

void DisableRecoFlags()

virtual bool storeRecoFlags() const

StatusCode initializeEventVariables()

StatusCode ComputeEventVariables()

StatusCode initializeObjectTools()

StatusCode initializeAnalysisTools()

StatusCode initializeSUSYTools()

StatusCode initializeGRLTool()

StatusCode FillEventWeights()

StatusCode processModules()

bool applyEventDumpCuts()

StatusCode SaveCrossSection()

ST::SUSYObjDef_xAOD *SUSYToolsPtr()

template <typename T>
ToolHandle<T> GetCPTool(const std::string &name)

template <typename Container>
StatusCode ViewElementsContainer(const std::string &Key, Container *&Cont)

bool PassObjectCleaning(const CP::SystematicSet *sys) const

StatusCode DumpNtuple(const CP::SystematicSet *sys)

StatusCode DumpHistos(const CP::SystematicSet *sys)

StatusCode initializeOuputFormat()

bool buildCommonTree() const

Protected Attributes

ToolHandle<IElectronSelector> m_electron_selection

ToolHandle<IJetSelector> m_jet_selection

ToolHandle<IMetSelector> m_met_selection

ToolHandle<IMuonSelector> m_muon_selection

ToolHandle<IPhotonSelector> m_photon_selection

ToolHandle<ITauSelector> m_tau_selection

ToolHandle<IDiTauSelector> m_ditau_selection

ToolHandle<ITruthSelector> m_truth_selection

ToolHandle<ISystematics> m_systematics

ToolHandle<ITriggerTool> m_triggers

asg::AnaToolHandle<ST::ISUSYObjDef_xAODTool> m_susytools

asg::AnaToolHandle<XAMPP::IReconstructedParticles> m_ParticleConstructor

XAMPP::EventInfo *m_XAMPPInfo

Private Functions

std::shared_ptr<HistoBase> CreateHistoClass(const CP::SystematicSet *set)

StatusCode initHistoClass(std::shared_ptr<HistoBase> HistoClass)

void CleaningForOutput(const std::string &DecorName, XAMPP::Storage<int> *&Store, bool DoCleaning)

std::shared_ptr<TreeBase> CreateTreeClass(const CP::SystematicSet *set)

StatusCode initTreeClass(std::shared_ptr<TreeBase> TreeClass)

Private Members

ServiceHandle<ITHistSvc> m_histSvc

bool m_init

bool m_added_output

bool m_RunCutFlow

bool m_UseFileMetadata

bool m_storeLHEbyName

bool m_doHistos

bool m_doTrees

bool m_doTruth

bool m_doPRW

bool m_isAF2

bool m_useGRLTool

bool m_StoreRecoFlags

bool m_CleanEvent

bool m_CleanBadMuon

bool m_CleanCosmicMuon

bool m_CleanBadJet

bool m_FillLHEWeights

bool m_shiftMetaDSID

std::map<unsigned int, XAMPP::Storage<double> *> m_LHEWeights

XAMPP::Storage<int> *m_dec_NumBadMuon

XAMPP::Storage<int> *m_decNumBadJet

XAMPP::Storage<int> *m_decNumCosmicMuon

std::string m_STConfigFile

std::string m_XsecDBDir

std::vector<std::string> m_GoodRunsListVec

std::vector<std::string> m_PRWConfigFiles

std::vector<std::string> m_PRWLumiCalcFiles

bool m_useXsecPMGTool

std::string m_XsecPMGToolFile

std::unique_ptr<SUSY::CrossSectionDB> m_XsecDB

std::map<const CP::SystematicSet *, std::shared_ptr<HistoBase>> m_histoVec

std::map<const CP::SystematicSet *, std::shared_ptr<TreeBase>> m_treeVec

bool m_buildCommonTree

ToolHandle<XAMPP::IAnalysisConfig> m_config

ToolHandleArray<XAMPP::IAnalysisModule> m_analysis_modules

bool m_hasModules

int m_OutlierStrat

float m_outlierWeightThreshold

asg::AnaToolHandle<XAMPP::IEventInfo> m_InfoHandle

asg::AnaToolHandle<XAMPP::IMetaDataTree> m_MDTree

asg::AnaToolHandle<IGoodRunsListSelectionTool> m_grl

class SUSYElectronSelector : public XAMPP::SUSYParticleSelector, public virtual XAMPP::IElectronSelector

#include <SUSYElectronSelector.h>

Public Functions

SUSYElectronSelector(const std::string &myname)

~SUSYElectronSelector()

StatusCode initialize()

StatusCode LoadSelection(const CP::SystematicSet &systset)

StatusCode LoadContainers()

StatusCode InitialFill(const CP::SystematicSet &systset)

StatusCode FillElectrons(const CP::SystematicSet &systset)

EleLink GetLink(const xAOD::Electron &el) const

EleLink GetOrigLink(const xAOD::Electron &el) const

virtual const xAOD::ElectronContainer *GetElectronContainer() const

virtual xAOD::ElectronContainer *GetElectrons() const

Returns the unskimmed container of all calibrated Electron objects.

virtual xAOD::ElectronContainer *GetPreElectrons() const

The pre container only contains Electronss passing the basic kinematic requirements and the baseline selection WP.

virtual xAOD::ElectronContainer *GetSignalElectrons() const

Signal Electrons have to pass all final selection requirements.

virtual xAOD::ElectronContainer *GetBaselineElectrons() const

Baseline Electron candidates are preElectrons surviving the overlap removal procedure No additional quality requirement is made

virtual xAOD::ElectronContainer *GetSignalNoORElectrons() const

Signal quality muons are all objects which pass the baseline & signal kinematics as well as the quality selection criteria. No overlap removal is considered.

xAOD::ElectronContainer *GetCustomElectrons(const std::string &kind) const

StatusCode SaveScaleFactor()

virtual std::shared_ptr<ElectronDecorations> GetElectronDecorations() const

Protected Functions

StatusCode CallSUSYTools()

bool PassPreSelection(const xAOD::IParticle &P) const

bool PassBaseline(const xAOD::IParticle &P) const

bool GetSignalDecorator(const xAOD::IParticle &P) const

StatusCode setupScaleFactors()

std::string EG_WP(const std::string &wp) const

std::string Trig_Iso_WP(const std::string &trig_exp, bool use_signal = true) const

std::string Trig_EG_WP(const std::string &trig_exp, bool use_signal = true) const

void setupDecorations(std::shared_ptr<ElectronDecorations> input = nullptr)

Protected Attributes

xAOD::ElectronContainer *m_Electrons

xAOD::ShallowAuxContainer *m_ElectronsAux

xAOD::ElectronContainer *m_PreElectrons

xAOD::ElectronContainer *m_BaselineElectrons

xAOD::ElectronContainer *m_SignalNoORElectrons

xAOD::ElectronContainer *m_SignalElectrons

std::shared_ptr<ElectronDecorations> m_electronDecorations

ToolHandle<ITriggerTool> m_trigger_tool

Private Types

typedef std::pair<std::string, EleEffToolHandle> TrigSFTool

typedef std::map<std::string, EleEffToolHandle> TrigSFTool_Map

Private Functions

StatusCode initializeScaleFactors(const std::string &sf_type, EleEffToolHandle &sf_tool, ElectronWeightMap &map, unsigned int content)

StatusCode initializeTriggerScaleFactors(TrigSFTool_Map &SFTools, ElectronWeight_VectorMap &SFs, unsigned int content)

void GetTriggerTokens(std::string trigger_str, std::vector<std::string> &v_trigger15, std::vector<std::string> &v_trigger16, std::vector<std::string> &v_trigger17, std::vector<std::string> &v_trigger18) const

StatusCode initializeTriggerSFTools()

StatusCode initializeTriggerSFTools(TrigSFTool_Map &map, bool use_signal)

std::string FindBestSFTool(const TrigSFTool_Map &TriggerSFTools, const std::string &TriggerSF)

Private Members

float m_PreSelectionD0SigCut

float m_PreSelectionZ0SinThetaCut

bool m_RequireIsoPreSelection

float m_BaselineD0SigCut

float m_BaselineZ0SinThetaCut

bool m_RequireIsoBaseline

float m_SignalD0SigCut

float m_SignalZ0SinThetaCut

bool m_RequireIsoSignal

bool m_StoreTruthClassifier

const xAOD::ElectronContainer *m_xAODElectrons

std::vector<ElectronWeightHandler_Ptr> m_SF

TrigSFTool_Map m_SignalTrig_SF_Tools

TrigSFTool_Map m_BaselineTrig_SF_Tools

EleEffToolHandle m_Reco_SF_Handle

EleEffToolHandle m_SignalId_SF_Handle

EleEffToolHandle m_SignalIso_SF_Handle

EleEffToolHandle m_BaselineId_SF_Handle

EleEffToolHandle m_BaselineIso_SF_Handle

bool m_SeparateSF

bool m_doRecoSF

bool m_doIdSF

bool m_doTriggerSF

bool m_doIsoSF

std::vector<std::string> m_TriggerExp

std::vector<std::string> m_TriggerSFConf

bool m_StoreMultiTrigSF

bool m_writeBaselineSF

std::string m_Baseline_Id_WP

std::string m_Signal_Id_WP

std::string m_EfficiencyMap

std::string m_CorrelationModel

std::string m_Signal_Iso_WP

std::string m_Baseline_Iso_WP

ToolHandle<CP::IIsolationSelectionTool> m_iso_tool

bool m_force_iso_calc

class SUSYJetSelector : public XAMPP::SUSYParticleSelector, public virtual XAMPP::IJetSelector

#include <SUSYJetSelector.h>

Subclassed by XAMPP::MonoHJetSelector

Public Functions

SUSYJetSelector(const std::string &myname)

~SUSYJetSelector()

StatusCode initialize()

StatusCode LoadContainers()

StatusCode InitialFill(const CP::SystematicSet &systset)

StatusCode FillJets(const CP::SystematicSet &systset)

virtual xAOD::JetContainer *GetJets() const

virtual xAOD::JetContainer *GetPreJets(int Radius = 4) const

virtual xAOD::JetContainer *GetBaselineJets(int = 4) const

virtual xAOD::JetContainer *GetSignalJets(int = 4) const

virtual xAOD::JetContainer *GetSignalNoORJets(int = 4) const

virtual xAOD::JetContainer *GetBJets() const

virtual xAOD::JetContainer *GetLightJets() const

virtual xAOD::JetContainer *GetSignalJetsNoJVT() const

xAOD::JetContainer *GetCustomJets(const std::string &kind) const

StatusCode ReclusterJets(const xAOD::IParticleContainer *inputJets, float Rcone, float minPtKt4 = -1, std::string PreFix = "", float minPtRecl = -1, float rclus = -1, float ptfrac = -1)

StatusCode SaveScaleFactor()

virtual std::shared_ptr<JetDecorations> GetJetDecorations() const

Protected Functions

StatusCode CalibrateJets(const std::string &Key, xAOD::JetContainer *&Container, xAOD::JetContainer *&PreSelected, const std::string &PreSelName = "", JetAlgorithm Cone = JetAlgorithm::AntiKt4)

StatusCode CalibrateJets(const std::string &Key, xAOD::JetContainer *&PreSelected, const std::string &PreSelName = "", JetAlgorithm Cone = JetAlgorithm::AntiKt4)

bool IsBadJet(const xAOD::Jet &jet) const

bool IsBJet(const xAOD::Jet &jet) const

double BtagBDT(const xAOD::Jet &jet) const

bool PassBaselineKinematics(const xAOD::IParticle &P) const

bool PassSignalKinematics(const xAOD::IParticle &P) const

bool isFromAlgorithm(const xAOD::IParticle &jet, XAMPP::JetAlgorithm alg) const

bool isFromAlgorithm(const xAOD::IParticle *jet, XAMPP::JetAlgorithm alg) const

virtual StatusCode preCalibCorrection(xAOD::JetContainer *)

StatusCode SetupScaleFactors()

StatusCode SetupSelection()

void setupDecorations(std::shared_ptr<JetDecorations> input = nullptr)

Protected Attributes

const xAOD::JetContainer *m_xAODJets

xAOD::JetContainer *m_Jets

xAOD::JetContainer *m_PreJets

xAOD::JetContainer *m_BaselineJets

xAOD::JetContainer *m_PreJVTJets

xAOD::JetContainer *m_SignalJets

xAOD::JetContainer *m_SignalQualJets

xAOD::JetContainer *m_PreFatJets

xAOD::JetContainer *m_BJets

xAOD::JetContainer *m_LightJets

std::shared_ptr<JetDecorations> m_jetDecorations

ToolHandle<CP::IJetJvtEfficiency> m_JvtTool

Private Members

int m_JetCollectionType

XAMPP::Storage<int> *m_decNBad

float m_bJetEtaCut

bool m_SeparateSF

std::vector<JetWeightHandler_Ptr> m_SF

bool m_doBTagSF

bool m_doJVTSF

bool m_doLargeRdecors

float m_Kt10_BaselinePt

float m_Kt10_BaselineEta

float m_Kt10_SignalPt

float m_Kt10_SignalEta

float m_Kt02_BaselinePt

float m_Kt02_BaselineEta

float m_Kt02_SignalPt

float m_Kt02_SignalEta

int m_Kt02_ORUtils_flag

int m_Kt10_ORUtils_flag

ToolHandle<IBTaggingEfficiencyTool> m_BtagTool

class SUSYMetSelector : public AsgTool, public virtual XAMPP::IMetSelector

#include <SUSYMetSelector.h>

Subclassed by XAMPP::MonoHMetSelector

Public Functions

SUSYMetSelector(const std::string &myname)

virtual ~SUSYMetSelector()

StatusCode initialize()

StatusCode LoadContainers()

StatusCode FillMet(const CP::SystematicSet &systset)

StatusCode SaveScaleFactor()

xAOD::MissingETContainer *GetCustomMet(const std::string &kind = "") const

StatusCode addToInvisible(xAOD::IParticle *particle, const std::string &invis_container)

StatusCode addToInvisible(xAOD::IParticle &particle, const std::string &invis_container)

StatusCode addToInvisible(const xAOD::IParticleContainer *container, const std::string &invis_container)

StatusCode addToInvisible(const xAOD::IParticleContainer &container, const std::string &invis_container)

xAOD::IParticleContainer *getInvisible(const std::string &invis_container = "") const

std::string softTrackTerm() const

std::string softCaloTerm() const

std::string referenceTerm(xAOD::Type::ObjectType Type) const

std::string FinalMetTerm() const

std::string FinalTrackMetTerm() const

ST::SUSYObjDef_xAOD *SUSYToolsPtr()

Protected Functions

StatusCode CreateContainer(const std::string &name, xAOD::MissingETContainer *&Cont)

StatusCode SetSystematic(const CP::SystematicSet &systset)

std::string storeName(const std::string &name) const

StatusCode initializeMetSignificance()

bool isInitialized() const

bool IncludePhotons() const

bool IncludeTaus() const

StatusCode buildMET(xAOD::MissingETContainer *&MET, const std::string &met_name, const std::string &soft_term, const xAOD::ElectronContainer *electrons = nullptr, const xAOD::MuonContainer *muons = nullptr, const xAOD::TauJetContainer *taus = nullptr, const xAOD::PhotonContainer *photons = nullptr, bool doJvt = true)

StatusCode buildTrackMET(xAOD::MissingETContainer *&MET, const std::string &met_name, const xAOD::ElectronContainer *electrons = nullptr, const xAOD::MuonContainer *muons = nullptr, const xAOD::TauJetContainer *taus = nullptr, const xAOD::PhotonContainer *photons = nullptr, bool doJvt = true)

MetSignificanceHandler_Ptr newSignificanceTool(const std::string &grp, bool enabled = true)

template <typename T>
ToolHandle<T> GetCPTool(const std::string &name)

Protected Attributes

XAMPP::EventInfo *m_XAMPPInfo

asg::AnaToolHandle<ST::ISUSYObjDef_xAODTool> m_susytools

ToolHandle<XAMPP::IElectronSelector> m_elec_selection

ToolHandle<XAMPP::IMuonSelector> m_muon_selection

ToolHandle<XAMPP::IJetSelector> m_jet_selection

ToolHandle<XAMPP::IPhotonSelector> m_phot_selection

ToolHandle<XAMPP::ITauSelector> m_tau_selection

ToolHandle<XAMPP::ISystematics> m_systematics

Private Functions

StatusCode addContainerToMet(xAOD::MissingETContainer *MET, const xAOD::IParticleContainer *particles, xAOD::Type::ObjectType type, const xAOD::IParticleContainer *invisible = nullptr)

StatusCode markInvisible(xAOD::MissingETContainer *MET, const xAOD::IParticleContainer *invisible)

StatusCode buildMET(xAOD::MissingETContainer *MET, const std::string &softTerm, bool doJvt = true, const xAOD::IParticleContainer *invisible = nullptr, bool build_track = false)

Private Members

asg::AnaToolHandle<XAMPP::IEventInfo> m_InfoHandle

std::vector<MetSignificanceHandler_Ptr> m_metSignifHandlers

MetSignificanceHandler_Ptr m_metSignif

MetSignificanceHandler_Ptr m_metSignif_noPUJets

MetSignificanceHandler_Ptr m_metSignif_noPUJets_noSoftTerm

MetSignificanceHandler_Ptr m_metSignif_dataJER

MetSignificanceHandler_Ptr m_metSignif_dataJER_noPUJets

MetSignificanceHandler_Ptr m_metSignif_phireso_noPUJets

bool m_init

bool m_doTrackMet

bool m_doMetCST

bool m_IncludePhotons

bool m_IncludeTaus

xAOD::MissingETContainer *m_MetTST

xAOD::MissingETContainer *m_MetCST

xAOD::MissingETContainer *m_MetTrack

XAMPP::Storage<XAMPPmet> *m_sto_MetTST

XAMPP::Storage<XAMPPmet> *m_sto_MetCST

XAMPP::Storage<XAMPPmet> *m_sto_MetTrack

const xAOD::MissingETContainer *m_xAODMet

const xAOD::MissingETAssociationMap *m_xAODMap

const xAOD::MissingETContainer *m_xAODTrackMet

std::string m_met_key

std::string m_met_map_key

std::string m_met_track_key

std::string m_systName

bool m_store_significance

ToolHandle<IMETMaker> m_metMaker

ToolHandle<IMETSystematicsTool> m_metSystTool

std::string m_EleRefTerm

std::string m_MuoRefTerm

std::string m_TauRefTerm

std::string m_JetRefTerm

std::string m_PhoRefTerm

std::string m_TrackSoftTerm

std::string m_CaloSoftTerm

std::string m_FinalMetTerm

std::string m_FinalTrackTerm

bool m_trkJetsyst

bool m_trkMETsyst

class SUSYMuonSelector : public XAMPP::SUSYParticleSelector, public virtual XAMPP::IMuonSelector

#include <SUSYMuonSelector.h>

Public Functions

SUSYMuonSelector(const std::string &myname)

~SUSYMuonSelector()

StatusCode initialize()

StatusCode LoadContainers()

StatusCode InitialFill(const CP::SystematicSet &systset)

StatusCode FillMuons(const CP::SystematicSet &systset)

StatusCode LoadSelection(const CP::SystematicSet &systset)

MuoLink GetLink(const xAOD::Muon &mu) const

MuoLink GetOrigLink(const xAOD::Muon &mu) const

virtual const xAOD::MuonContainer *GetMuonContainer() const

virtual xAOD::MuonContainer *GetMuons() const

Returns the unskimmed container of all calibrated Muon objects.

virtual xAOD::MuonContainer *GetPreMuons() const

The pre container only contains Muonss passing the basic kinematic requirements and the baseline selection WP.

virtual xAOD::MuonContainer *GetSignalMuons() const

Signal Muons have to pass all final selection requirements.

virtual xAOD::MuonContainer *GetBaselineMuons() const

Baseline Muon candidates are preMuons surviving the overlap removal procedure No additional quality requirement is made

virtual xAOD::MuonContainer *GetSignalNoORMuons() const

Signal quality muons are all objects which pass the baseline & signal kinematics as well as the quality selection criteria. No overlap removal is considered.

xAOD::MuonContainer *GetCustomMuons(const std::string &kind) const

StatusCode SaveScaleFactor()

virtual std::shared_ptr<MuonDecorations> GetMuonDecorations() const

Protected Functions

StatusCode CallSUSYTools()

StatusCode StoreTruthClassifer(xAOD::Muon &mu) const

bool IsBadMuon(const xAOD::Muon &mu) const

bool IsCosmicMuon(const xAOD::Muon &mu) const

bool PassPreSelection(const xAOD::IParticle &P) const

bool PassBaseline(const xAOD::IParticle &P) const

bool GetSignalDecorator(const xAOD::IParticle &P) const

StatusCode SetupScaleFactors()

StatusCode SetupSelection()

void setupDecorations(std::shared_ptr<MuonDecorations> input = nullptr)

Protected Attributes

const xAOD::MuonContainer *m_xAODMuons

xAOD::MuonContainer *m_Muons

xAOD::ShallowAuxContainer *m_MuonsAux

xAOD::MuonContainer *m_PreMuons

xAOD::MuonContainer *m_SignalMuons

xAOD::MuonContainer *m_BaselineMuons

xAOD::MuonContainer *m_SignalQualMuons

std::shared_ptr<MuonDecorations> m_muonDecorations

XAMPP::Storage<int> *m_NumBadMuons

XAMPP::Storage<int> *m_NumCosmics

Private Functions

StatusCode initializeSfMap(const std::string &sf_type, ToolHandle<CP::IMuonEfficiencyScaleFactors> &sf_tool, MuonWeightMap &map, unsigned int content)

StatusCode initializeTrigSFMap(ToolHandle<CP::IMuonTriggerScaleFactors> &sf_tool, SUSYMuonTriggerSFHandler_Map &map, bool isBaseline)

StatusCode initTriggerSFDecorators(const std::vector<std::string> &Triggers, std::vector<SUSYMuonTriggerSFHandler_Ptr> &Decorators, const CP::SystematicSet *set, unsigned int year, bool isBaseline)

Private Members

float m_PreSelectionD0SigCut

float m_PreSelectionZ0SinThetaCut

bool m_RequireIsoPreSelection

float m_BaselineD0SigCut

float m_BaselineZ0SinThetaCut

bool m_RequireIsoBaseline

float m_SignalD0SigCut

float m_SignalZ0SinThetaCut

bool m_RequireIsoSignal

bool m_StoreTruthClassifier

bool m_SeparateSF

std::vector<MuonWeightHandler_Ptr> m_SF

bool m_doRecoSF

bool m_doIsoSF

bool m_doTTVASF

bool m_doTriggerSF

std::vector<std::string> m_TriggerExp2015

std::vector<std::string> m_TriggerExp2016

std::vector<std::string> m_TriggerExp2017

std::vector<std::string> m_TriggerExp2018

bool m_StoreMultipleTrigSF

bool m_writeBaselineSF

ToolHandle<CP::IMuonEfficiencyScaleFactors> m_SFtool_Reco

ToolHandle<CP::IMuonEfficiencyScaleFactors> m_SFtool_Iso

ToolHandle<CP::IMuonEfficiencyScaleFactors> m_SFtool_TTVA

ToolHandle<CP::IMuonEfficiencyScaleFactors> m_SFtool_BaseReco

ToolHandle<CP::IMuonTriggerScaleFactors> m_SFtool_Trig

ToolHandle<CP::IMuonTriggerScaleFactors> m_SFtool_BasTrig

std::string m_SFtoolName_Trig

int m_Baseline_Muon_Id

int m_Signal_Muon_Id

std::string m_quality_Cosmic

std::string m_quality_BadMuon

ToolHandle<CP::IIsolationSelectionTool> m_iso_tool

bool m_force_iso_calc

class SUSYMuonTriggerSFHandler : public XAMPP::IParticleWeightDecorator

#include <SUSYMuonSelector.h>

Public Functions

SUSYMuonTriggerSFHandler(const XAMPP::EventInfo *Info, ToolHandle<ST::ISUSYObjDef_xAODTool> ST, const std::string &Trigger, int year)

StatusCode initialize()

void ApplyIfTriggerFired(bool B)

void DefineTrigger(const std::string &Trigger)

StatusCode SaveSF(const xAOD::MuonContainer *Muons)

bool SetBaselineTool(SUSYMuonTriggerSFHandler_Ptr Ref)

void FilterHandlersFromOtherYears(const SUSYMuonTriggerSFHandler_Vector &handlers)

bool isAvailable() const

const std::string &name() const

unsigned int year() const

unsigned int nMuons() const

~SUSYMuonTriggerSFHandler()

Private Members

SUSYMuonTriggerSFHandler_Ptr m_BaselineHandler

std::vector<SUSYMuonTriggerSFHandler *> m_otherYearHandlers

const XAMPP::EventInfo *m_Info

ToolHandle<ST::ISUSYObjDef_xAODTool> m_SUSYTools

std::string m_SF_string

std::string m_Trigger_string

unsigned int m_year

unsigned int m_n_muons

bool m_DependOnTrigger

Cut *m_Cut

class SUSYParticleSelector : public XAMPP::ParticleSelector

#include <SUSYParticleSelector.h>

Subclassed by XAMPP::SUSYElectronSelector, XAMPP::SUSYJetSelector, XAMPP::SUSYMuonSelector, XAMPP::SUSYPhotonSelector, XAMPP::SUSYTauSelector

Public Functions

SUSYParticleSelector(std::string myname)

~SUSYParticleSelector()

StatusCode initialize()

Protected Functions

StatusCode CallSUSYTools()

ST::SUSYObjDef_xAOD *SUSYToolsPtr() const

template <typename Container>
StatusCode LoadPreSelectedContainer(Container *&PreSelCont, const CP::SystematicSet *syst)

template <typename Container>
StatusCode FillFromSUSYTools(Container *&Cont, xAOD::ShallowAuxContainer *&AuxCont, Container *&PreSelCont)

template <typename T>
ToolHandle<T> GetCPTool(const std::string &name)

Protected Attributes

asg::AnaToolHandle<ST::ISUSYObjDef_xAODTool> m_susytools

Private Members

ST::SUSYObjDef_xAOD *m_STPtr

class SUSYPhotonSelector : public XAMPP::SUSYParticleSelector, public virtual XAMPP::IPhotonSelector

#include <SUSYPhotonSelector.h>

Public Functions

SUSYPhotonSelector(const std::string &myname)

~SUSYPhotonSelector()

StatusCode initialize()

StatusCode LoadContainers()

StatusCode InitialFill(const CP::SystematicSet &systset)

StatusCode FillPhotons(const CP::SystematicSet &systset)

PhoLink GetLink(const xAOD::Photon &ph) const

PhoLink GetOrigLink(const xAOD::Photon &ph) const

xAOD::PhotonContainer *GetPhotons() const

Returns the unskimmed container of all calibrated photon objects.

xAOD::PhotonContainer *GetPrePhotons() const

The pre container only contains photons passing the basic kinematic requirements and the baseline selection WP.

const xAOD::PhotonContainer *GetPhotonContainer() const

xAOD::PhotonContainer *GetSignalPhotons() const

Signal photons have to pass all final selection requirements.

xAOD::PhotonContainer *GetBaselinePhotons() const

Baseline photon candidates are preTaus surviving the overlap removal procedure No additional quality requirement is made

xAOD::PhotonContainer *GetSignalNoORPhotons() const

Signal quality taus are all taus which pass the baseline & signal kinematics as well as the quality selection criteria. No overlap removal is considered.

xAOD::PhotonContainer *GetCustomPhotons(const std::string &kind) const

StatusCode SaveScaleFactor()

std::shared_ptr<PhotonDecorations> GetPhotonDecorations() const

Protected Functions

StatusCode CallSUSYTools()

bool PassPreSelection(const xAOD::IParticle &P) const

bool PassSignal(const xAOD::IParticle &P) const

bool PassBaseline(const xAOD::IParticle &P) const

void setupDecorations(std::shared_ptr<PhotonDecorations> input = nullptr)

Protected Attributes

xAOD::PhotonContainer *m_PrePhotons

xAOD::PhotonContainer *m_BaselinePhotons

xAOD::PhotonContainer *m_SignalPhotons

xAOD::PhotonContainer *m_SignalQualPhotons

std::shared_ptr<PhotonDecorations> m_photonDecorations

Private Functions

StatusCode initializeScaleFactors(const std::string &sf_type, PhotonEffToolHandle &sf_tool, PhotonWeightMap &map, unsigned int content)

Private Members

const xAOD::PhotonContainer *m_xAODPhotons

xAOD::PhotonContainer *m_Photons

xAOD::ShallowAuxContainer *m_PhotonsAux

bool m_SeparateSF

std::vector<PhotonWeightHandler_Ptr> m_SF

bool m_doRecoSF

bool m_doIsoSF

bool m_requireIso_PreSelection

bool m_requireIso_Baseline

bool m_requireIso_Signal

bool m_writeBaselineSF

class SUSYSystematics : public AsgTool, public virtual XAMPP::ISystematics

#include <SUSYSystematics.h>

Public Functions

SUSYSystematics(const std::string &myname)

~SUSYSystematics()

std::vector<const CP::SystematicSet *> GetAllSystematics() const

std::vector<const CP::SystematicSet *> GetKinematicSystematics(XAMPP::SelectionObject T = XAMPP::SelectionObject::Other) const

std::vector<const CP::SystematicSet *> GetWeightSystematics(XAMPP::SelectionObject T = XAMPP::SelectionObject::Other) const

const CP::SystematicSet *GetNominal() const

const CP::SystematicSet *GetCurrent() const

StatusCode resetSystematics()

StatusCode setSystematic(const CP::SystematicSet *Set)

bool AffectsOnlyMET(const CP::SystematicSet *Set) const

bool ProcessObject(XAMPP::SelectionObject T) const

bool isData() const

bool isAF2() const

StatusCode InsertKinematicSystematic(const CP::SystematicSet &set, XAMPP::SelectionObject T = XAMPP::SelectionObject::Other)

StatusCode InsertWeightSystematic(const CP::SystematicSet &set, XAMPP::SelectionObject T = XAMPP::SelectionObject::Other)

StatusCode InsertSystematicToolService(XAMPP::ISystematicToolService *Service)

bool SystematicsFixed() const

StatusCode FixSystematics()

Private Functions

const CP::SystematicSet *CreateCopy(const CP::SystematicSet &Set)

void PromptSystList(std::vector<const CP::SystematicSet *> &List, const std::string &Type) const

void AppendSystematic(std::vector<const CP::SystematicSet *> &Systematics, const CP::SystematicSet *set)

void CopySystematics(std::vector<const CP::SystematicSet *> &From, std::vector<const CP::SystematicSet *> &To)

Private Members

std::vector<std::shared_ptr<CP::SystematicSet>> m_syst_all

std::vector<const CP::SystematicSet *> m_syst_kin

std::vector<const CP::SystematicSet *> m_syst_kin_ele

std::vector<const CP::SystematicSet *> m_syst_kin_muo

std::vector<const CP::SystematicSet *> m_syst_kin_jet

std::vector<const CP::SystematicSet *> m_syst_kin_tau

std::vector<const CP::SystematicSet *> m_syst_kin_pho

std::vector<const CP::SystematicSet *> m_syst_kin_met

std::vector<const CP::SystematicSet *> m_syst_kin_trk

std::vector<const CP::SystematicSet *> m_syst_kin_tru

std::vector<const CP::SystematicSet *> m_syst_weight

std::vector<const CP::SystematicSet *> m_syst_weight_elec

std::vector<const CP::SystematicSet *> m_syst_weight_muon

std::vector<const CP::SystematicSet *> m_syst_weight_tau

std::vector<const CP::SystematicSet *> m_syst_weight_phot

std::vector<const CP::SystematicSet *> m_syst_weight_jet

std::vector<const CP::SystematicSet *> m_syst_weight_btag

std::vector<const CP::SystematicSet *> m_syst_weight_met

std::vector<const CP::SystematicSet *> m_syst_weight_trk

std::vector<const CP::SystematicSet *> m_syst_weight_tru

std::vector<const CP::SystematicSet *> m_syst_weight_evtweight

const CP::SystematicSet *m_empty_syst

const CP::SystematicSet *m_act_syst

bool m_doNoElecs

bool m_doNoMuons

bool m_doNoJets

bool m_doNoTaus

bool m_doNoPhotons

bool m_doNoDiTaus

bool m_doNoBtag

bool m_doNoMet

bool m_doNoTracks

bool m_doNoTruth

bool m_doSyst

bool m_doWeights

std::vector<std::shared_ptr<XAMPP::ISystematicToolService>> m_Tools

std::vector<std::string> m_excluded_syst

bool m_init

bool m_isData

bool m_isAF2

class SUSYTauSelector : public XAMPP::SUSYParticleSelector, public virtual XAMPP::ITauSelector

#include <SUSYTauSelector.h>

Public Functions

SUSYTauSelector(const std::string &myname)

~SUSYTauSelector()

StatusCode initialize()

StatusCode LoadContainers()

StatusCode InitialFill(const CP::SystematicSet &systset)

StatusCode FillTaus(const CP::SystematicSet &systset)

TauLink GetLink(const xAOD::TauJet &tau) const

TauLink GetOrigLink(const xAOD::TauJet &tau) const

const xAOD::TauJetContainer *GetTauContainer() const

xAOD::TauJetContainer *GetTaus() const

Returns the unskimmed container of all calibrated tau objects.

xAOD::TauJetContainer *GetPreTaus() const

The pre container only contains taus passing the basic kinematic requirements and the baseline selection WP.

xAOD::TauJetContainer *GetSignalTaus() const

Signal taus have to pass all final selection requirements.

xAOD::TauJetContainer *GetBaselineTaus() const

Baseline Tau candidates are preTaus surviving the overlap removal procedure No additional quality requirement is made

xAOD::TauJetContainer *GetSignalNoORTaus() const

Signal quality taus are all taus which pass the baseline & signal kinematics as well as the quality selection criteria. No overlap removal is considered.

xAOD::TauJetContainer *GetCustomTaus(const std::string &kind) const

StatusCode SaveScaleFactor()

std::shared_ptr<TauDecorations> GetTauDecorations() const

Protected Functions

StatusCode CallSUSYTools()

void setupDecorations(std::shared_ptr<TauDecorations> input = nullptr)

StatusCode StoreTruthClassifer(xAOD::TauJet &tau)

Protected Attributes

const xAOD::TauJetContainer *m_xAODTaus

xAOD::TauJetContainer *m_Taus

xAOD::ShallowAuxContainer *m_TausAux

xAOD::TauJetContainer *m_PreTaus

xAOD::TauJetContainer *m_BaselineTaus

xAOD::TauJetContainer *m_SignalTaus

xAOD::TauJetContainer *m_SignalQualTaus

std::shared_ptr<TauDecorations> m_tauDecorations

asg::AnaToolHandle<TauAnalysisTools::ITauTruthMatchingTool> m_TruthMatching

Private Functions

StatusCode initializeTauEfficiencySFTools(TauEffiToolMap &SfTools, ToolHandle<TauAnalysisTools::ITauSelectionTool> &selectionTool)

StatusCode initializeScaleFactors(TauEffiToolMap &SfTools, std::vector<TauWeightMap> &sf_types, unsigned int content)

StatusCode initializeScaleFactors(const std::string &sf_type, TauEffiToolHandle &sf_tool, TauWeightMap &map, unsigned int content)

StatusCode initializeTriggerEfficiencySFTools(TauTriggEffiToolMap &SfTools, ToolHandle<TauAnalysisTools::ITauSelectionTool> &selectionTool)

StatusCode initializeTriggerScaleFactors(TauTriggEffiToolMap &SFTools, TauWeight_VectorMap &SF_Map, unsigned int content)

Private Members

std::vector<TauWeightHandler_Ptr> m_SF

ToolHandle<TauAnalysisTools::ITauSelectionTool> m_BaseTauSelectionTool

ToolHandle<TauAnalysisTools::ITauSelectionTool> m_SignalTauSelectionTool

ToolHandle<ITriggerTool> m_trigger_tool

TauEffiToolMap m_BaselineSF_Tools

TauEffiToolMap m_SignalSF_Tools

TauTriggEffiToolMap m_Baseline_TrigSF_Tools

TauTriggEffiToolMap m_Signal_TrigSF_Tools

bool m_SeparateSF

bool m_doIdSF

bool m_doTrigSF

std::vector<std::string> m_TriggerExp

bool m_StoreMultiTriggerSf

bool m_RequireTrigMatchForSF

bool m_writeBaselineSF

bool m_writeBaselineTrigSF

bool m_StoreTruthClassifier

bool m_ignoreBaseTauIDTool

class SUSYToolsSystematicToolHandle : public virtual XAMPP::ISystematicToolService

#include <SUSYSystematics.h>

Public Functions

SUSYToolsSystematicToolHandle(ToolHandle<ST::ISUSYObjDef_xAODTool> &SusyTools)

SUSYToolsSystematicToolHandle(asg::AnaToolHandle<ST::ISUSYObjDef_xAODTool> &SusyTools)

SUSYToolsSystematicToolHandle(ST::ISUSYObjDef_xAODTool *SusyTools)

StatusCode resetSystematic()

StatusCode setSystematic(const CP::SystematicSet *Set)

StatusCode initialize()

std::string name() const

~SUSYToolsSystematicToolHandle()

Private Functions

void FatalMSG(const std::string &MSG) const

void InfoMSG(const std::string &MSG) const

bool systematicAffectsMET(const ST::SystInfo &isys) const

bool systematicAffects(const ST::SystInfo &isys, xAOD::Type::ObjectType t) const

bool isKineSys(const ST::SystInfo &isys) const

bool isWeightSys(const ST::SystInfo &isys) const

Private Members

ST::ISUSYObjDef_xAODTool *m_SUSYTools_ptr

asg::AnaToolHandle<ST::ISUSYObjDef_xAODTool> m_anaSUSYTools

ToolHandle<ST::ISUSYObjDef_xAODTool> m_SUSYTools

ToolHandle<XAMPP::ISystematics> m_systematic

bool m_init

std::vector<xAOD::Type::ObjectType> m_objTypes

class SUSYTriggerTool : public AsgTool, public virtual XAMPP::ITriggerTool

#include <SUSYTriggerTool.h>

Public Functions

~SUSYTriggerTool()

SUSYTriggerTool(const std::string &myname)

StatusCode initialize()

bool CheckTrigger()

bool CheckTriggerMatching()

bool IsMatchedObject(const xAOD::IParticle *p, const std::string &Trig) const

bool CheckTrigger(const std::string &trigger_name)

StatusCode SaveObjectMatching(ParticleStorage *Storage, xAOD::Type::ObjectType Type)

xAOD::ElectronContainer *CalibElectrons() const

xAOD::MuonContainer *CalibMuons() const

xAOD::PhotonContainer *CalibPhotons() const

xAOD::TauJetContainer *CalibTaus() const

std::vector<std::shared_ptr<TriggerInterface>> GetActiveTriggers() const

std::shared_ptr<TriggerInterface> GetActiveTrigger(const std::string &trig_name) const

std::vector<std::string> GetTriggerOR(const std::string &trig_string)

Protected Types

enum LinkStatus

Values:

Created

Loaded

Failed

Protected Functions

bool isData() const

StatusCode MetTriggerEmulation()

StatusCode GetHLTMet(float &met, const std::string &containerName, bool &doContainer)

StatusCode FillTriggerVector(std::vector<std::string> &triggers_vector)

template <typename TriggerContainer>
SUSYTriggerTool::LinkStatus CreateContainerLinks(const std::string &key, TriggerContainer *&container)

template <typename Container>
StatusCode ViewElementsContainer(const std::string &Key, Container *&Cont)

template <typename T>
ToolHandle<T> GetCPTool(const std::string &name)

ST::SUSYObjDef_xAOD *SUSYToolsPtr()

Protected Attributes

XAMPP::EventInfo *m_XAMPPInfo

asg::AnaToolHandle<ST::ISUSYObjDef_xAODTool> m_susytools

ToolHandle<Trig::TrigDecisionTool> m_trigDecTool

ToolHandle<Trig::IMatchingTool> m_trigMatchTool

ToolHandle<XAMPP::IElectronSelector> m_elec_selection

ToolHandle<XAMPP::IMuonSelector> m_muon_selection

ToolHandle<XAMPP::IPhotonSelector> m_phot_selection

ToolHandle<XAMPP::ITauSelector> m_tau_selection

std::vector<std::shared_ptr<TriggerInterface>> m_triggers

std::vector<std::shared_ptr<FiredObjectTrigger>> m_obj_trig

std::vector<std::string> m_trigger_names

bool m_init

bool m_Pass

bool m_NoCut

bool m_EmptyTriggerList

bool m_StoreObjectMatching

If this flag is turned into true. The information whether the triggers are dR matched are saved to the n-tuples if the SaveObjectMatching(ParticleStorage* Storage, xAOD::Type::ObjectType Type) method is called during initializeEventVariables() in SUSYAnalysisHelper

bool m_StoreFullTriggerInfo

bool m_StorePreScaling

bool m_MetTrigEmulation

bool m_doLVL1Met

bool m_doCellMet

bool m_doMhtMet

bool m_doTopoClMet

bool m_doTopoClPufitMet

bool m_doTopoClPuetaMet

bool m_doMetTriggerPassed

If each of the flag is turned into true then two dedicated branches are written to the n-tuple indicating whether any of e.g. electron trigger has fired in this round. Please be aware that only the triggers on the list are considered. If you like to use the lowest unprescaled trigger only please use the constrainToPeriods method inside your JobOptions…

bool m_doSingleElectronTriggerPassed

bool m_doSingleMuonTriggerPassed

bool m_doSinglePhotonTriggerPassed

XAMPP::Storage<char> *m_DecTrigger

XAMPP::Storage<char> *m_DecMatching

XAMPP::Storage<char> *m_DecMetTrigger

bool m_useSignalElec

Flags to choose which container is going to be returned for the object matching of the triggers. If the flag is set to false then the baseline container is used instead

bool m_useSignalMuon

bool m_useSignalTau

bool m_useSignalPhot

Private Members

asg::AnaToolHandle<XAMPP::IEventInfo> m_XAMPPInfoHandle

ToolHandle<XAMPP::ISystematics> m_systematics

class SUSYTruthAnalysisHelper : public XAMPP::SUSYAnalysisHelper

#include <SUSYTruthAnalysisHelper.h>

Subclassed by XAMPP::MonoHTruthAnalysisHelper

Public Functions

SUSYTruthAnalysisHelper(const std::string &myname)

virtual ~SUSYTruthAnalysisHelper()

StatusCode LoadContainers()

StatusCode FillInitialObjects(const CP::SystematicSet *systset)

StatusCode FillObjects(const CP::SystematicSet *systset)

StatusCode RemoveOverlap()

virtual bool EventCleaning() const

virtual bool CheckTrigger()

StatusCode initialize()

Protected Functions

virtual StatusCode initializeAnalysisTools()

StatusCode initializeEventVariables()

StatusCode ComputeEventVariables()

StatusCode initializeObjectTools()

virtual StatusCode FillEventWeights()

bool PassObjectCleaning(const CP::SystematicSet *systset) const

class SUSYTruthSelector : public XAMPP::ParticleSelector, public virtual XAMPP::ITruthSelector

#include <SUSYTruthSelector.h>

Subclassed by XAMPP::MonoHTruthSelector

Public Functions

SUSYTruthSelector(const std::string &myname)

virtual ~SUSYTruthSelector()

int GetInitialState()

StatusCode initialize()

StatusCode LoadContainers()

StatusCode InitialFill(const CP::SystematicSet &systset)

StatusCode FillTruth(const CP::SystematicSet &systset)

bool isTrueTop(const xAOD::TruthParticle *particle)

bool isTrueW(const xAOD::TruthParticle *particle)

bool isTrueZ(const xAOD::TruthParticle *particle)

bool isTrueSUSY(const xAOD::TruthParticle *particle)

bool isTrueTau(const xAOD::TruthParticle *particle)

int classifyWDecays(const xAOD::TruthParticle *particle)

virtual xAOD::TruthParticleContainer *GetTruthPreElectrons() const

virtual xAOD::TruthParticleContainer *GetTruthBaselineElectrons() const

virtual xAOD::TruthParticleContainer *GetTruthSignalElectrons() const

virtual xAOD::TruthParticleContainer *GetTruthPreMuons() const

virtual xAOD::TruthParticleContainer *GetTruthBaselineMuons() const

virtual xAOD::TruthParticleContainer *GetTruthSignalMuons() const

virtual xAOD::TruthParticleContainer *GetTruthPrePhotons() const

virtual xAOD::TruthParticleContainer *GetTruthBaselinePhotons() const

virtual xAOD::TruthParticleContainer *GetTruthSignalPhotons() const

virtual xAOD::TruthParticleContainer *GetTruthPreTaus() const

virtual xAOD::TruthParticleContainer *GetTruthBaselineTaus() const

virtual xAOD::TruthParticleContainer *GetTruthSignalTaus() const

virtual xAOD::TruthParticleContainer *GetTruthNeutrinos() const

virtual xAOD::TruthParticleContainer *GetTruthPrimaryParticles() const

virtual xAOD::JetContainer *GetTruthPreJets() const

virtual xAOD::JetContainer *GetTruthBaselineJets() const

virtual xAOD::JetContainer *GetTruthSignalJets() const

virtual xAOD::JetContainer *GetTruthBJets() const

virtual xAOD::JetContainer *GetTruthLightJets() const

virtual xAOD::JetContainer *GetTruthFatJets() const

xAOD::JetContainer *GetTruthCustomJets(const std::string &kind) const

virtual xAOD::TruthParticleContainer *GetTruthParticles() const

virtual const xAOD::TruthParticleContainer *GetTruthInContainer() const

virtual xAOD::TruthParticleContainer *GetTruthBSM() const

virtual xAOD::TruthParticleContainer *GetTruthTop() const

virtual xAOD::TruthParticleContainer *GetTruthBottom() const

StatusCode ReclusterTruthJets(const xAOD::IParticleContainer *inputJets, float Rcone, float minPtKt4 = -1, std::string PreFix = "", float minPtRecl = -1, float rclus = -1, float ptfrac = -1)

virtual std::shared_ptr<TruthDecorations> GetTruthDecorations() const

void setupDecorations(std::shared_ptr<TruthDecorations> inptr = nullptr)

Protected Functions

bool isTRUTH3() const

bool PassBaselineKinematics(const xAOD::IParticle &P) const

bool PassSignalKinematics(const xAOD::IParticle &P) const

bool PassSignal(const xAOD::IParticle &P) const

bool PassBaseline(const xAOD::IParticle &P) const

bool PassPreSelection(const xAOD::IParticle &P) const

void InitDecorators(xAOD::TruthParticle *T, bool Pass = true)

void InitDecorators(const xAOD::Jet *J, bool Pass)

template <typename Cont>
void InitContainer(Cont *Input, Cont *PreSel)

bool IsGenParticle(const xAOD::TruthParticle *Truthpart) const

bool IsInitialStateParticle(const xAOD::TruthParticle *truth)

bool ConsiderParticle(xAOD::TruthParticle *particle)

bool IsBJet(const xAOD::IParticle *j)

void FillBaselineContainer(xAOD::TruthParticleContainer *Pre, xAOD::TruthParticleContainer *Baseline)

void FillSignalContainer(xAOD::TruthParticleContainer *Baseline, xAOD::TruthParticleContainer *Signal)

StatusCode FillTruthParticleContainer()

StatusCode RetrieveParticleContainer(xAOD::TruthParticleContainer *&Particles, bool FromStoreGate, const std::string &GateKey, const std::string &ViewElementsKey, bool linkOriginal = true)

void LoadDressedMomentum(xAOD::TruthParticle *Truth)

void LoadVisibleMomentum(xAOD::TruthParticle *Truth)

void DressVanillaMomentum(const xAOD::TruthParticle *Truth)

bool doTruthJets() const

bool doTruthParticles() const

std::string TauKey() const

std::string ElectronKey() const

std::string MuonKey() const

std::string PhotonKey() const

std::string NeutrinoKey() const

std::string BosonKey() const

std::string BSMKey() const

std::string TopKey() const

std::string BottomKey() const

std::string JetKey() const

void declare(ObjectDefinition &obj, const std::string &as)

StatusCode init(ObjectDefinition &obj, const std::string &as)

bool RequirePreselFromHardProc() const

bool RequireBaseFromHardProc() const

bool RequireSignalFromHardProc() const

bool RequirePreSelTauHad() const

bool RequireBaseTauHad() const

bool RequireSignalTauHad() const

bool RejectUnknownOrigin() const

Protected Attributes

const xAOD::JetContainer *m_xAODTruthJets

const xAOD::TruthParticleContainer *m_xAODTruthParticles

const xAOD::MissingETContainer *m_xAODTruthMet

const xAOD::TruthParticleContainer *m_xAODTruthBSM

const xAOD::TruthParticleContainer *m_xAODTruthBoson

const xAOD::TruthParticleContainer *m_xAODTruthTop

const xAOD::TruthParticleContainer *m_xAODTruthBottom

xAOD::TruthParticleContainer *m_InitialParticles

xAOD::JetContainer *m_InitialJets

xAOD::JetContainer *m_InitialFatJets

xAOD::TruthParticleContainer *m_InitialElectrons

xAOD::TruthParticleContainer *m_InitialMuons

xAOD::TruthParticleContainer *m_InitialPhotons

xAOD::TruthParticleContainer *m_InitialTaus

xAOD::TruthParticleContainer *m_InitialNeutrinos

xAOD::JetContainer *m_PreJets

xAOD::JetContainer *m_BaselineJets

xAOD::JetContainer *m_SignalJets

xAOD::JetContainer *m_BJets

xAOD::JetContainer *m_LightJets

xAOD::TruthParticleContainer *m_Particles

xAOD::TruthParticleContainer *m_PreElectrons

xAOD::TruthParticleContainer *m_BaselineElectrons

xAOD::TruthParticleContainer *m_SignalElectrons

xAOD::TruthParticleContainer *m_PreMuons

xAOD::TruthParticleContainer *m_BaselineMuons

xAOD::TruthParticleContainer *m_SignalMuons

xAOD::TruthParticleContainer *m_PrePhotons

xAOD::TruthParticleContainer *m_BaselinePhotons

xAOD::TruthParticleContainer *m_SignalPhotons

xAOD::TruthParticleContainer *m_PreTaus

xAOD::TruthParticleContainer *m_BaselineTaus

xAOD::TruthParticleContainer *m_SignalTaus

xAOD::TruthParticleContainer *m_Neutrinos

xAOD::TruthParticleContainer *m_BSMparticles

xAOD::TruthParticleContainer *m_Tops

xAOD::TruthParticleContainer *m_Bottoms

xAOD::TruthParticleContainer *m_InitialStatePart

std::shared_ptr<TruthDecorations> m_truthDecorations

Private Functions

bool BaselineKinematics(const xAOD::IParticle &P, const ObjectDefinition &obj) const

bool SignalKinematics(const xAOD::IParticle &P, const ObjectDefinition &obj) const

Private Members

ObjectDefinition m_MuonDefs

ObjectDefinition m_ElectronDefs

ObjectDefinition m_TauDefs

ObjectDefinition m_JetDefs

ObjectDefinition m_PhotonDefs

ObjectDefinition m_NeutrinoDefs

float m_BJetPtCut

float m_BJetEtaCut

bool m_RequirePreselFromHardProc

bool m_RequireBaseFromHardProc

bool m_RequireSignalFromHardProc

bool m_RequirePreSelTauHad

bool m_RequireBaseTauHad

bool m_RequireSignalTauHad

bool m_doTruthParticles

bool m_doTruthTop

bool m_doTruthBottom

bool m_doTruthBoson

bool m_doTruthSUSY

bool m_isTRUTH3

bool m_rejectUnknownOrigin

bool m_doSUSYProcess

std::string m_BosonKey

std::string m_BSMKey

std::string m_TopKey

std::string m_BottomKey

bool m_useVisTauP4

class SystematicContainer

#include <EventStorage.h>

Public Functions

SystematicContainer(const DataVectorStorage *store, const CP::SystematicSet *set)

void setContainer(xAOD::IParticleContainer *container)

void setContainer(DataVector<SG::AuxElement> *container)

xAOD::IParticleContainer *particleContainer() const

DataVector<SG::AuxElement> *auxElementContainer() const

const CP::SystematicSet *systematic() const

bool isContainerValid() const

void createAuxElementsContainer()

Private Members

const DataVectorStorage *m_refStore

const CP::SystematicSet *m_set

xAOD::IParticleContainer *m_particle_container

DataVector<SG::AuxElement> *m_sg_container

std::unique_ptr<DataVector<SG::AuxElement>> m_converted_container

unsigned long long m_lastSet

class SystematicEnvelope

#include <FinalPlotHelpers.h>

Helper class to define a group of systematics which are summarized in a single systematic envelope, i.e. taking the maximum deviation from the nominal histogram

Subclassed by XAMPP::SystematicGroup

Public Types

enum VariationSite

Values:

UpOnly = 1 << 0

DownOnly = 1 << 1

Any = UpOnly | DownOnly

Public Functions

SystematicEnvelope(const std::string &pattern, const std::string &env_name)

SystematicEnvelope(const SystematicEnvelope&)

void operator=(const SystematicEnvelope&)

bool consider_in_envelope(const std::string &systematic) const

std::shared_ptr<TH1> calculate_syst(std::map<std::string, std::shared_ptr<TH1>> &syst_map, std::shared_ptr<TH1> nominal) const

Picks up all affecting systematics from the map and calculates the envelope from it. Picked entries are removed from the map.

std::string get_pattern() const

Pattern what the systematics have to satisfy in order to be considered.

std::string name() const

Name of the envelope group. If no name is defined in the constructor the pattern is returned.

void append_systematic(const std::string &syst)

void Print() const

void apply_only_to(unsigned int direction)

unsigned int application_mask() const

bool add_to_up() const

bool add_to_down() const

Protected Functions

void add_up(unsigned int bin, double diff, std::shared_ptr<TH1> syst) const

Private Members

std::string m_pattern

std::string m_name

std::vector<std::string> m_syst

unsigned int m_site

class SystematicGroup : public XAMPP::SystematicEnvelope

#include <EventStorage.h>

Systematic groups are the managing classes to organize branches into groups by affecting systematics. The systematic group has an arbitrary name, the Selection object is belongs to and finally the SystematicsTool connected

Public Functions

SystematicGroup(const std::string &name, XAMPP::SelectionObject obj, const ToolHandle<ISystematics> &syst_tool)

std::string name() const

bool isAffectedBySyst(const CP::SystematicSet *syst) const

SystematicGroup(const std::string &pattern, const std::string &env_name, unsigned int s)

Protected Functions

void add_up(unsigned int bin, double diff, std::shared_ptr<TH1> syst) const

Private Members

std::string m_name

XAMPP::SelectionObject m_obj

ToolHandle<ISystematics> m_systematics

class SystematicPairer

#include <FinalPlotHelpers.h>

Public Functions

void append_systematic(const std::string &name)

void exclude_systematic(const std::string &syst)

void do_systematics(bool B)

bool create_envelope(const std::string &grp_pattern, const std::string &env_name = "")

bool create_group(const std::string &grp_pattern, const std::string &grp_name, unsigned int sel_only = SystematicGroup::Any)

bool pair_systematics(const std::string &down, const std::string &up)

bool is_systematic_known(const std::string &syst) const

bool is_systematic_excluded(const std::string &syst) const

bool is_systematic_up(const std::string &syst) const

bool is_systematic_down(const std::string &syst) const

bool is_systematic_envelope(const std::string &syst) const

bool do_systematics() const

std::string get_paired(const std::string &syst) const

std::vector<SystematicEnvelope_Ptr> get_envelopes() const

SystematicEnvelope_Ptr find_envelope(const std::string &grp_name) const

const std::vector<std::string> &get_systematics() const

~SystematicPairer()

void Print() const

std::string get_syst_title(const std::string &syst_name) const

void set_systematic_title(const std::string &syst_name, const std::string &syst_title)

Public Static Functions

SystematicPairer *getInstance()

const std::vector<std::string> &up_variation_endings()

const std::vector<std::string> &down_variation_endings()

Private Types

typedef std::pair<std::string, std::string> VariationPair

Private Functions

SystematicPairer()

SystematicPairer(const SystematicPairer&)

void operator=(const SystematicPairer&)

Private Members

std::vector<std::string> m_known_syst

std::vector<std::string> m_excluded_syst

std::vector<VariationPair> m_paired_syst

std::vector<SystematicEnvelope_Ptr> m_envelope_grps

std::vector<size_t> m_syst_up_hashes

std::vector<size_t> m_syst_dn_hashes

std::map<std::string, std::string> m_syst_titles

bool m_doSyst

Private Static Attributes

SystematicPairer *m_Inst = nullptr

class SystematicPairHistos

#include <SampleHisto.h>

Helper class to return single systematics from the sample histo.

Public Functions

SystematicPairHistos(SampleHisto *ref_histo, SystematicEnvelope_Ptr grp, std::shared_ptr<TH1> env)

SystematicPairHistos(SampleHisto *ref_histo, const std::string &sys_name, std::shared_ptr<TH1> sym)

SystematicPairHistos(SampleHisto *ref_histo, const std::string &sys_name, std::shared_ptr<TH1> dn, std::shared_ptr<TH1> up)

bool is_symmetric() const

bool is_envelope() const

std::shared_ptr<TH1> up_histo() const

Histograms having the deltas w.r.t. nominal Each bin is strictly below or above the nominal

std::shared_ptr<TH1> dn_histo() const

std::shared_ptr<TH1> final_up_histo() const

histograms having the variance w.r.t nominal applied. No statistical errors are included

std::shared_ptr<TH1> final_dn_histo() const

std::string name() const

double total_up_dev()

double total_dn_dev()

void Scale(double s)

Private Functions

void cache_total_deviation()

Private Members

std::string m_name

std::shared_ptr<TH1> m_dn

std::shared_ptr<TH1> m_up

const std::shared_ptr<TH1> m_nominal

std::shared_ptr<TH1> m_nom_up

std::shared_ptr<TH1> m_nom_dn

bool m_symmetric

bool m_envelope

double m_tot_up_dev

Variables to cache the total deviation from nominal histogram

double m_tot_dn_dev

bool m_dev_cached

class TauDecorations : public XAMPP::ParticleDecorations

#include <TauDecorations.h>

Public Functions

TauDecorations()

void populateDefaults(SG::AuxElement &ipart)

Public Members

Decoration<int> truthType

Decoration<int> truthOrigin

Decoration<int> numTracks

Decoration<char> passBaselineID

Decoration<char> passSignalID

Decoration<int> partonTruthLabelID

Decoration<int> coneTruthLabelID

Decoration<int> tauTruthType

class TauTriggerSFHandler : public XAMPP::TauWeightDecorator

#include <SUSYTauSelector.h>

Public Functions

TauTriggerSFHandler(const std::string &Trigger, const ToolHandle<ITriggerTool> &TriggerTool, TauEffiToolHandle &TriggerSF)

StatusCode initialize()

~TauTriggerSFHandler()

void requireMatching(bool B = true)

Protected Functions

StatusCode calculateSF(const xAOD::TauJet &Tau, double &SF)

Private Functions

bool RetrieveMatchers(const std::string &Trigger)

bool IsTriggerMachted(const xAOD::TauJet &Tau) const

Private Members

std::string m_TrigStr

TauEffiToolHandle m_TriggerSFTool

ToolHandle<ITriggerTool> m_trigger_tool

std::vector<std::shared_ptr<TriggerInterface>> m_Triggers

bool m_requireMatching

class TauWeight : public XAMPP::TauWeightDecorator

#include <SUSYTauSelector.h>

Public Functions

TauWeight(TauEffiToolHandle &SFTool)

~TauWeight()

Protected Functions

StatusCode calculateSF(const xAOD::TauJet &Tau, double &SF)

Private Members

TauEffiToolHandle m_SFTool

class TauWeightDecorator : public XAMPP::IParticleWeightDecorator

#include <SUSYTauSelector.h>

Subclassed by XAMPP::TauTriggerSFHandler, XAMPP::TauWeight, XAMPP::TauWeightHandler

Public Functions

TauWeightDecorator()

~TauWeightDecorator()

StatusCode initialize()

StatusCode saveSF(const xAOD::TauJet &Tau, bool isSignal)

Protected Functions

virtual StatusCode calculateSF(const xAOD::TauJet &Tau, double &SF) = 0

class TauWeightHandler : public XAMPP::TauWeightDecorator

#include <SUSYTauSelector.h>

Public Functions

TauWeightHandler(const CP::SystematicSet *syst_set)

const CP::SystematicSet *systematic() const

size_t nWeights() const

void multipleTriggerSF(bool B = true)

StatusCode saveSF(const xAOD::TauJet &Tau, bool isSignal)

StatusCode applySF()

bool append(const TauWeightMap &map, const CP::SystematicSet *nominal)

bool setSignalTriggerSF(const TauWeight_VectorMap &map, const CP::SystematicSet *nominal)

Protected Functions

StatusCode calculateSF(const xAOD::TauJet &Tau, double &SF)

Private Members

const CP::SystematicSet *m_Syst

std::vector<TauWeight_Ptr> m_Weights

bool m_init

TauWeight_Vector m_signal_trig_SF

bool m_multiple_trig_sf

class TensorCombination

#include <ReconstructedParticleReaders.h>

Public Functions

const TLorentzVector &P4() const

size_t first_idx() const

size_t second_idx() const

TensorCombination(CombinedParticleReader *ref, size_t i, size_t j)

Private Members

TLorentzVector m_p4

size_t m_first

size_t m_second

class TF1LookUp : public XAMPP::IExternalLookUpTable

#include <DataDrivenWeights.h>

Public Functions

TF1LookUp()

TF1LookUp(const TF1LookUp &other)

virtual ~TF1LookUp()

double read(const double x) const

double read(const double x, const double y) const

double read(const double x, const double y, const double z) const

bool isOverFlow(const double x) const

bool isOverFlow(const double x, const double y) const

bool isOverFlow(const double x, const double y, const double z) const

std::shared_ptr<IExternalLookUpTable> clone() const

bool applyUncertainty(double w)

Private Members

std::unique_ptr<TF1> m_Func

class TH1LookUp : public XAMPP::IExternalLookUpTable

#include <DataDrivenWeights.h>

Public Functions

TH1LookUp()

TH1LookUp(const TH1LookUp &other)

virtual ~TH1LookUp()

bool LoadHistogramFromFile(std::stringstream &sstr)

bool LoadHistogramFromFile(const std::string &file, const std::string &histo_path)

bool SetHisto(TH1 *H)

double read(const double x) const

double read(const double x, const double y) const

double read(const double x, const double y, const double z) const

bool isOverFlow(const double x) const

bool isOverFlow(const double x, const double y) const

bool isOverFlow(const double x, const double y, const double z) const

std::shared_ptr<IExternalLookUpTable> clone() const

bool applyUncertainty(double w)

unsigned int dimension() const

TH1 *histo() const

TAxis *axis(unsigned int d) const

Private Functions

bool isOverFlow(TAxis *axis, const int Bin) const

Private Members

std::unique_ptr<TH1> m_Histo

template <class T>
class ToolHandleSystematics : public virtual XAMPP::ISystematicToolService

#include <ToolHandleSystematics.h>

Public Functions

StatusCode resetSystematic()

StatusCode setSystematic(const CP::SystematicSet *Set)

StatusCode initialize()

StatusCode initTool()

std::string name() const

template <typename P>
StatusCode setProperty(const std::string &Property, P Value)

ToolHandleSystematics(T *Pointer, XAMPP::SelectionObject Kine = XAMPP::SelectionObject::Other, XAMPP::SelectionObject Weight = XAMPP::SelectionObject::Other)

ToolHandleSystematics(T *Pointer, const std::string &SystTool, XAMPP::SelectionObject Kine = XAMPP::SelectionObject::Other, XAMPP::SelectionObject Weight = XAMPP::SelectionObject::Other)

ToolHandleSystematics(ToolHandle<T> Handle, const std::string &SystTool, XAMPP::SelectionObject Kine = XAMPP::SelectionObject::Other, XAMPP::SelectionObject Weight = XAMPP::SelectionObject::Other)

ToolHandleSystematics(ToolHandle<T> Handle, XAMPP::SelectionObject Kine = XAMPP::SelectionObject::Other, XAMPP::SelectionObject Weight = XAMPP::SelectionObject::Other)

ToolHandleSystematics(asg::AnaToolHandle<T> &AnaHandle, const std::string &SystTool, XAMPP::SelectionObject Kine = XAMPP::SelectionObject::Other, XAMPP::SelectionObject Weight = XAMPP::SelectionObject::Other)

ToolHandleSystematics(asg::AnaToolHandle<T> &AnaHandle, XAMPP::SelectionObject Kine = XAMPP::SelectionObject::Other, XAMPP::SelectionObject Weight = XAMPP::SelectionObject::Other)

~ToolHandleSystematics()

Private Members

T *m_pointer

asg::AnaToolHandle<T> m_anaHandle

ToolHandle<T> m_handle

ToolHandle<ISystematics> m_systematics

XAMPP::SelectionObject m_affectKine

XAMPP::SelectionObject m_affectWeight

class TransverseMassReader : public XAMPP::ParticleCorrelationReader

#include <ObservableReader.h>

Public Functions

std::string name() const

virtual ~TransverseMassReader()

Public Static Functions

ParticleCorrelationReader *GetReader(const std::string &FirstParticle, const std::string &SecondParticle)

Protected Functions

TransverseMassReader(const std::string &FirstParticle, const std::string &SecondParticle)

TransverseMassReader(const TransverseMassReader&)

void operator=(const TransverseMassReader&)

class TreeBase

#include <TreeBase.h>

Public Functions

TreeBase(const CP::SystematicSet *set)

TreeBase(const CP::SystematicSet *set, std::shared_ptr<SystematicGroup> grp)

~TreeBase()

StatusCode InitializeTree()

StatusCode FillTree()

StatusCode FinalizeTree()

void SetHistService(ServiceHandle<ITHistSvc> &Handle)

void SetEventInfoHandler(const XAMPP::EventInfo *Info)

void SetSystematicsTool(const ToolHandle<XAMPP::ISystematics> &Syst)

void SetAnalysisConfig(const ToolHandle<XAMPP::IAnalysisConfig> &config)

void SetListOfFriends(const std::vector<std::shared_ptr<TreeBase>> &friends)

void AddFriend(std::shared_ptr<TreeBase> tree_base)

TTree *Tree() const

const CP::SystematicSet *systematic() const

std::shared_ptr<SystematicGroup> getSystematicGroup() const

bool isInitialized() const

std::string tree_name() const

Protected Functions

void CreateBranches()

template <typename T>
void CreateEventBranches()

Private Functions

bool addVariable(IStorage *store) const

Private Members

const CP::SystematicSet *m_set

std::shared_ptr<SystematicGroup> m_syst_group

const XAMPP::EventInfo *m_XAMPPInfo

const XAMPP::ISystematics *m_systematics

const XAMPP::IAnalysisConfig *m_config

std::unique_ptr<TTree> m_tree

TDirectory *m_directory

bool m_init

bool m_isWritten

ServiceHandle<ITHistSvc> m_histSvc

std::vector<std::shared_ptr<TreeBase>> m_friend_trees

Friend trees rely on.

std::vector<std::shared_ptr<XAMPP::ITreeBranchVariable>> m_Branches

int m_mcChannelNumber

ULong64_t m_eventId[2]

template <class T>
class TreeBranch : public XAMPP::TreeHelper, public virtual XAMPP::ITreeBranchVariable

#include <TreeHelpers.h>

Public Functions

TreeBranch(TTree *tree, const std::string &name)

bool Init()

std::string name() const

bool Fill()

virtual ~TreeBranch()

void setValue(const T &Value)

Private Members

std::string m_name

T m_Var

bool m_isUpdated

template <class T>
class TreeDataVectorAccessor : public XAMPP::ITreeDataVectorAccessor

#include <TreeHelpers.h>

Public Functions

TreeDataVectorAccessor(DataVectorStorage *store, TreeBase *tree, const std::string &b_name, const std::string &accessor_name)

bool PushBack(const SG::AuxElement *element, bool Resize, size_t Reserve)

void Clear(size_t Reserve = 0)

bool Init()

Private Members

std::vector<T> m_Vector

SG::AuxElement::Accessor<T> m_Acc

class TreeHelper

#include <TreeHelpers.h>

Subclassed by XAMPP::EventBranchVariable< T >, XAMPP::ITreeContainerAccessor, XAMPP::TreeBranch< T >, XAMPP::TreeHelperMet

Public Functions

virtual ~TreeHelper()

Protected Functions

TreeHelper(TTree *tree)

template <typename T>
bool AddBranch(const std::string &Name, T &Element)

Private Functions

std::string branch_name(const std::string &b_name) const

Private Members

TTree *m_tree

class TreeHelperMet : public XAMPP::TreeHelper, public virtual XAMPP::ITreeBranchVariable

#include <TreeHelpers.h>

Public Functions

TreeHelperMet(XAMPP::Storage<XAMPPmet> *met, TTree *tree)

bool Init()

std::string name() const

bool Fill()

Protected Attributes

XAMPP::Storage<XAMPPmet> *m_store

float m_met

float m_phi

float m_sumet

class TreeIndexer

#include <EventService.h>

Public Functions

Long64_t currentEvent()

Long64_t entries() const

const ULong64_t &eventNumber() const

const ULong64_t &eventHash() const

TTree *tree() const

TTree *synchronization_tree() const

void sync_indexer()

bool init()

bool getEntry(Long64_t entry)

TreeIndexer(TTree *tree)

TreeIndexer(TFriendElement *tree, TreeIndexer *parent)

Public Static Functions

void buildCommonHash(bool B)

Private Functions

bool is_syncronized() const

Private Members

TTree *m_tree_to_sync

std::shared_ptr<TFile> m_in_file

TTree *m_tree

TBranch *m_hash_branch

TreeIndexer *m_parent

ULong64_t m_eventHash[2]

Long64_t m_event

Long64_t m_evInTree

EventService *m_service

bool m_learningPhase

Private Static Attributes

bool m_buildCommonHash = false

class TreeSystematic : public XAMPP::IKinematicSyst

#include <Analysis.h>

Public Functions

std::string syst_name() const

std::string tree_name() const

bool is_nominal() const

bool apply_syst()

void reset()

TreeSystematic(const std::string &tree_name, bool is_nominal = false)

Private Members

std::string m_tree_name

bool m_is_nominal

class TriggerInterface

#include <SUSYTriggerTool.h>

Public Functions

TriggerInterface(const std::string &Name, SUSYTriggerTool *TriggerTool)

virtual ~TriggerInterface()

StatusCode initialize(XAMPP::EventInfo *Info)

std::string name() const

std::string MatchStoreName() const

std::string StoreName() const

void NewEvent()

The newEvent evaluates if the trigger has fired.

bool PassTrigger() const

bool PassTriggerMatching()

Evaluates the trigger matching 1) Objects are matched via dR matching 2) pt_threshold is then checked 3) Count how many object pass the particular thresholds 4) -> compare against matching requirement

bool NeedsTriggerMatching() const

Checks whether the trigger also requires some matching either to electrons muons or photons

bool NeedsElectronMatching() const

Electron trigger matching is enabled if _eXX or _2eXX is found in the name.

bool NeedsMuonMatching() const

Checks whether the trigger is a muon trigger and requires matching to them.

bool NeedsTauMatching() const

Trigger matching for taus.

bool NeedsPhotonMatching() const

Finally the photon trigger matching is as well supported.

std::string PrintMatchingThresholds() const

Prints the extracted pt thresholds of the trigger foreach object.

bool isMatchingDone(const xAOD::IParticle *P) const

Checks whether the matching is done on a particle the information is recieved and stored to the original xAOD::IParticle

bool isMatchingDone(const xAOD::IParticle &P) const

bool isMatched_dR(const xAOD::IParticle *P) const

Checks whether a particle is matched to the trigger in terms of the ordinary dR matching where no requirement is applied on the pt of the particle

bool isMatched_dR(const xAOD::IParticle &P) const

bool isMatched(const xAOD::IParticle *P) const

Checks whether the object is really matched to the trigger with applying the full matching chain.

bool isMatched(const xAOD::IParticle &P) const

StatusCode addTriggerPeriod(unsigned int begin, unsigned int end)

int num_toMatch() const

int num_toMatch(const XAMPP::SelectionObject obj) const

Public Static Functions

void SaveTriggerPrescaling(bool B)

void SaveFullTriggerInfo(bool B)

If this flag is true then the information whether the trigger has fired and is matched is written to the ntuple. In the other case only the latter is written out

void SaveObjectMatching(bool B)

if this is flag is true a dummy matching decision is always assigned to the particle container since the matching decision is going to be dumped into the n-tuples. If no trigger fired -> no matching -> usally bail out of the matching procedure

Private Types

typedef std::pair<std::string, xAOD::Type::ObjectType> StringObjectMatching

typedef std::vector<StringObjectMatching> ObjMatchVec

typedef std::pair<unsigned int, unsigned int> run_range

Private Functions

unsigned int MatchObjectsToTrigger(const xAOD::IParticleContainer *calibrated_obj)

bool isInPeriod() const

TriggerInterface::FinalStrObjMatching FindObjectInTriggerString(const std::string &TriggerString, const ObjMatchVec &Matching) const

void GetMatchingThresholds()

int ExtractPtThreshold(std::string &TriggerString, int &M, xAOD::Type::ObjectType &T)

bool AssignMatching(xAOD::Type::ObjectType T) const

Private Members

std::string m_name

SUSYTriggerTool *m_TriggerTool

XAMPP::EventInfo *m_XAMPPInfo

ToolHandle<Trig::TrigDecisionTool> m_trigDecTool

ToolHandle<Trig::IMatchingTool> m_trigMatchTool

XAMPP::Storage<char> *m_TriggerStore

XAMPP::Storage<char> *m_MatchingStore

XAMPP::Storage<float> *m_PreScalingStore

CharDecorator m_MatchingDecorator

CharAccessor m_MatchingAccessor

BoolDecorator m_dec_isMatchingDone

BoolAccessor m_acc_isMatchingDone

bool m_MatchEle

bool m_MatchMuo

bool m_MatchTau

bool m_MatchPho

std::vector<OfflineMatching> m_Thresholds

std::vector<run_range> m_periods

bool m_has_periods

Private Static Attributes

bool m_SavePrescaling = false

bool m_saveFullTrigInfo = true

bool m_SaveObjMatching = false

class TruthAnalysisConfig : public XAMPP::AnalysisConfig

#include <AnalysisConfig.h>

Subclassed by XAMPP::MonoHTruthAnalysisConfig

Public Functions

TruthAnalysisConfig(const std::string &Analysis = "Custom")

Protected Functions

StatusCode initializeStandardCuts()

StatusCode initializeCustomCuts()

class TruthDecorations : public XAMPP::ParticleDecorations

#include <TruthDecorations.h>

Public Types

enum p4LoadStatus

Values:

NothingLoaded = 0

Vanilla

Dressed

VisibleTauMom

Public Functions

TruthDecorations()

void populateDefaults(SG::AuxElement &ipart)

Public Members

Decoration<float> charge

Decoration<float> pt_orig

Decoration<float> eta_orig

Decoration<float> phi_orig

Decoration<float> m_orig

Decoration<float> pt_dressed

Decoration<float> eta_dressed

Decoration<float> phi_dressed

Decoration<float> e_dressed

Decoration<double> pt_visible

Decoration<double> eta_visible

Decoration<double> phi_visible

Decoration<double> m_visible

Decoration<char> loaded_p4

Decoration<char> IsHadronicTau

Decoration<int> truthType

Decoration<int> truthOrigin

Decoration<unsigned int> classifierParticleType

Decoration<unsigned int> classifierParticleOrigin

Decoration<ElementLink<xAOD::TruthParticleContainer>> originalTruthParticle

class UniqueEventCondition : public XAMPP::Condition

#include <Cuts.h>

Public Functions

UniqueEventCondition(const std::string &duplicated_list)

Standard constructor. Optionally a path to a txt file can be piped having the list of duplicated events stored. Such a file can be made with CheckDuplicatedEvents. Each event occuring twice in data is listed in a separate line having the format: <run> <event_number>

bool load_duplicated_list(const std::string &duplicated_list)

bool Pass() const

virtual bool PassScalar() const

virtual bool PassVector(size_t) const

virtual bool PassMatrix(size_t, size_t) const

std::string name() const

Private Functions

UniqueEventCondition::EventSeen *find_event(const unsigned int run, const unsigned long long event) const

Private Members

Weight *m_weighter

std::set<std::pair<unsigned int, unsigned long long>> m_known_ev

std::vector<std::shared_ptr<EventSeen>> m_ev_with_duplication

unsigned int m_ev_in_tree

Helper variables to check whether the event has changed size the last call.

bool m_ev_decision

class UnSortedDiParticleReader : public XAMPP::DiParticleReader

#include <ReconstructedParticleReaders.h>

Public Static Functions

DiParticleReader *GetReader(const std::string &Name, const std::string &First = "", const std::string &Second = "")

Protected Functions

UnSortedDiParticleReader(const std::string &Name, const std::string &First, const std::string &Second)

UnSortedDiParticleReader(const UnSortedDiParticleReader&)

void operator=(const UnSortedDiParticleReader&)

void OrderParticleStreams()

class VectorColumnSizeReader : public XAMPP::IVectorReader

#include <UtilityReader.h>

Public Functions

std::string name() const

bool init(TTree *t)

double readEntry(const size_t I) const

size_t entries() const

Public Static Functions

ITreeVectorReader *GetReader(ITreeMatrixReader *Reader)

Protected Functions

VectorColumnSizeReader(ITreeMatrixReader *Variable)

VectorColumnSizeReader(const VectorColumnSizeReader&)

void operator=(const VectorColumnSizeReader&)

Private Members

ITreeMatrixReader *m_Var

bool m_Registered

EventService *m_service

Long64_t m_EventNumber

std::vector<size_t> m_Cache

class VectorNthEntryReader : public XAMPP::IScalarReader

#include <UtilityReader.h>

Public Functions

double read() const

size_t entries() const

bool update()

bool init(TTree *t)

std::string name() const

Public Static Functions

ITreeVarReader *GetReader(ITreeVectorReader *Vector, size_t Entry = -1)

Protected Functions

VectorNthEntryReader(ITreeVectorReader *Vector, size_t Entry)

VectorNthEntryReader(const VectorNthEntryReader&)

void operator=(const VectorNthEntryReader&)

Private Members

ITreeVectorReader *m_Reader

size_t m_Entry

class VectorRangeReader : public XAMPP::IVectorReader

#include <UtilityReader.h>

Public Functions

double readEntry(size_t I) const

bool init(TTree *t)

std::string name() const

size_t entries() const

Public Static Functions

ITreeVectorReader *GetReader(ITreeVectorReader *Var, size_t begin, size_t end)

Protected Functions

VectorRangeReader(ITreeVectorReader *Variable, size_t begin, size_t end)

VectorRangeReader(const VectorRangeReader&)

void operator=(const VectorRangeReader&)

Private Members

ITreeVectorReader *m_Variable

size_t m_begin

size_t m_end

bool m_Registered

class VectorRowSizeReader : public XAMPP::IVectorReader

#include <UtilityReader.h>

Public Functions

std::string name() const

bool init(TTree *t)

double readEntry(const size_t I) const

size_t entries() const

Public Static Functions

ITreeVectorReader *GetReader(ITreeMatrixReader *Reader)

Protected Functions

VectorRowSizeReader(ITreeMatrixReader *Variable)

VectorRowSizeReader(const VectorRowSizeReader&)

void operator=(const VectorRowSizeReader&)

Private Members

ITreeMatrixReader *m_Var

bool m_Registered

class VectorSizeReader : public XAMPP::IScalarReader

#include <UtilityReader.h>

Public Functions

double read() const

bool init(TTree *t)

std::string name() const

Public Static Functions

ITreeVarReader *GetReader(ITreeVectorReader *Vector)

Protected Functions

VectorSizeReader(ITreeVectorReader *Vector)

VectorSizeReader(const VectorSizeReader&)

void operator=(const VectorSizeReader&)

Protected Attributes

ITreeVectorReader *m_Reader

template <class T>
class VectorTreeVarWriter : public XAMPP::ITreeVarWriter

#include <TreeVarWriter.h>

Public Functions

bool init(TTree *t)

bool fill()

Public Static Functions

VectorTreeVarWriter<T> *GetWriter(const std::string &varname, ITreeVarReader *R = nullptr)

Private Functions

VectorTreeVarWriter(const std::string &Name, ITreeVarReader *R)

VectorTreeVarWriter(const VectorTreeVarWriter&)

void operator=(const VectorTreeVarWriter&)

Private Members

std::vector<T> m_Var

template <class T>
class VectorVarReader : public XAMPP::IVectorReader

#include <TreeVarReader.h>

Subclassed by XAMPP::VectorVarReaderGeV< T >

Public Functions

std::string name() const

size_t entries() const

bool init(TTree *t)

double readEntry(const size_t I) const

virtual ~VectorVarReader()

const std::vector<T> &get() const

Public Static Functions

VectorVarReader<T> *GetReader(const std::string &varname)

Protected Functions

VectorVarReader(const std::string &varname)

VectorVarReader(const VectorVarReader&)

void operator=(const VectorVarReader&)

Private Members

bool m_Registered

Long64_t m_lastEvent

unsigned int m_TreeNumber

TBranch *m_branch

EventService *m_evService

TreeIndexer *m_indexer

std::string m_var_name

std::vector<T> *m_var

template <class T>
class VectorVarReaderGeV : public XAMPP::VectorVarReader<T>

#include <TreeVarReader.h>

Public Functions

double readEntry(const size_t I) const

virtual ~VectorVarReaderGeV()

Public Static Functions

VectorVarReaderGeV<T> *GetReader(const std::string &varname)

Protected Functions

VectorVarReaderGeV(const std::string &varname)

VectorVarReaderGeV(const VectorVarReaderGeV&)

void operator=(const VectorVarReaderGeV&)

class Weight

#include <Weight.h>

Public Types

enum LHENormalization

LHE weights are there to evaluate the uncertainties on the theory parameters like the renormalization or the factorization scale or the choice of the PDF set. Each of the variation comes a long with its own sum of weights saved in the XAMPP metaData tree with processIDs beyond the 1k There are two different ways to handle the uncertainties 1) Evaluate the effect of the LHE uncertainties on the acceptance only (DEFAULT). Each of the LHE variations is normalized to its respective sum of weights. This approach is usually taken if the value of the cross-section is taken from external calculations. 2) Evaluate the combined effect of the LHE uncertainties on the cross-section and the cross-section: Each LHE variation is normalized w.r.t. the nominal sum of weights

Values:

AcceptanceOnly = 0

CrossSectionAndAcceptance

Public Functions

bool isData() const

unsigned int eventNumber() const

unsigned int runNumber() const

int mcChannelNumber() const

int SUSYFinalState() const

int processID() const

void NewEvent()

bool init(TTree *tree)

bool InitWeights()

double GetWeight() const

double GetWeightSquared() const

void UseWeights(const std::vector<std::string> &W_Names)

void UseDataWeights(const std::vector<std::string> &W_Names)

const std::vector<std::string> &WeightNames() const

const std::vector<std::string> &DataWeightNames() const

const std::vector<IWeightElement *> &GetUsedWeighters() const

void SetLumi(double Lumi)

xAOD::EventInfo *GetInfo() const

void SetupEventInfo(bool B = true)

void ApplyXSection(bool B = true)

bool applyXSection() const

void NormProcesses(bool B = true)

bool normToProdProcess() const

int LHEnormMode() const

void setLHEnormMode(LHENormalization N)

void ApplyPRW(bool B = true)

Application of the pile up weight.

bool applyPRW() const

std::vector<std::string> FindWeightVariations(TTree *T)

bool ApplySystematic(const std::string &Syst)

void ResetSystematic()

bool RegisterWeightElement(IWeightElement *W)

bool RegisterWeightElement(std::shared_ptr<IWeightElement> W)

IWeightElement *GetWeightElement(const std::string &Element) const

void excludeSystematic(const std::string &Syst)

void excludeSystematic(const std::vector<std::string> &Syst)

const std::vector<std::string> excludedSystematics() const

~Weight()

Public Static Functions

Weight *getWeighter(bool isData = false)

Protected Functions

Weight(bool isData = false)

Weight(const Weight&)

void operator=(const Weight&)

void AppendWeight(IWeightElement *R)

Protected Static Attributes

Weight *m_DB = nullptr

Private Functions

bool IsWeightAlreadyUsed(IWeightElement *R) const

void LoadWeightElements(std::vector<std::string> &Weights)

void UpdateEventInfo()

Private Members

bool m_isData

bool m_ApplyXS

bool m_UpdateXsec

bool m_UseSUSYstates

bool m_CreateInfo

bool m_ApplyPRW

double m_weight

double m_weight2

XAMPP::NormalizationDataBase *m_MetaData

std::map<std::string, std::shared_ptr<IWeightElement>> m_RegisteredWeighters

ScalarVarReader<int> *m_MCchannel

ScalarVarReader<int> *m_FinalState

std::vector<IWeightElement *> m_WeightReader

std::vector<std::string> m_UseWeights

std::vector<std::string> m_UseDataWeights

std::vector<std::string> m_excludedSystematics

xAOD::EventInfo *m_eventInfo

std::unique_ptr<xAOD::EventInfoAuxContainer> m_eventInfoAux

std::unique_ptr<xAOD::EventInfoContainer> m_eventInfoCont

ScalarVarReader<float> *m_mu_actual_reader

ScalarVarReader<float> *m_mu_reader

ScalarVarReader<unsigned int> *m_RunNumber

ScalarVarReader<unsigned int> *m_LumiBlock

ScalarVarReader<unsigned long long> *m_evNumber

NormalizationWeight *m_GenWeight

unsigned int m_EventNumber

LHENormalization m_LHENorm

class WeightElementFromTree : public XAMPP::IWeightElement

#include <Weight.h>

Subclassed by XAMPP::FloatWeightFromTree

Public Functions

bool init(TTree *tree)

double read()

std::vector<std::string> FindWeightVariations(TTree *Tree)

IWeightElement::SystStatus ApplySystematic(const std::string &variation)

void ResetSystematic()

std::string name() const

ITreeVarReader *GetTreeVarReader()

ITreeVarReader *GetSystematicReader(const std::string &Syst)

std::vector<std::string> GetWeightVariations()

~WeightElementFromTree()

Public Static Functions

WeightElementFromTree *GetWeighter(const std::string &Name)

Protected Functions

WeightElementFromTree(const std::string &Weight)

WeightElementFromTree()

WeightElementFromTree(const WeightElementFromTree&)

void operator=(const WeightElementFromTree&)

ITreeVarReader *LoadReader(const std::string &syst = "")

Protected Attributes

std::string m_Name

ITreeVarReader *m_Weighter

std::vector<std::string> m_Systematics

bool m_init

bool m_Registered

EventService *m_eventService

class WeightSystematic : public XAMPP::IKinematicSyst

#include <Weight.h>

Public Functions

WeightSystematic(const std::string &syst)

std::string syst_name() const

std::string tree_name() const

bool is_nominal() const

bool apply_syst()

void reset()

Private Members

std::string m_syst_name

Weight *m_weighter

EventService *m_service

class XAMPPMetCutElement : public XAMPP::ICutElement

#include <Cuts.h>

Public Functions

bool ApplyCut(bool ForCutFlow = false) const

bool initialize(float Value, Cut::Relation R, bool IsSkimmingCut)

XAMPPMetCutElement(XAMPP::Storage<XAMPPmet> *Store, XAMPP::IEventInfo *XAMPPInfo)

Protected Types

typedef bool (XAMPPMetCutElement::*Application)() const

Protected Functions

float GetMet() const

bool PassGreaterThan() const

bool PassGreaterEqual() const

bool PassEqual() const

bool PassLessThan() const

bool PassLessEqual() const

Protected Attributes

XAMPP::Storage<XAMPPmet> *m_MetStore

float m_CutValue

bool m_CutSkims

Application m_Relation

namespace CP

namespace ST

namespace SUSY

namespace TauAnalysisTools

namespace Trig

namespace XAMPP

Here we define additional decorations which are defined in case of electrons. These extend the set defined in the ParticleDecorations class.

Here we define additional decorations which are defined in case of jets. These extend the set defined in the ParticleDecorations class.

Here we define additional decorations which are defined in case of muons. These extend the set defined in the ParticleDecorations class.

This defines the decorations we can expect to find in every particle within the XAMPP framework. They mainly represent abstract stages in the object selection. This is then extended in the specific classes for each particle type, and optionally within the analysis specific code.

The hierarchy assumed here is: Preselection (WP, kinematics,…) | // via overlap removal V Baseline | // via more signal cuts V Signal | // via isolation cuts V Isolated

Here we define additional decorations which are defined in case of photons. These extend the set defined in the ParticleDecorations class.

Here we define additional decorations which are defined in case of truth particles. These extend the set defined in the ParticleDecorations class.

Typedefs

typedef std::vector<Cut *> CutRow

typedef xAOD::MissingET *XAMPPmet

typedef double (IParticle::*Momentum)() const

typedef SG::AuxElement::Accessor<char> CharAccessor

typedef SG::AuxElement::Decorator<char> CharDecorator

typedef std::unique_ptr<CharAccessor> SelectionAccessor

typedef std::unique_ptr<CharDecorator> SelectionDecorator

typedef SG::AuxElement::Accessor<float> FloatAccessor

typedef SG::AuxElement::Decorator<float> FloatDecorator

typedef SG::AuxElement::Accessor<double> DoubleAccessor

typedef SG::AuxElement::Decorator<double> DoubleDecorator

typedef SG::AuxElement::Accessor<int> IntAccessor

typedef SG::AuxElement::Decorator<int> IntDecorator

typedef SG::AuxElement::Accessor<unsigned int> UIntAccessor

typedef SG::AuxElement::Decorator<unsigned int> UIntDecorator

typedef SG::AuxElement::Accessor<bool> BoolAccessor

typedef SG::AuxElement::Decorator<bool> BoolDecorator

typedef std::vector<std::string> StringVector

typedef std::vector<float> FloatVector

typedef std::vector<int> IntVector

typedef std::vector<double> DoubleVector

typedef std::shared_ptr<IHistoVariable> IHistoVariable_Ptr

typedef ElementLink<xAOD::ElectronContainer> EleLink

typedef ElementLink<xAOD::MuonContainer> MuoLink

typedef ElementLink<xAOD::PhotonContainer> PhoLink

typedef ElementLink<xAOD::TauJetContainer> TauLink

typedef std::vector<EleLink> MatchedEl

typedef std::vector<MuoLink> MatchedMuo

typedef std::vector<PhoLink> MatchedPho

typedef std::vector<TauLink> MatchedTau

typedef std::shared_ptr<ElectronWeightDecorator> ElectronWeight_Ptr

Short the names of the types a bit.

typedef std::map<const CP::SystematicSet *, ElectronWeight_Ptr> ElectronWeightMap

typedef std::vector<ElectronWeight_Ptr> ElectronWeight_Vector

typedef std::map<const CP::SystematicSet *, ElectronWeight_Vector> ElectronWeight_VectorMap

typedef std::shared_ptr<ElectronWeightHandler> ElectronWeightHandler_Ptr

typedef IAsgElectronEfficiencyCorrectionTool EleEffTool

typedef ToolHandle<IAsgElectronEfficiencyCorrectionTool> EleEffToolHandle

typedef std::shared_ptr<BTagJetWeight> BTagJetWeight_Ptr

typedef std::map<const CP::SystematicSet *, BTagJetWeight_Ptr> BTagJetWeightMap

typedef std::shared_ptr<JvtJetWeight> JvtJetWeight_Ptr

typedef std::map<const CP::SystematicSet *, JvtJetWeight_Ptr> JvtJetWeightMap

typedef std::shared_ptr<JetWeightHandler> JetWeightHandler_Ptr

typedef std::shared_ptr<MetSignificanceHandler> MetSignificanceHandler_Ptr

typedef std::shared_ptr<MuonWeight> MuonWeight_Ptr

typedef std::map<const CP::SystematicSet *, MuonWeight_Ptr> MuonWeightMap

typedef std::shared_ptr<MuonWeightHandler> MuonWeightHandler_Ptr

typedef std::shared_ptr<SUSYMuonTriggerSFHandler> SUSYMuonTriggerSFHandler_Ptr

typedef std::vector<SUSYMuonTriggerSFHandler_Ptr> SUSYMuonTriggerSFHandler_Vector

typedef std::map<const CP::SystematicSet *, SUSYMuonTriggerSFHandler_Vector> SUSYMuonTriggerSFHandler_Map

typedef ToolHandle<IAsgPhotonEfficiencyCorrectionTool> PhotonEffToolHandle

typedef std::shared_ptr<PhotonWeight> PhotonWeight_Ptr

typedef std::map<const CP::SystematicSet *, PhotonWeight_Ptr> PhotonWeightMap

typedef std::shared_ptr<PhotonWeightHandler> PhotonWeightHandler_Ptr

typedef TauAnalysisTools::ITauEfficiencyCorrectionsTool TauEffiTool

typedef ToolHandle<TauEffiTool> TauEffiToolHandle

typedef std::shared_ptr<TauWeightDecorator> TauWeight_Ptr

typedef std::map<const CP::SystematicSet *, TauWeight_Ptr> TauWeightMap

typedef std::vector<TauWeight_Ptr> TauWeight_Vector

typedef std::map<const CP::SystematicSet *, TauWeight_Vector> TauWeight_VectorMap

typedef std::shared_ptr<TauWeightHandler> TauWeightHandler_Ptr

typedef std::map<TauAnalysisTools::EfficiencyCorrectionType, TauEffiToolHandle> TauEffiToolMap

typedef std::map<std::string, TauEffiToolHandle> TauTriggEffiToolMap

typedef std::function<double(const size_t, const size_t)> BinaryFunc

typedef std::function<double(const size_t)> UnaryFunc

typedef std::shared_ptr<PlotRegion> PlotRegion_Ptr

typedef std::shared_ptr<PlotAnalysis> PlotAnalysis_Ptr

typedef std::shared_ptr<FileStructure> FileStructure_Ptr

typedef std::shared_ptr<SystematicEnvelope> SystematicEnvelope_Ptr

typedef std::shared_ptr<HistoBin> HistoBin_Ptr

typedef std::shared_ptr<HistoAxis> HistoAxis_Ptr

typedef std::shared_ptr<TH1> TH1_Ptr

typedef std::shared_ptr<StringVector> StringVector_Ptr

typedef std::shared_ptr<IfDefVariable> Variable_Ptr

typedef std::shared_ptr<TFile> TFile_Ptr

typedef std::shared_ptr<MetaDataStore> MetaDataStore_Ptr

typedef std::shared_ptr<MonteCarloStoreHandler> MonteCarloStoreHandler_Ptr

typedef std::shared_ptr<MonteCarloPeriodHandler> MonteCarloPeriodHandler_Ptr

typedef std::vector<std::shared_ptr<IParticleTagger>> TaggerVector

typedef std::pair<int, int> Ranges

typedef std::pair<Ranges, Ranges> Cube

Enums

enum NLepton

Values:

ZeroLepton = 0

OneLepton

TwoLepton

enum CutKind

Values:

MonitorCutFlow

EventDump

enum SelectionObject

Values:

Other = 0

Jet = 2

TrackParticle = 4

Electron = 6

Photon = 7

Muon = 8

Tau = 9

BTag = 102

TruthParticle = 201

MissingET = 301

EventWeight = 302

RecoParticle = 960

DiTau = 980

enum ZVeto

Values:

Pass = 1

Fail2Lep = 1 << 1

Fail3Lep = 1 << 2

Fail4Lep = 1 << 3

Fail2LepPhot = 1 << 4

enum Stop_RecoTypes

Values:

None = 0

TopWCandidate1

TopWCandidate2

DRB4TopWCandidate1

DRB4TopWCandidate2

MinMassTopWCandidate1

MinMassTopWCandidate2

Chi2TopWCandidate1

Chi2TopWCandidate2

enum WDecayModes

Values:

Unspecified = 0

Hadronic = 1

ElecNeut = 2

MuonNeut = 3

HadTauNeut = 4

LepTauNeut = 5

enum JetAlgorithm

Values:

AntiKt2 = 0

AntiKt4

AntiKt10

RScan

enum TimeComponent

Values:

Energy = 0

Mass = 1

MTAR = 2

Functions

const xAOD::Jet *GetParentJet(const xAOD::Jet *jet)

Helper function to get parent jet using an element link to the parent jet container.

Return

The parent jet.

Parameters

• jet: The jet

const xAOD::Jet *GetParentJet(const xAOD::Jet &jet)

Helper function to get parent jet using an element link to the parent jet container.

Return

The parent jet.

Parameters

• jet: The jet

TLorentzVector GetTLV(xAOD::JetFourMom_t tmp)

Helper function to convert xAOD JetFourMom_t datatype to ROOT TLorentzVector.

Return

The jet four momentum as TLorentzVector

Parameters

• tmp: The jet four momentum as xAOD::JetFourMom_t

xAOD::JetFourMom_t GetJetFourMom(TLorentzVector tmp)

Helper function to convert ROOT TLorentzVector datatype to xAOD JetFourMom_t.

Return

The jet four momentum as xAOD::JetFourMom_t

Parameters

• tmp: The jet four momentum as TLorentzVector

float METz(TLorentzVector tauInPermutation, TLorentzVector metVec, int type)

This function returns the z-component of pTV.

        It is required for the likelihood calculation of the
        likelihood ordering to reduce ttbar in the resolved signal
        region.

        In the 0 lepton region, the lepton is mostly a taujet. One
        uses invariant mass of leptonic W to find z-component of pTV:
        (pTV + tau)^2 = m_W^2 --> solve quadratic equation in pTV_z.
        pTV_z is used for invariant mass of leptonic top in
        likelihood function: top_lep = W_lep + b_lep

Return

The z-component of pTV calculated from lepton and MET as float

Parameters

• tauInPermutation: The TLorentzVector of a lepton (most likely to be a tau, hence the name)
• metVec: The MET as TLorentzVector
• type: The type of the permutation (used in: METz = 1000 * (center + type * TMath::Sqrt(discriminant) / (energyTau * energyTau - pTauZ * pTauZ));)

float LBW(float mass, float poleMass, float width)

This function returns -2 times the logarithm of a Breit-Wigner function: 2 * ln( (mass^2 - poleMass^2)^2 + (poleMass * width)^2 ); (https://en.wikipedia.org/wiki/Cauchy_distribution)

        It is required for the likelihood calculation of the
        likelihood ordering to reduce ttbar in the resolved signal
        region.

Return

The float value of -2 times the logarithm of a Breit-Wigner function

Parameters

• mass: The mass
• poleMass: The pole mass (e.g. of the W boson or the top quark)
• width: The width

float LChi2(float mass, float poleMass, float width)

This function returns -2ln(exponential), which is the Chi2-term required for the likelihood calculation.

        It is required for the likelihood calculation of the
        likelihood ordering to reduce ttbar in the resolved signal
        region.

Return

Returns float value of -2ln(exponential)

Parameters

• mass: The mass of the resonance
• poleMass: The pole mass (e.g. of the W boson or the top quark)
• width: The width of the resonance

float EllipticCut(float mtop, float mW, int btag)

This function returns the value used for an elliptic cut which is used to reject events inside the ellipse. The parameters of the ellipse are optimised based on a study and are hard-coded in the function implementation. The ellipse is defined by.

         - (x_0,y_0), the center of ellipse,
         - theta, the rotation angle in RAD
         - a,b, the major and minor semi-axis of the ellipse

Return

Returns float value to be used for elliptic cut.

Parameters

• mtop: The top mass (x axis of ellipse)
• mW: The W mass (y axis of ellipse)
• btag: The b-tag multiplicity

float CalculateLikelihood(std::vector<float> &measuredMasses, int Njets)

Calculates the likelihood of a given jet permutation and returns -2 times ln(Likelihood) of given parton-jet permutation.

Return

Returns -2 times ln(Likelihood) of given parton-jet permutation.

Parameters

• measuredMasses: The measured masses entering the likelihood calculation
• Njets: The number of jets in the given parton-jet permutation

float LikelihoodOrderingFourJets(std::vector<const xAOD::Jet *> jetsForHbbReco, TLorentzVector tlv_complete_j0, TLorentzVector tlv_complete_j1, int btag)

Function for likelihood ordering for exactly 4 jets. This shall reduce ttbar in the resolved signal region. When one considers that most of ttbar has one leptonic decaying W boson.

Return

Returns float value for likelihood ordering for ttbar rejection.

Parameters

• jetsForHbbReco: The jets for hbb reco
• tlv_complete_j0: The TLorentzVector of first jet from hadronic W decay
• tlv_complete_j1: The TLorentzVector of second jet from hadronic W decay
• btag: The btag multiplicity

float LikelihoodOrdering(std::vector<const xAOD::Jet *> jetsForHbbReco, TLorentzVector tlv_complete_j0, TLorentzVector tlv_complete_j1, TLorentzVector metVec, const xAOD::Muon *muon, int btag, NLepton nlep)

Function for likelihood ordering. This shall reduce ttbar in the resolved signal region. When one considers that most of ttbar has one leptonic decaying W boson.

Return

Returns float value for likelihood ordering for ttbar rejection.

Parameters

• jetsForHbbReco: The jets for hbb reco
• tlv_complete_j0: The TLorentzVector of first jet from hadronic W decay
• tlv_complete_j1: The TLorentzVector of second jet from hadronic W decay
• metVec: The met vector
• muon: The muon
• btag: The btag multiplicity
• nlep: The lepton multiplicity

static IntAccessor XAMPP::acc_HadronConeExclTruthLabelID("HadronConeExclTruthLabelID")

static IntAccessor XAMPP::acc_n_MuonInJet("n_MuonInJet")

static FloatAccessor XAMPP::acc_XbbScoreHiggs("XbbScoreHiggs")

static FloatAccessor XAMPP::acc_XbbScoreQCD("XbbScoreQCD")

static FloatAccessor XAMPP::acc_XbbScoreTop("XbbScoreTop")

static CharAccessor XAMPP::acc_isAssociated("isAssociated")

static CharAccessor XAMPP::acc_passDRcut("passDRcut")

static IntDecorator XAMPP::dec_n_MuonInJet("n_MuonInJet")

static IntDecorator XAMPP::dec_n_matchedasstrkjets("n_matchedasstrkjets")

static CharDecorator XAMPP::dec_isAssociated("isAssociated")

static DoubleDecorator XAMPP::dec_DL1r("DL1r")

static CharDecorator XAMPP::dec_bjet("bjet")

static IntDecorator XAMPP::dec_NBtags("btag")

double Sign(const double &N)

template <typename T>
int max_bit(const T &number)

bool ptsorter(const xAOD::IParticle *j1, const xAOD::IParticle *j2)

bool btagweightsorter(const xAOD::Jet *j1, const xAOD::Jet *j2)

std::vector<std::string> GetPathResolvedFileList(const std::vector<std::string> &Files)

std::vector<std::string> ListDirectory(std::string Path, std::string ElementToContain = "", std::string RegExpToMatch = "")

StatusCode ResetOverlapDecorations(const xAOD::IParticleContainer *Container)

StatusCode RemoveOverlap(xAOD::IParticleContainer *RemFrom, xAOD::IParticleContainer *RemWith, float dR, bool UseRapidity = true)

StatusCode RemoveOverlap(xAOD::IParticleContainer *RemFrom, xAOD::IParticleContainer *RemWith, std::function<float(const xAOD::IParticle *, const xAOD::IParticle *)> radiusFunc, bool UseRapidity = true, )

float CalculateMT2(const xAOD::IParticle *P1, const xAOD::IParticle *P2, XAMPP::Storage<XAMPPmet> *met, float InvMass = 0, float ParticleMass = -1)

Calculates the symmetric mt2 out of 2 particles and the missing transverse energy.

Return

Symmetric mt2

Parameters

• P1: First particle
• P2: Second particle
• met: Missing transverse energy
• InvMass: Assumed mass of the invisible particle
• ParticleMass: Overwrites the ‘real’ mass of P1 and P2 if needed

float CalculateMT2(const xAOD::IParticle *P1, const xAOD::IParticle *P2, const xAOD::MissingET *met, float InvMass = 0, float ParticleMass = -1)

float CalculateMT2(const xAOD::IParticle &P1, const xAOD::IParticle &P2, XAMPP::Storage<XAMPPmet> *met, float InvMass = 0, float ParticleMass = -1)

float CalculateMT2(const xAOD::IParticle &P1, const xAOD::IParticle &P2, const xAOD::MissingET *met, float InvMass = 0, float ParticleMass = -1)

float CalculateAMT2(const xAOD::IParticle *P1, const xAOD::IParticle *P2, XAMPP::Storage<XAMPPmet> *met, float InvMass1 = 0, float InvMass2 = 0, float ParticleMass = -1)

Calculates the asymmetric mt2 out of 2 particles and the missing transverse energy assuming an asymmetric mass distribution among the invisible particles.

Return

Asymmetric mt2

Parameters

• P1: First particle
• P2: Second particle
• met: Missing transverse energy
• InvMass1: Assumed mass of the first invisible particle
• InvMass2: Assumed mass of the second invisible particle
• ParticleMass: Overwrites the ‘real’ mass of P1 and P2 if needed

float CalculateAMT2(const xAOD::IParticle *P1, const xAOD::IParticle *P2, const xAOD::MissingET *met, float InvMass1 = 0, float InvMass2 = 0, float ParticleMass = -1)

float CalculateAMT2(const xAOD::IParticle &P1, const xAOD::IParticle &P2, XAMPP::Storage<XAMPPmet> *met, float InvMass1 = 0, float InvMass2 = 0, float ParticleMass = -1)

float CalculateAMT2(const xAOD::IParticle &P1, const xAOD::IParticle &P2, const xAOD::MissingET *met, float InvMass1 = 0, float InvMass2 = 0, float ParticleMass = -1)

Momentum FourMomentum(const std::string &str)

std::string FourMomentum(Momentum Mom)

template <typename T>
bool ToolIsAffectedBySystematic(const ToolHandle<T> &Handle, const CP::SystematicSet *set)

template <typename P>
P GetProperty(const std::string &name, const asg::IAsgTool *IAsgTool)

template <typename P, typename T>
P GetProperty(const std::string &name, const ToolHandle<T> &handle)

template <typename P, typename T>
P GetProperty(const std::string &name, const asg::AnaToolHandle<T> &handle)

int Index(const xAOD::IParticle *P)

unsigned int GetNthPrime(unsigned int N)

void FillVectorFromString(std::vector<std::string> &str_vector, std::string &str)

std::string EraseWhiteSpaces(std::string str)

std::string ReplaceExpInString(std::string str, const std::string &exp, const std::string &rep)

std::string ToLower(const std::string &str)

bool GetLine(std::ifstream &inf, std::string &line)

MSG::Level setOutputLevel(int m_output_level_int)

xAOD::IParticle *FindLeadingParticle(xAOD::IParticleContainer *Particles)

std::string RemoveAllExpInStr(std::string Str, std::string Exp)

float GetLeadingPt(xAOD::IParticleContainer *Particles)

bool Overlaps(const xAOD::IParticle &P1, const xAOD::IParticle &P2, float dR, bool UseRapidity = false)

bool Overlaps(const xAOD::IParticle *P1, const xAOD::IParticle *P2, float dR, bool UseRapidity = false)

bool IsRecoLepton(const xAOD::IParticle &L)

bool IsRecoLepton(const xAOD::IParticle *L)

bool OppositeSign(const xAOD::IParticle &L, const xAOD::IParticle &L1)

bool OppositeSign(const xAOD::IParticle *L, const xAOD::IParticle *L1)

bool OppositeSignLead2(const xAOD::IParticleContainer *pc)

bool SameFlavour(const xAOD::IParticle &L, const xAOD::IParticle &L1)

bool SameFlavour(const xAOD::IParticle *L, const xAOD::IParticle *L1)

bool OppositeFlavour(const xAOD::IParticle &L, const xAOD::IParticle &L1)

bool OppositeFlavour(const xAOD::IParticle *L, const xAOD::IParticle *L1)

bool IsSame(const xAOD::IParticle &P, const xAOD::IParticle &P1, bool DeRefShallowCopy = false)

bool IsSame(const xAOD::IParticle *P, const xAOD::IParticle *P1, bool DeRefShallowCopy = false)

bool IsNotSame(const xAOD::IParticle &P, const xAOD::IParticle &P1)

bool IsNotSame(const xAOD::IParticle *P, const xAOD::IParticle *P1)

bool IsSFOS(const xAOD::IParticle &L, const xAOD::IParticle &L1)

bool IsSFOS(const xAOD::IParticle *L, const xAOD::IParticle *L1)

bool IsDFOS(const xAOD::IParticle &L, const xAOD::IParticle &L1)

bool IsDFOS(const xAOD::IParticle *L, const xAOD::IParticle *L1)

StatusCode RemoveLowMassLeptons(xAOD::IParticleContainer *Leptons, bool (*pair)(const xAOD::IParticle *, const xAOD::IParticle *), float Upper_Mll, float Lower_Mll = 0., )

StatusCode RemoveLowMassLeptons(xAOD::IParticleContainer *Leptons, float Upper_Mll, float Lower_Mll = 0.)

void AddFourMomenta(const xAOD::IParticle *P, const xAOD::IParticle *P1, xAOD::Particle *Candidate, std::function<bool(const xAOD::IParticle *)> signalFunc)

void ConstructInvariantMomenta(xAOD::IParticleContainer *Leptons, XAMPP::IReconstructedParticles *Constructor, std::function<bool(const xAOD::IParticle *)> signalFunc, int MaxN = -1, )

void ConstructInvariantMomenta(xAOD::IParticleContainer &Leptons, XAMPP::IReconstructedParticles *Constructor, std::function<bool(const xAOD::IParticle *)> signalFunc, int MaxN = -1, )

void ConstructInvariantMomenta(xAOD::IParticleContainer &Leptons, xAOD::IParticleContainer::const_iterator Itr, XAMPP::IReconstructedParticles *Constructor, std::function<bool(const xAOD::IParticle *)> signalFunc, int MaxN, const xAOD::IParticle *In = nullptr, )

void ConstructInvariantMomenta(xAOD::IParticleContainer *Leptons, asg::AnaToolHandle<XAMPP::IReconstructedParticles> &Constructor, std::function<bool(const xAOD::IParticle *)> signalFunc, int MaxN = -1, )

void ConstructInvariantMomenta(xAOD::IParticleContainer &Leptons, asg::AnaToolHandle<XAMPP::IReconstructedParticles> &Constructor, std::function<bool(const xAOD::IParticle *)> signalFunc, int MaxN = -1, )

void ConstructInvariantMomenta(xAOD::IParticleContainer &Leptons, xAOD::IParticleContainer::const_iterator Itr, asg::AnaToolHandle<XAMPP::IReconstructedParticles> &Constructor, std::function<bool(const xAOD::IParticle *)> signalFunc, int MaxN, const xAOD::IParticle *In = nullptr, )

float Charge(const xAOD::IParticle *p)

float Charge(const xAOD::IParticle &p)

int TypeToPdgId(const xAOD::IParticle *P)

int TypeToPdgId(const xAOD::IParticle &P)

float ComputeMt(const xAOD::IParticle *v1, XAMPP::Storage<XAMPPmet> *met)

float ComputeMt(const xAOD::IParticle &v1, XAMPP::Storage<XAMPPmet> *met)

float ComputeMt(const xAOD::IParticle *v1, const xAOD::MissingET *met)

float ComputeMt(const xAOD::IParticle &v1, const xAOD::MissingET &met)

float ComputeMt(const xAOD::IParticle *v1, const xAOD::IParticle *v2)

float ComputeMt(const xAOD::IParticle &v1, const xAOD::IParticle &v2)

void CalculateMt(xAOD::IParticleContainer &Particles, XAMPP::Storage<xAOD::MissingET *> *dec_MET)

void CalculateMt(const xAOD::IParticleContainer *Particles, XAMPP::Storage<xAOD::MissingET *> *dec_MET)

float RelPt(const xAOD::IParticle *v1, const xAOD::IParticle *v2)

float RelPt(const xAOD::IParticle &v1, const xAOD::IParticle &v2)

float InvariantMass(const xAOD::IParticle &P1, const xAOD::IParticle &P2)

float InvariantMass(const xAOD::IParticle *P1, const xAOD::IParticle *P2)

float InvariantMass(const xAOD::IParticle &P1, const xAOD::IParticle &P2, const xAOD::IParticle &P3)

float InvariantMass(const xAOD::IParticle *P1, const xAOD::IParticle *P2, const xAOD::IParticle *P3)

float InvariantMass(const xAOD::IParticle &P1, const xAOD::IParticle &P2, const xAOD::IParticle &P3, const xAOD::IParticle &P4)

float InvariantMass(const xAOD::IParticle *P1, const xAOD::IParticle *P2, const xAOD::IParticle *P3, const xAOD::IParticle *P4)

int GetZVeto(xAOD::IParticleContainer &Particles, float Z_Window)

int GetZVeto(xAOD::IParticleContainer *Particles, float Z_Window)

int GetZVeto(xAOD::IParticleContainer *Electrons, xAOD::IParticleContainer *Muons, float Z_Window = 1.e4)

float CalculateHt(xAOD::IParticleContainer *Container, float MinPt = 0.)

float CalculateLeptonHt(xAOD::ElectronContainer *Electrons, xAOD::MuonContainer *Muons, xAOD::TauJetContainer *Taus = nullptr)

const xAOD::IParticle *GetClosestParticle(xAOD::IParticleContainer *Cont, XAMPP::Storage<XAMPPmet> *met, xAOD::IParticleContainer *Exclude = nullptr)

const xAOD::IParticle *GetClosestParticle(xAOD::IParticleContainer *Cont, xAOD::MissingET *met, xAOD::IParticleContainer *Exclude = nullptr)

const xAOD::IParticle *GetFarestParticle(xAOD::IParticleContainer *Cont, XAMPP::Storage<XAMPPmet> *met, xAOD::IParticleContainer *Exclude = nullptr)

const xAOD::IParticle *GetFarestParticle(xAOD::IParticleContainer *Cont, xAOD::MissingET *met, xAOD::IParticleContainer *Exclude = nullptr)

const xAOD::IParticle *GetClosestParticle(xAOD::IParticleContainer *Cont, const xAOD::IParticle *P1, xAOD::IParticleContainer *Exclude = nullptr)

const xAOD::IParticle *GetFarestParticle(xAOD::IParticleContainer *Cont, const xAOD::IParticle *P1, xAOD::IParticleContainer *Exclude = nullptr)

const xAOD::IParticle *GetClosestParticle(const xAOD::IParticleContainer *LookIn, const xAOD::IParticle *RefPart, bool UseRapidity = false, const xAOD::IParticleContainer *RefContainer = nullptr)

float ComputeMtMin(xAOD::IParticleContainer *Collection, XAMPP::Storage<XAMPPmet> *met)

float ComputeMtMin(xAOD::IParticleContainer *Collection, xAOD::MissingET *met)

float ComputeMtMin(xAOD::IParticleContainer *Collection, const xAOD::IParticle *P1)

float ComputeMtMax(xAOD::IParticleContainer *Collection, XAMPP::Storage<XAMPPmet> *met)

float ComputeMtMax(xAOD::IParticleContainer *Collection, xAOD::MissingET *met)

float ComputeMtMax(xAOD::IParticleContainer *Collection, const xAOD::IParticle *P1)

float ComputeDPhiMin(xAOD::JetContainer *Jets, XAMPP::Storage<XAMPPmet> *met, unsigned int NJetsToUse = 0)

float ComputeDPhiMin(xAOD::JetContainer *Jets, xAOD::MissingET *met, unsigned int NJetsToUse = 0)

bool HasTauCandidate(xAOD::JetContainer *Jets, xAOD::MissingET *met, unsigned int primVtxIdx, float &MtTauCand, int &Ntracks)

float ComputeMinMt(xAOD::JetContainer *Jets, xAOD::MissingET *met)

float ComputeJetAngularSep(xAOD::JetContainer *Jets)

float ComputeAbsDeltaPhi(xAOD::MissingET *met1, xAOD::MissingET *met2)

float ComputeDeltaPhi(xAOD::MissingET *met1, xAOD::MissingET *met2)

float ComputeDeltaPhi(XAMPP::Storage<XAMPPmet> *met1, XAMPP::Storage<XAMPPmet> *met2)

float ComputeAbsDeltaPhi(XAMPP::Storage<XAMPPmet> *met1, XAMPP::Storage<XAMPPmet> *met2)

bool RecoZfromLeps(xAOD::IParticleContainer *Lep, xAOD::Particle *RecoZ, float MassWindow = 1.e4)

void GetTopCandidates(xAOD::JetContainer *BJets, xAOD::JetContainer *LightJets, xAOD::Particle *W1Cand, xAOD::Particle *W2Cand, xAOD::Particle *Top1Cand, xAOD::Particle *Top2Cand)

void GetTopCandidatesDRB4(xAOD::JetContainer *BJets, xAOD::JetContainer *LightJets, xAOD::Particle *W1CandDRB4, xAOD::Particle *W2CandDRB4, xAOD::Particle *Top1CandDRB4, xAOD::Particle *Top2CandDRB4)

void GetTopCandidatesMinMass(xAOD::JetContainer *BJets, xAOD::JetContainer *LightJets, xAOD::Particle *W1CandMinMass, xAOD::Particle *W2CandMinMass, xAOD::Particle *Top1CandMinMass, xAOD::Particle *Top2CandMinMass)

bool IsBJet(const xAOD::IParticle *P)

float GetChi2FromTopConstruction(float WMass, float TopMass)

bool isConstituent(const xAOD::IParticle *C, const xAOD::Particle *DiPart)

bool HasCommonConstructingParticles(const xAOD::IParticle *First, const xAOD::IParticle *Second)

xAOD::Particle *GetTop(const xAOD::IParticle *W, const xAOD::Jet *B, asg::AnaToolHandle<XAMPP::IReconstructedParticles> &Constructor)

xAOD::Particle *GetTop(const xAOD::IParticle *W, const xAOD::Jet *B, XAMPP::IReconstructedParticles *Constructor)

StatusCode GetTopCandidatesChi2(xAOD::JetContainer *SignalJets, const xAOD::JetContainer *BJets, asg::AnaToolHandle<XAMPP::IReconstructedParticles> &Constructor)

StatusCode GetTopCandidatesChi2(xAOD::JetContainer *SignalJets, const xAOD::JetContainer *BJets, XAMPP::IReconstructedParticles *Constructor)

xAOD::MissingET *GetMET_obj(const std::string &Name, xAOD::MissingETContainer *Cont)

void PromptParticle(const xAOD::IParticle *Part, std::string AddInfo = "")

void PromptParticle(const xAOD::IParticle &Part, std::string AddInfo = "")

bool IsInContainer(const xAOD::IParticle *P, const xAOD::IParticleContainer *Container)

bool IsInContainer(const xAOD::IParticle &P, const xAOD::IParticleContainer *Container)

bool IsInContainer(const xAOD::IParticle *P, const xAOD::IParticleContainer &Container)

bool IsInContainer(const xAOD::IParticle &P, const xAOD::IParticleContainer &Container)

template <typename T>
bool IsInVector(const T &Ele, const std::vector<T> &Vec)

template <typename T>
void CopyVector(const std::vector<T> &From, std::vector<T> &To, bool Clear = true)

template <typename T>
void ClearFromDuplicates(std::vector<T> &toClear)

template <typename T>
void EraseFromVector(std::vector<T> &vec, std::function<bool(const T&)> func)

template <class T>
std::ostream &operator<<(std::ostream &os, const std::vector<T> &v)

bool IsChargedFlipped(const xAOD::Electron *el)

bool isSparticle(const xAOD::TruthParticle &P)

bool isSparticle(const xAOD::TruthParticle *P)

bool isGluon(const xAOD::TruthParticle &P)

bool isGluon(const xAOD::TruthParticle *P)

bool isEWboson(const xAOD::TruthParticle &P)

bool isEWboson(const xAOD::TruthParticle *P)

const xAOD::TruthParticle *getTruthMatchedParticle(const xAOD::IParticle &P)

const xAOD::TruthParticle *getTruthMatchedParticle(const xAOD::IParticle *P)

int getParticleTruthOrigin(const xAOD::IParticle &P)

int getParticleTruthOrigin(const xAOD::IParticle *P)

int getParticleTruthType(const xAOD::IParticle &P)

int getParticleTruthType(const xAOD::IParticle *P)

const xAOD::TruthParticle *GetFirstChainLink(const xAOD::TruthParticle *TruthPart)

const xAOD::TruthParticle *GetLastChainLink(const xAOD::TruthParticle *TruthPart)

bool isParticleFromHardProcess(const xAOD::TruthParticle *TruthPart, bool rejectUnknownOrigin = false)

bool IsInOutGoing(const xAOD::TruthParticle *P)

float MinDeltaR(const xAOD::IParticle *p, const xAOD::IParticleContainer *pc)

template <class decoType, class retType>
bool getDeco(const SG::AuxElement::Accessor<decoType> &accessor, const SG::AuxElement &part, retType &val)

template <class decoType>
bool getDeco(const std::string &name, const SG::AuxElement &part, decoType &val)

template <class decoType, class inputType>
void setDeco(const SG::AuxElement::Decorator<decoType> &deco, const SG::AuxElement &part, const inputType &val)

template <class decoType>
void setDeco(const std::string &name, const SG::AuxElement &part, const decoType &val)

std::vector<unsigned int> SUSYprocessIDs()

std::string to_string(TauAnalysisTools::EfficiencyCorrectionType T)

void PrintHeadLine(const std::string &Title)

void PrintFooter()

template <typename T>
bool IsElementInList(const std::vector<T> &List, const T &Element)

template <typename T>
void CopyVector(const std::vector<T> &From, std::set<T> &To, bool Clear = false)

template <typename T>
unsigned int count_active(const std::vector<std::future<T>> &threads)

template <typename T>
void RemoveElement(std::vector<T> &Vec, const T &Ele)

std::string GetWordFromStream(std::stringstream &sstr, bool Reset = false)

int GetIntegerFromStream(std::stringstream &sstr, bool Reset = false)

float GetFloatFromStream(std::stringstream &sstr, bool Reset = false)

double GetDoubleFromStream(std::stringstream &sstr, bool Reset = false)

double truncate(const double &dbl, unsigned int prec)

bool IsKeyWordSatisfied(std::stringstream &sstr, const std::string &word)

void ExtractListFromStream(std::stringstream &sstr, std::vector<std::string> &List, bool ClearList = false)

void ExtractListFromStream(std::stringstream &sstr, std::vector<int> &List, bool ClearList = false)

void ExtractListFromStream(std::stringstream &sstr, std::vector<float> &List, bool ClearList = false)

std::shared_ptr<TFile> Open(const std::string &Path)

void PrintHistogram(TH1 *H)

unsigned int GetNbins(const std::shared_ptr<TH1> &Histo)

unsigned int GetNbins(const TH1 *Histo)

double GetBinNormalization(const TH1 *H1, int Bin)

double GetBinNormalization(const std::shared_ptr<TH1> &H1, int Bin)

double Integrate(const std::shared_ptr<TH1> &Histo, unsigned int xStart = 0, int xEnd = -1, unsigned int yStart = 0, int yEnd = -1, unsigned int zStart = 0, int zEnd = -1)

double Integrate(const TH1 *Histo, unsigned int xStart = 0, int xEnd = -1, unsigned int yStart = 0, int yEnd = -1, unsigned int zStart = 0, int zEnd = -1)

std::pair<double, double> IntegrateAndError(const std::shared_ptr<TH1> &Histo, unsigned int xStart = 0, int xEnd = -1, unsigned int yStart = 0, int yEnd = -1, unsigned int zStart = 0, int zEnd = -1)

std::pair<double, double> IntegrateAndError(const TH1 *Histo, unsigned int xStart = 0, int xEnd = -1, unsigned int yStart = 0, int yEnd = -1, unsigned int zStart = 0, int zEnd = -1)

double GetMinimum(const std::shared_ptr<TH1> &histo, double min_value = -DBL_MAX)

double GetMinimum(const TH1 *histo, double min_value = DBL_MIN)

double GetMaximum(const std::shared_ptr<TH1> &histo, double max_value = DBL_MAX)

double GetMaximum(const TH1 *histo, double max_value = DBL_MAX)

int GetMinimumBin(const std::shared_ptr<TH1> &histo, double min_value = -DBL_MAX)

int GetMinimumBin(const TH1 *histo, double min_value = DBL_MIN)

int GetMaximumBin(const std::shared_ptr<TH1> &histo, double max_value = DBL_MAX)

int GetMaximumBin(const TH1 *histo, double max_value = DBL_MAX)

std::shared_ptr<TH1> clone(const std::shared_ptr<TH1> &histo, bool reset = false)

std::shared_ptr<TH1> clone(const TH1 *histo, bool reset = false)

std::shared_ptr<TH1> ProjectInto1D(const std::shared_ptr<TH1> &H3, unsigned int project_along, int bin1_start, int bin1_end, int bin2_start, int bin2_end)

std::shared_ptr<TH1> ProjectInto1D(TH1 *H3, unsigned int project_along, int bin1_start, int bin1_end, int bin2_start, int bin2_end)

bool IsFinite(const std::shared_ptr<TH1> &histo)

bool IsFinite(const TH1 *histo)

std::string TimeHMS(float t)

std::string SeparationLine()

std::string WhiteSpaces(int N = 0, std::string space = " ")

std::string LongestCommonString(const std::string &str1, const std::string &str2)

std::string RandomString(size_t s)

void Info(const std::string &Method, const std::string &Message)

void Error(const std::string &Method, const std::string &Message)

void Warning(const std::string &Method, const std::string &Message)

std::shared_ptr<Condition> CreateCut(ITreeVarReader *Var, std::stringstream &sstr)

std::shared_ptr<Condition> CreateCut(const std::string &line, std::vector<ITreeVarReader *> &Readers)

Condition::Mode GetCombineModeFromLine(const std::string &line)

std::shared_ptr<Condition> CreateCombinedCut(std::ifstream &inf, std::vector<ITreeVarReader *> &Readers, const std::string &line)

std::shared_ptr<Condition> CreateCombinedCut(std::ifstream &inf, std::vector<ITreeVarReader *> &Readers, Condition::Mode M)

std::shared_ptr<Histo> CreateHisto(std::ifstream &inf, std::vector<ITreeVarReader *> &Readers)

ITreeVarWriter *CreateOutBranch(std::ifstream &inf, std::vector<ITreeVarReader *> &Readers)

std::vector<std::string> ListDirectory(std::string Path, std::string WildCard)

std::string ResolvePath(const std::string &path)

bool DoesFileExist(const std::string &Path)

bool DoesDirectoryExist(const std::string &Path)

bool IsFinite(double N)

int gcd(int a, int b)

std::string ResolveEnviromentVariables(std::string str)

Ranges GetRangesFromStr(std::string str)

Cube GetMatrixRangesToRead(std::string &Instr)

std::string GetMatrixRangesFromCube(Cube C)

unsigned int binomial(unsigned int n, unsigned int m)

std::vector<size_t> sequence(size_t to, size_t start = 0)

m_region(region)

m_variable(variable)

m_name(sample_name)

m_label()

m_nominal_histo()

m_sample_type(SampleHisto::SampleType::UnDefined)

m_root_files()

XAMPP::m_tried_to_load(false)

m_variations()

m_up_syst_histo()

m_down_syst_histo()

XAMPP::m_legend_order(- 1)

XAMPP::m_integral(std:: nan"1")

XAMPP::m_lumi(1.)

m_nominal()

m_syst()

m_excluded_syst()

XAMPP::m_syst_set_external(false)

XAMPP::m_nominal_set_external(false)

XAMPP::m_theo_uncert(- 1.)

XAMPP::m_drawStyle("HIST")

XAMPP::m_nom_dn(ref_histo-> ApplyTansformation[&ref_histo,&dn](unsigned int i){return std::pair< double, double >(ref_histo->GetBinContent(i)-dn->GetBinContent(i), 0);})

XAMPP::m_symmetric(false)

XAMPP::m_envelope(false)

XAMPP::m_tot_up_dev(0)

XAMPP::m_tot_dn_dev(0)

XAMPP::m_dev_cached(false)

Variables

constexpr float Z_MASS = 91.1876 * 1e3

constexpr float W_MASS = 80387.

constexpr float W_WIDTH = 2085

constexpr float Top_MASS = 173210.

constexpr float MeVToGeV = 1. / 1000.

const float TTVA_SF_MIN_PT = 1.e4

const std::vector<std::string> m_IdExp = {"noL1", "tc_ecm", "tc_em", "loose", "tracktwo", "etcut", "nod0", "ivar", "medium", "loose"}

const float M_Z = 91.2

constexpr size_t reset_idx = -1

const int MsgMethodChars = 35

const unsigned int period_mc16a = 284500

const unsigned int period_mc16d = 300000

const unsigned int period_mc16e = 310000

file AnalysisConfig.cxx

#include <XAMPPbase/AnalysisUtils.h>#include <XAMPPbase/Cuts.h>#include <XAMPPbase/EventInfo.h>#include <XAMPPbase/HistoBase.h>#include <XAMPPbase/HistoHelpers.h>#include <PATInterfaces/SystematicSet.h>#include <XAMPPbase/AnalysisConfig.h>#include <iostream>#include <vector>#include “TMath.h”

Defines

GeVToMeV

file BaseAnalysisModule.cxx

#include <XAMPPbase/AnalysisUtils.h>#include <XAMPPbase/BaseAnalysisModule.h>#include <XAMPPbase/ToolHandleSystematics.h>

file Cuts.cxx

#include <XAMPPbase/AnalysisUtils.h>#include <XAMPPbase/Cuts.h>#include <XAMPPbase/EventInfo.h>#include <XAMPPbase/EventStorage.h>

file Cuts.cxx

#include <XAMPPplotting/Cuts.h>#include <XAMPPplotting/TreeVarReader.h>#include <XAMPPplotting/UtilityReader.h>#include <XAMPPplotting/Weight.h>#include <AsgAnalysisInterfaces/IGoodRunsListSelectionTool.h>#include <cstring>#include <iostream>

file ElectronDecorations.cxx

#include <XAMPPbase/ElectronDecorations.h>

file EventInfo.cxx

#include <XAMPPbase/AnalysisUtils.h>#include <XAMPPbase/EventInfo.h>#include <XAMPPbase/ISystematics.h>#include <XAMPPbase/TreeBase.h>#include <XAMPPbase/TreeHelpers.h>#include <iostream>#include <vector>#include <AsgAnalysisInterfaces/IGoodRunsListSelectionTool.h>#include <AsgAnalysisInterfaces/IPileupReweightingTool.h>#include <PATInterfaces/SystematicSet.h>#include <PileupReweighting/PileupReweightingTool.h>#include <PileupReweighting/TPileupReweighting.h>#include <xAODCore/ShallowCopy.h>

file EventStorage.cxx

#include <PATInterfaces/SystematicSet.h>#include <XAMPPbase/AnalysisUtils.h>#include <XAMPPbase/Cuts.h>#include <XAMPPbase/EventStorage.h>#include <XAMPPbase/TreeBase.h>

file HistoBase.cxx

#include <XAMPPbase/AnalysisUtils.h>#include <XAMPPbase/AnalysisConfig.h>#include <XAMPPbase/ISystematics.h>#include <XAMPPbase/EventInfo.h>#include <XAMPPbase/HistoBase.h>#include <XAMPPbase/HistoHelpers.h>#include <iostream>#include <vector>#include <GaudiKernel/ITHistSvc.h>#include “TH1D.h”#include “TH2D.h”#include “TH3D.h”

file HistoHelpers.cxx

#include <XAMPPbase/AnalysisUtils.h>#include <XAMPPbase/AnalysisConfig.h>#include <XAMPPbase/Cuts.h>#include <XAMPPbase/EventStorage.h>#include <XAMPPbase/HistoBase.h>#include <XAMPPbase/HistoHelpers.h>#include <iostream>#include <vector>#include “TH1D.h”#include “TH2D.h”#include “TH3D.h”

file JetDecorations.cxx

#include <XAMPPbase/JetDecorations.h>

file MetaDataTree.cxx

#include <XAMPPbase/MetaDataTree.h>#include <iostream>#include <XAMPPbase/IAnalysisHelper.h>#include <XAMPPbase/AnalysisUtils.h>#include <XAMPPbase/EventInfo.h>#include <xAODCutFlow/CutBookkeeper.h>#include <xAODCutFlow/CutBookkeeperContainer.h>#include <xAODMetaData/FileMetaData.h>#include <xAODTruth/TruthMetaDataContainer.h>#include <xAODLuminosity/LumiBlockRange.h>#include <xAODLuminosity/LumiBlockRangeContainer.h>#include <AthAnalysisBaseComps/AthAnalysisHelper.h>#include <EventInfo/EventStreamInfo.h>#include <GaudiKernel/ITHistSvc.h>

file MuonDecorations.cxx

#include <XAMPPbase/MuonDecorations.h>

file ParticleDecorations.cxx

#include <XAMPPbase/ParticleDecorations.h>

file ParticleSelector.cxx

#include <PATInterfaces/SystematicSet.h>#include <XAMPPbase/AnalysisUtils.h>#include <XAMPPbase/EventInfo.h>#include <XAMPPbase/ISystematics.h>#include <XAMPPbase/ParticleSelector.h>#include <xAODJet/JetAuxContainer.h>#include <xAODJet/JetContainer.h>#include “JetRec/JetDumper.h”#include “JetRec/JetFinder.h”#include “JetRec/JetFromPseudojet.h”#include “JetRec/JetRecTool.h”#include “JetRec/JetSplitter.h”#include “JetRec/JetToolRunner.h”#include “JetRec/PseudoJetGetter.h”#include “fastjet/ClusterSequence.hh”#include “fastjet/PseudoJet.hh”#include “fastjet/tools/Filter.hh”

file PhotonDecorations.cxx

#include <XAMPPbase/AnalysisUtils.h>#include <XAMPPbase/PhotonDecorations.h>

file PileupUtils.cxx

#include <AsgAnalysisInterfaces/IPileupReweightingTool.h>#include <PileupReweighting/PileupReweightingTool.h>#include <PileupReweighting/TPileupReweighting.h>#include <XAMPPbase/PileupUtils.h>

file RecontructedParticles.cxx

#include <PATInterfaces/SystematicSet.h>#include <XAMPPbase/AnalysisUtils.h>#include <XAMPPbase/EventInfo.h>#include <XAMPPbase/ReconstructedParticles.h>

file SUSYAnalysisHelper.cxx

#include <XAMPPbase/AnalysisConfig.h>#include <XAMPPbase/EventInfo.h>#include <XAMPPbase/HistoBase.h>#include <XAMPPbase/IDiTauSelector.h>#include <XAMPPbase/IElectronSelector.h>#include <XAMPPbase/IJetSelector.h>#include <XAMPPbase/IMetSelector.h>#include <XAMPPbase/IMuonSelector.h>#include <XAMPPbase/IPhotonSelector.h>#include <XAMPPbase/ITauSelector.h>#include <XAMPPbase/ITriggerTool.h>#include <XAMPPbase/ITruthSelector.h>#include <XAMPPbase/MetaDataTree.h>#include <XAMPPbase/ReconstructedParticles.h>#include <XAMPPbase/SUSYAnalysisHelper.h>#include <XAMPPbase/SUSYSystematics.h>#include <XAMPPbase/TreeBase.h>#include <AsgAnalysisInterfaces/IGoodRunsListSelectionTool.h>#include <AsgTools/StatusCode.h>#include <GaudiKernel/ITHistSvc.h>#include <PATInterfaces/CorrectionCode.h>#include <PATInterfaces/SystematicSet.h>#include <PathResolver/PathResolver.h>#include <SUSYTools/SUSYCrossSection.h>#include <SUSYTools/SUSYObjDef_xAOD.h>#include <fstream>#include <iostream>

file SUSYElectronSelector.cxx

#include <EgammaAnalysisInterfaces/IAsgElectronEfficiencyCorrectionTool.h>#include <IsolationSelection/IIsolationSelectionTool.h>#include <PATCore/PATCoreEnums.h>#include <SUSYTools/SUSYObjDef_xAOD.h>#include <XAMPPbase/AnalysisUtils.h>#include <XAMPPbase/SUSYElectronSelector.h>#include <XAMPPbase/SUSYTriggerTool.h>#include <XAMPPbase/ToolHandleSystematics.h>#include <xAODEgamma/EgammaxAODHelpers.h>

Defines

CONFIG_BASELINE_IDISO_SFTOOl(TOOLHANDLE, TOOLNAME, ISOWP)

file SUSYJetSelector.cxx

#include <FTagAnalysisInterfaces/IBTaggingEfficiencyTool.h>#include <FTagAnalysisInterfaces/IBTaggingSelectionTool.h>#include <JetAnalysisInterfaces/IJetJvtEfficiency.h>#include <JetJvtEfficiency/JetJvtEfficiency.h>#include <XAMPPbase/SUSYJetSelector.h>#include <xAODJet/JetContainerInfo.h>

file SUSYMetSelector.cxx

#include <METInterface/IMETMaker.h>#include <METInterface/IMETSystematicsTool.h>#include <METUtilities/METSignificance.h>#include <XAMPPbase/AnalysisUtils.h>#include <XAMPPbase/Defs.h>#include <XAMPPbase/EventInfo.h>#include <XAMPPbase/IElectronSelector.h>#include <XAMPPbase/IJetSelector.h>#include <XAMPPbase/IMuonSelector.h>#include <XAMPPbase/IPhotonSelector.h>#include <XAMPPbase/ISystematics.h>#include <XAMPPbase/ITauSelector.h>#include <XAMPPbase/SUSYMetSelector.h>#include <xAODJet/JetContainerInfo.h>#include <functional>

file SUSYMuonSelector.cxx

#include <XAMPPbase/AnalysisUtils.h>#include <XAMPPbase/Cuts.h>#include <XAMPPbase/SUSYMuonSelector.h>#include <IsolationSelection/IIsolationSelectionTool.h>#include <MuonAnalysisInterfaces/IMuonEfficiencyScaleFactors.h>#include <MuonAnalysisInterfaces/IMuonTriggerScaleFactors.h>#include <PATInterfaces/SystematicSet.h>#include <SUSYTools/SUSYObjDef_xAOD.h>

file SUSYParticleSelector.cxx

#include <XAMPPbase/EventInfo.h>#include <XAMPPbase/ISystematics.h>#include <XAMPPbase/SUSYParticleSelector.h>

file SUSYPhotonSelector.cxx

#include <EgammaAnalysisInterfaces/IAsgPhotonEfficiencyCorrectionTool.h>#include <XAMPPbase/SUSYPhotonSelector.h>

file SUSYSystematics.cxx

#include <PATInterfaces/SystematicCode.h>#include <PATInterfaces/SystematicRegistry.h>#include <PATInterfaces/SystematicSet.h>#include <PATInterfaces/SystematicVariation.h>#include <SUSYTools/SUSYObjDef_xAOD.h>#include <SUSYTools/SUSYCrossSection.h>#include <XAMPPbase/AnalysisUtils.h>#include <XAMPPbase/SUSYSystematics.h>

file SUSYTauSelector.cxx

#include <AsgAnalysisInterfaces/IPileupReweightingTool.h>#include <TauAnalysisTools/ITauEfficiencyCorrectionsTool.h>#include <TauAnalysisTools/TauSelectionTool.h>#include <TauAnalysisTools/TauTruthMatchingTool.h>#include <XAMPPbase/SUSYTauSelector.h>#include <XAMPPbase/SUSYTriggerTool.h>#include <XAMPPbase/ToolHandleSystematics.h>#include <xAODTau/TauxAODHelpers.h>#include <fstream>#include <iostream>#include <sstream>

file SUSYTriggerTool.cxx

#include <SUSYTools/ISUSYObjDef_xAODTool.h>#include <XAMPPbase/AnalysisUtils.h>#include <XAMPPbase/EventInfo.h>#include <XAMPPbase/SUSYTriggerTool.h>#include <XAMPPbase/TreeHelpers.h>#include <xAODTrigMissingET/TrigMissingETContainer.h>#include <xAODTrigger/EnergySumRoI.h>#include “TriggerMatchingTool/IMatchingTool.h”#include “TrigDecisionTool/TrigDecisionTool.h”

file SUSYTruthAnalysisHelper.cxx

#include <XAMPPbase/AnalysisUtils.h>#include <XAMPPbase/ITruthSelector.h>#include <XAMPPbase/ReconstructedParticles.h>#include <XAMPPbase/SUSYTruthAnalysisHelper.h>

file SUSYTruthSelector.cxx

#include <SUSYTools/SUSYCrossSection.h>#include <SUSYTools/SUSYObjDef_xAOD.h>#include <XAMPPbase/AnalysisUtils.h>#include <XAMPPbase/EventInfo.h>#include <XAMPPbase/IMetSelector.h>#include <XAMPPbase/SUSYTruthSelector.h>#include “fastjet/ClusterSequence.hh”#include “fastjet/PseudoJet.hh”

file TauDecorations.cxx

#include <XAMPPbase/TauDecorations.h>

file TreeBase.cxx

#include <GaudiKernel/ITHistSvc.h>#include <PATInterfaces/SystematicSet.h>#include <XAMPPbase/AnalysisConfig.h>#include <XAMPPbase/AnalysisUtils.h>#include <XAMPPbase/EventInfo.h>#include <XAMPPbase/ISystematics.h>#include <XAMPPbase/TreeBase.h>#include <XAMPPbase/TreeHelpers.h>#include <iostream>

file TreeHelpers.cxx

#include <XAMPPbase/AnalysisUtils.h>#include <XAMPPbase/EventInfo.h>#include <XAMPPbase/EventStorage.h>#include <XAMPPbase/TreeBase.h>#include <XAMPPbase/TreeHelpers.h>

file TruthDecorations.cxx

#include <XAMPPbase/AnalysisUtils.h>#include <XAMPPbase/TruthDecorations.h>

file AnalysisConfig.h

#include <AsgTools/AsgTool.h>#include <AsgTools/IAsgTool.h>#include <XAMPPbase/Cuts.h>#include <map>#include <string>#include <vector>

file BaseAnalysisModule.h

#include <AsgTools/AnaToolHandle.h>#include <AsgTools/AsgTool.h>#include <AsgTools/ToolHandle.h>#include <XAMPPbase/Defs.h>#include <XAMPPbase/EventInfo.h>#include <XAMPPbase/EventStorage.h>#include <XAMPPbase/IAnalysisModule.h>#include <XAMPPbase/ReconstructedParticles.h>

file Cuts.h

#include <XAMPPbase/Defs.h>#include <XAMPPbase/EventInfo.h>#include <xAODMissingET/MissingETContainer.h>#include <iostream>#include <string>#include <XAMPPbase/Cuts.ixx>

file Cuts.h

#include <AsgTools/AnaToolHandle.h>#include <memory>#include <set>#include <string>#include <vector>

file Cuts.ixx

#include <XAMPPbase/Cuts.h>

Defines

XAMPPbase_Cuts_IXX

file DecorationInterface.h

#include <type_traits>#include “AthContainers/AuxElement.h”

file Defs.h

#include <xAODMissingET/MissingET.h>

file ElectronDecorations.h

#include <XAMPPbase/ParticleDecorations.h>#include <xAODTruth/TruthParticleContainer.h>

file EventInfo.h

#include <XAMPPbase/EventStorage.h>#include <XAMPPbase/IEventInfo.h>#include <XAMPPbase/ISystematics.h>#include <xAODEventInfo/EventInfo.h>#include <xAODTracking/Vertex.h>#include <AsgTools/AnaToolHandle.h>#include <AsgTools/AsgTool.h>#include <AsgTools/IAsgTool.h>#include <AsgTools/ToolHandle.h>#include <memory>#include <XAMPPbase/EventInfo.ixx>

file EventInfo.ixx

#include <XAMPPbase/EventInfo.h>

Defines

XAMPPbase_EventInfo_IXX

file EventStorage.h

#include <AsgTools/IAsgTool.h>#include <AsgTools/ToolHandle.h>#include <TH1.h>#include <XAMPPbase/IEventInfo.h>#include <xAODEventInfo/EventInfo.h>#include <iostream>#include <map>#include <memory>#include <string>#include <vector>#include <XAMPPbase/EventStorage.ixx>

file EventStorage.ixx

#include <XAMPPbase/EventStorage.h>#include <XAMPPbase/IEventInfo.h>#include <XAMPPbase/TreeHelpers.h>#include <memory>#include <string>

Defines

XAMPPBASE_EventStorage_IXX

file HistoBase.h

#include <TH1.h>#include <XAMPPbase/HistoHelpers.h>#include “TDirectory.h”#include “TFile.h”#include <map>#include <memory>#include <string>#include <vector>

file HistoHelpers.h

#include <XAMPPbase/Defs.h>#include <xAODBase/IParticleContainer.h>#include <iostream>#include <map>#include <memory>#include <string>#include <vector>#include <TH1.h>#include <XAMPPbase/HistoHelpers.ixx>

file HistoHelpers.ixx

#include <XAMPPbase/Defs.h>#include <XAMPPbase/EventStorage.h>#include <XAMPPbase/HistoBase.h>

Defines

XAMPPbase_HistoHelpers_IXX

file IAnalysisHelper.h

#include <XAMPPbase/Defs.h>#include “AsgTools/IAsgTool.h”

file IAnalysisModule.h

#include <AsgTools/IAsgTool.h>

file IDiTauSelector.h

#include <AsgTools/IAsgTool.h>#include <xAODTau/DiTauJet.h>#include <xAODTau/DiTauJetContainer.h>

file IElectronSelector.h

#include <AsgTools/IAsgTool.h>#include <XAMPPbase/ElectronDecorations.h>#include <xAODEgamma/Electron.h>#include <xAODEgamma/ElectronContainer.h>

file IEventInfo.h

#include <AsgTools/IAsgTool.h>#include <XAMPPbase/Defs.h>#include <xAODEventInfo/EventInfo.h>#include <xAODTracking/Vertex.h>

file IJetSelector.h

#include <AsgTools/IAsgTool.h>#include <XAMPPbase/Defs.h>#include <XAMPPbase/JetDecorations.h>#include <xAODJet/JetAuxContainer.h>#include <xAODJet/JetContainer.h>

file IMetSelector.h

#include <AsgTools/IAsgTool.h>#include <xAODMissingET/MissingETAuxContainer.h>#include <xAODMissingET/MissingETContainer.h>

file IMuonSelector.h

#include <AsgTools/IAsgTool.h>#include <XAMPPbase/MuonDecorations.h>#include <xAODMuon/Muon.h>#include <xAODMuon/MuonContainer.h>

file IPhotonSelector.h

#include <AsgTools/IAsgTool.h>#include <XAMPPbase/PhotonDecorations.h>#include <xAODEgamma/Photon.h>#include <xAODEgamma/PhotonContainer.h>

file ISystematics.h

#include <AsgTools/IAsgTool.h>#include <XAMPPbase/Defs.h>#include <xAODBase/ObjectType.h>#include <vector>

file ITauSelector.h

#include <AsgTools/IAsgTool.h>#include <XAMPPbase/TauDecorations.h>#include <xAODTau/TauJet.h>#include <xAODTau/TauJetContainer.h>

file ITriggerTool.h

#include <AsgTools/IAsgTool.h>#include <xAODBase/ObjectType.h>#include <XAMPPbase/IElectronSelector.h>#include <XAMPPbase/IMuonSelector.h>#include <XAMPPbase/IPhotonSelector.h>#include <XAMPPbase/ITauSelector.h>#include <memory>

file ITruthSelector.h

#include <AsgTools/IAsgTool.h>#include <XAMPPbase/TruthDecorations.h>#include <xAODJet/JetContainer.h>#include <xAODTruth/TruthParticle.h>#include <xAODTruth/TruthParticleContainer.h>

file JetDecorations.h

#include <XAMPPbase/ParticleDecorations.h>#include <xAODTruth/TruthParticleContainer.h>

file MetaDataTree.h

#include <AsgTools/AnaToolHandle.h>#include <AsgTools/AsgMetadataTool.h>#include <AsgTools/IAsgTool.h>#include <AsgTools/ToolHandle.h>#include <TFile.h>#include <TTree.h>#include <XAMPPbase/IEventInfo.h>#include <xAODCutFlow/CutBookkeeper.h>#include <xAODCutFlow/CutBookkeeperContainer.h>#include <xAODEventInfo/EventInfo.h>#include <xAODLuminosity/LumiBlockRange.h>#include <xAODLuminosity/LumiBlockRangeContainer.h>#include <map>#include <memory>#include <set>

file MuonDecorations.h

#include <XAMPPbase/ParticleDecorations.h>#include <xAODTruth/TruthParticleContainer.h>

file ParticleDecorations.h

#include <XAMPPbase/DecorationInterface.h>

file ParticleSelector.h

#include <AsgTools/AsgTool.h>#include <XAMPPbase/EventInfo.h>#include <XAMPPbase/ParticleDecorations.h>#include <AsgTools/AnaToolHandle.h>#include <AsgTools/ToolHandle.h>#include <XAMPPbase/Defs.h>#include <xAODBase/ObjectType.h>#include <xAODCore/ShallowCopy.h>#include <memory>#include <XAMPPbase/ParticleSelector.ixx>

file ParticleSelector.ixx

#include <XAMPPbase/ISystematics.h>#include <XAMPPbase/ParticleSelector.h>#include <XAMPPbase/ToolHandleSystematics.h>#include <PATInterfaces/SystematicSet.h>#include <xAODBase/IParticleHelpers.h>

Defines

XAMPPBASE_ParticleSelector_IXX

file PhotonDecorations.h

#include <XAMPPbase/ParticleDecorations.h>#include <xAODTruth/TruthParticleContainer.h>

file PileupUtils.h

#include <XAMPPbase/AnalysisUtils.h>

file ReconstructedParticles.h

#include <AsgTools/AsgTool.h>#include <AsgTools/IAsgTool.h>#include <XAMPPbase/ParticleSelector.h>#include <xAODParticleEvent/Particle.h>#include <xAODParticleEvent/ParticleAuxContainer.h>#include <xAODParticleEvent/ParticleContainer.h>

file SUSYAnalysisHelper.h

#include <XAMPPbase/AnalysisUtils.h>#include <XAMPPbase/IAnalysisHelper.h>#include <XAMPPbase/IAnalysisModule.h>#include <XAMPPbase/HistoBase.h>#include <XAMPPbase/TreeHelpers.h>#include <XAMPPbase/IDiTauSelector.h>#include <XAMPPbase/IElectronSelector.h>#include <XAMPPbase/IJetSelector.h>#include <XAMPPbase/IMuonSelector.h>#include <XAMPPbase/IPhotonSelector.h>#include <XAMPPbase/ITauSelector.h>#include <XAMPPbase/ITruthSelector.h>#include <XAMPPbase/EventInfo.h>#include <XAMPPbase/EventStorage.h>#include <XAMPPbase/ITriggerTool.h>#include <AsgTools/AnaToolHandle.h>#include <AsgTools/AsgTool.h>#include <AsgTools/ToolHandle.h>#include <AsgTools/ToolHandleArray.h>#include <SUSYTools/SUSYObjDef_xAOD.h>#include <TFile.h>#include <fstream>#include <iomanip>#include <iostream>#include <memory>#include <sstream>#include <string>#include <vector>

file SUSYElectronSelector.h

#include <XAMPPbase/IElectronSelector.h>#include <XAMPPbase/ITriggerTool.h>#include <XAMPPbase/SUSYParticleSelector.h>#include <AsgTools/AnaToolHandle.h>

file SUSYJetSelector.h

#include <XAMPPbase/IJetSelector.h>#include <XAMPPbase/SUSYParticleSelector.h>

file SUSYMetSelector.h

#include <SUSYTools/SUSYObjDef_xAOD.h>#include <METInterface/IMETMaker.h>#include <METInterface/IMETSystematicsTool.h>#include <AsgTools/AnaToolHandle.h>#include <AsgTools/AsgTool.h>#include <XAMPPbase/EventStorage.h>#include <XAMPPbase/IMetSelector.h>#include <xAODMissingET/MissingETAssociationMap.h>#include <xAODMissingET/MissingETContainer.h>

file SUSYMuonSelector.h

#include <XAMPPbase/IMuonSelector.h>#include <XAMPPbase/SUSYParticleSelector.h>

file SUSYParticleSelector.h

#include <SUSYTools/ISUSYObjDef_xAODTool.h>#include <XAMPPbase/AnalysisUtils.h>#include <XAMPPbase/EventInfo.h>#include <XAMPPbase/EventStorage.h>#include <XAMPPbase/ISystematics.h>#include <XAMPPbase/ParticleSelector.h>#include <XAMPPbase/SUSYParticleSelector.ixx>

file SUSYParticleSelector.ixx

#include <SUSYTools/SUSYObjDef_xAOD.h>#include <XAMPPbase/AnalysisUtils.h>#include <XAMPPbase/ISystematics.h>#include <XAMPPbase/SUSYParticleSelector.h>

Defines

XAMPPbase_SUSYParticleSelector_IXX

file SUSYPhotonSelector.h

#include <XAMPPbase/IPhotonSelector.h>#include <XAMPPbase/SUSYParticleSelector.h>

file SUSYSystematics.h

#include <AsgTools/AnaToolHandle.h>#include <AsgTools/AsgTool.h>#include <AsgTools/ToolHandle.h>#include <SUSYTools/ISUSYObjDef_xAODTool.h>#include <XAMPPbase/ISystematics.h>

file SUSYTauSelector.h

#include <TauAnalysisTools/Enums.h>#include <TauAnalysisTools/TauEfficiencyCorrectionsTool.h>#include <XAMPPbase/ITauSelector.h>#include <XAMPPbase/ITriggerTool.h>#include <XAMPPbase/SUSYParticleSelector.h>#include <XAMPPbase/TauDecorations.h>

file SUSYTriggerTool.h

#include <AsgTools/AnaToolHandle.h>#include <AsgTools/AsgTool.h>#include <AsgTools/ToolHandle.h>#include <XAMPPbase/EventStorage.h>#include <XAMPPbase/ITriggerTool.h>#include <xAODBase/IParticleHelpers.h>#include <xAODCore/ShallowCopy.h>#include <XAMPPbase/SUSYTriggerTool.ixx>

file SUSYTriggerTool.ixx

#include <XAMPPbase/EventInfo.h>#include <XAMPPbase/EventStorage.h>#include <XAMPPbase/SUSYTriggerTool.h>#include <SUSYTools/SUSYObjDef_xAOD.h>#include <xAODBase/IParticleHelpers.h>#include <xAODCore/ShallowCopy.h>#include <PATInterfaces/SystematicSet.h>

Defines

XAMPPbase_SUSYTriggerTool_IXX

file SUSYTruthAnalysisHelper.h

#include <XAMPPbase/SUSYAnalysisHelper.h>

file SUSYTruthSelector.h

#include <XAMPPbase/AnalysisUtils.h>#include <XAMPPbase/ITruthSelector.h>#include <XAMPPbase/ParticleSelector.h>

file TauDecorations.h

#include <XAMPPbase/ParticleDecorations.h>#include <xAODTruth/TruthParticleContainer.h>

file ToolHandleSystematics.h

#include <XAMPPbase/Defs.h>#include <XAMPPbase/ISystematics.h>#include <AsgTools/AnaToolHandle.h>#include <AsgTools/ToolHandle.h>#include <PATInterfaces/SystematicCode.h>#include <PATInterfaces/SystematicSet.h>#include <XAMPPbase/ToolHandleSystematics.ixx>

file ToolHandleSystematics.ixx

#include <XAMPPbase/AnalysisUtils.h>#include <XAMPPbase/ToolHandleSystematics.h>#include “PATInterfaces/SystematicsUtil.h”

Defines

XAMPPbase_ToolHandleSystematics_IXX

file TreeBase.h

#include <XAMPPbase/EventInfo.h>#include <XAMPPbase/TreeHelpers.h>#include <AsgTools/ToolHandle.h>#include <algorithm>#include <cctype>#include <iostream>#include <memory>#include <string>#include <vector>#include “TFile.h”#include “TTree.h”

file TreeHelpers.h

#include <AsgTools/IAsgTool.h>#include <TMath.h>#include <TTree.h>#include <XAMPPbase/Defs.h>#include <xAODBase/IParticleContainer.h>#include <iostream>#include <memory>#include <XAMPPbase/TreeHelpers.ixx>

file TreeHelpers.ixx

#include <XAMPPbase/EventStorage.h>#include <XAMPPbase/TreeHelpers.h>#include <memory>

Defines

XAMPPBASE_TREEHELPERS_IXX

file TruthDecorations.h

#include <XAMPPbase/ParticleDecorations.h>#include <xAODTruth/TruthParticle.h>#include <xAODTruth/TruthParticleContainer.h>

file XAMPPbaseDict.h

#include <XAMPPbase/AnalysisConfig.h>#include <XAMPPbase/EventInfo.h>#include <XAMPPbase/MetaDataTree.h>#include <XAMPPbase/SUSYAnalysisHelper.h>#include <XAMPPbase/SUSYElectronSelector.h>#include <XAMPPbase/SUSYJetSelector.h>#include <XAMPPbase/SUSYMetSelector.h>#include <XAMPPbase/SUSYMuonSelector.h>#include <XAMPPbase/SUSYPhotonSelector.h>#include <XAMPPbase/SUSYSystematics.h>#include <XAMPPbase/SUSYTauSelector.h>#include <XAMPPbase/SUSYTriggerTool.h>#include <XAMPPbase/SUSYTruthAnalysisHelper.h>#include <XAMPPbase/SUSYTruthSelector.h>#include <XAMPPbase/PileupUtils.h>

file AnalysisUtils.cxx

#include <XAMPPmonoH/AnalysisUtils.h>

file AnalysisUtils.cxx

#include <PathResolver/PathResolver.h>#include <XAMPPbase/AnalysisUtils.h>#include <XAMPPbase/EventInfo.h>#include <XAMPPbase/ReconstructedParticles.h>#include <xAODBase/IParticleHelpers.h>#include <xAODEgamma/EgammaTruthxAODHelpers.h>#include <xAODEgamma/ElectronxAODHelpers.h>#include <MCTruthClassifier/MCTruthClassifierDefs.h>#include <TruthUtils/PIDHelpers.h>#include <boost/filesystem.hpp>#include <boost/regex.hpp>#include <iostream>#include <locale>#include <string>#include <CalcGenericMT2/MT2_ROOT.h>

file LikelihoodOrdering.cxx

#include <XAMPPmonoH/LikelihoodOrdering.h>#include <cmath>

file LinkDef.h

#include <XAMPPmonoH/MonoHAnalysisHelper.h>#include <XAMPPmonoH/MonoHTruthAnalysisHelper.h>#include <XAMPPmonoH/MonoHAnalysisConfig.h>#include <XAMPPmonoH/MonoHTruthSelector.h>#include <XAMPPmonoH/MonoHJetSelector.h>

file MonoHAnalysisConfig.cxx

#include <XAMPPmonoH/MonoHAnalysisConfig.h>

file MonoHAnalysisHelper.cxx

#include <XAMPPmonoH/MonoHAnalysisHelper.h>#include <XAMPPmonoH/MonoHTruthSelector.h>#include <XAMPPmonoH/AnalysisUtils.h>#include <XAMPPbase/ToolHandleSystematics.h>#include <AsgAnalysisInterfaces/IPileupReweightingTool.h>#include <XAMPPbase/SUSYTriggerTool.h>#include <MetTriggerSFUncertainties/IMetTriggerSF.h>#include <SMShapeUncertainties/ISMShapeWeights.h>#include <cmath>#include <PathResolver/PathResolver.h>#include <PileupReweighting/TPileupReweighting.h>#include <fstream>#include <iostream>#include <boost/format.hpp>

file MonoHJetSelector.cxx

#include <XAMPPmonoH/AnalysisUtils.h>#include <XAMPPmonoH/MonoHJetSelector.h>#include <XAMPPbase/ToolHandleSystematics.h>#include “xAODBase/IParticleHelpers.h”

file MonoHMetSelector.cxx

#include <XAMPPmonoH/MonoHMetSelector.h>#include <XAMPPbase/AnalysisUtils.h>#include <XAMPPbase/Defs.h>#include <XAMPPbase/EventInfo.h>#include <XAMPPbase/IElectronSelector.h>#include <XAMPPbase/IJetSelector.h>#include <XAMPPbase/IMuonSelector.h>#include <XAMPPbase/IPhotonSelector.h>#include <XAMPPbase/ISystematics.h>#include <XAMPPbase/ITauSelector.h>#include <MetTriggerSFUncertainties/IMetTriggerSF.h>

file MonoHTruthAnalysisHelper.cxx

#include <XAMPPmonoH/AnalysisUtils.h>#include <XAMPPmonoH/MonoHTruthAnalysisHelper.h>#include <PathResolver/PathResolver.h>#include <fstream>#include <iostream>

file MonoHTruthSelector.cxx

#include “XAMPPmonoH/MonoHTruthSelector.h”#include “XAMPPbase/AnalysisUtils.h”#include <algorithm>#include <iostream>

file AnalysisUtils.h

#include <XAMPPbase/AnalysisUtils.h>

file AnalysisUtils.h

#include <xAODBase/IParticleHelpers.h>#include <xAODParticleEvent/Particle.h>#include <xAODEgamma/Electron.h>#include <xAODEgamma/ElectronContainer.h>#include <xAODEgamma/Photon.h>#include <xAODEgamma/PhotonContainer.h>#include <xAODMuon/Muon.h>#include <xAODMuon/MuonContainer.h>#include <xAODTau/TauJet.h>#include <xAODTau/TauJetContainer.h>#include <xAODTruth/TruthParticle.h>#include <xAODTruth/TruthParticleContainer.h>#include <xAODTruth/TruthVertex.h>#include <xAODTruth/TruthVertexContainer.h>#include <xAODBTagging/BTagging.h>#include <xAODJet/Jet.h>#include <xAODJet/JetContainer.h>#include <xAODMissingET/MissingET.h>#include <xAODMissingET/MissingETContainer.h>#include <TMath.h>#include <XAMPPbase/Defs.h>#include <XAMPPbase/EventStorage.h>#include <fstream>#include <functional>#include <iostream>#include <vector>#include “FourMomUtils/xAODP4Helpers.h”#include “PATInterfaces/SystematicSet.h”#include “TLorentzVector.h”#include <AsgTools/AnaToolHandle.h>#include <AsgTools/AsgTool.h>#include <AsgTools/ToolHandle.h>

file LikelihoodOrdering.h

#include “xAODJet/Jet.h”#include “xAODMuon/Muon.h”#include “TLorentzVector.h”#include “TMath.h”#include <iostream>#include <vector>

file MonoHAnalysisConfig.h

#include <XAMPPbase/AnalysisConfig.h>

file MonoHAnalysisHelper.h

#include <XAMPPbase/SUSYAnalysisHelper.h>#include <XAMPPbase/SUSYTruthAnalysisHelper.h>

file MonoHJetSelector.h

#include <FTagAnalysisInterfaces/IBTaggingEfficiencyTool.h>#include <FTagAnalysisInterfaces/IBTaggingSelectionTool.h>#include <MuonSelectorTools/MuonSelectionTool.h>#include <XAMPPbase/IElectronSelector.h>#include <XAMPPbase/IMuonSelector.h>#include <XAMPPbase/SUSYJetSelector.h>#include “JetAnalysisInterfaces/IJetSelectorTool.h”

file MonoHMetSelector.h

#include <XAMPPbase/SUSYMetSelector.h>

file MonoHTruthAnalysisHelper.h

#include <XAMPPbase/SUSYAnalysisHelper.h>#include <XAMPPbase/SUSYTruthAnalysisHelper.h>#include <TRandom3.h>

file MonoHTruthSelector.h

#include “AthContainers/ConstDataVector.h”#include “TLorentzVector.h”#include “XAMPPbase/AnalysisUtils.h”#include “XAMPPbase/ITruthSelector.h”#include “XAMPPbase/SUSYTruthSelector.h”#include <memory>#include <utility>#include <vector>

Typedefs

typedef std::vector<TLorentzVector> FourMomentumContainer

file XAMPPmonoHDict.h

#include <XAMPPmonoH/MonoHAnalysisConfig.h>#include <XAMPPmonoH/MonoHAnalysisHelper.h>#include <XAMPPmonoH/MonoHJetSelector.h>#include <XAMPPmonoH/MonoHMetSelector.h>#include <XAMPPmonoH/MonoHTruthSelector.h>

file Analysis.cxx

#include <TSystem.h>#include <XAMPPplotting/Analysis.h>#include <XAMPPplotting/Cuts.h>#include <XAMPPplotting/EventService.h>#include <XAMPPplotting/Histo.h>#include <XAMPPplotting/HistoTemplates.h>#include <XAMPPplotting/TreeVarReader.h>#include <XAMPPplotting/Weight.h>#include <iomanip>#include <iostream>#include <sstream>

file AnalysisSetup.cxx

#include <XAMPPplotting/Analysis.h>#include <XAMPPplotting/AnalysisSetup.h>#include <XAMPPplotting/BTaggingScaleFactor.h>#include <XAMPPplotting/CombinatoricSelection.h>#include <XAMPPplotting/Cuts.h>#include <XAMPPplotting/DMXSecUpdater.h>#include <XAMPPplotting/DataDrivenWeights.h>#include <XAMPPplotting/EventDuplication.h>#include <XAMPPplotting/Histo.h>#include <XAMPPplotting/HistoTemplates.h>#include <XAMPPplotting/IfDefHelpers.h>#include <XAMPPplotting/LumiCalculator.h>#include <XAMPPplotting/MetaDataTreeReader.h>#include <XAMPPplotting/NTupleWriter.h>#include <XAMPPplotting/ParticleTagger.h>#include <XAMPPplotting/PlottingUtils.h>#include <XAMPPplotting/ReaderProvider.h>#include <XAMPPplotting/ReconstructedParticleReaders.h>#include <XAMPPplotting/TreeVarReader.h>#include <XAMPPplotting/UtilityReader.h>#include <XAMPPplotting/Weight.h>#include <TFile.h>#include <TSystem.h>#include <dirent.h>#include <fstream>#include <iomanip>#include <iostream>#include <map>#include <sstream>#include <string>

file ArithmetricReaders.cxx

#include <FourMomUtils/xAODP4Helpers.h>#include <XAMPPplotting/ArithmetricReaders.h>#include <XAMPPplotting/PlottingUtils.h>#include <XAMPPplotting/Weight.h>#include <cmath>

file BTaggingScaleFactor.cxx

file CombinatoricSelection.cxx

#include <XAMPPplotting/CombinatoricSelection.h>#include <XAMPPplotting/DataDrivenWeights.h>#include <XAMPPplotting/IfDefHelpers.h>#include <XAMPPplotting/PlottingUtils.h>#include <XAMPPplotting/TreeVarReader.h>#include <XAMPPplotting/TreeVarWriter.h>

file DataDrivenWeights.cxx

#include <PathResolver/PathResolver.h>#include <TFile.h>#include <XAMPPplotting/DataDrivenWeights.h>#include <XAMPPplotting/ObservableReader.h>#include <XAMPPplotting/PlottingUtils.h>#include <XAMPPplotting/ReaderProvider.h>#include <XAMPPplotting/UtilityReader.h>#include <functional>#include <numeric>#include <sstream>

file DMXSecUpdater.cxx

#include <XAMPPplotting/DMXSecUpdater.h>#include <XAMPPplotting/MetaDataTreeReader.h>#include <XAMPPplotting/PlottingUtils.h>#include <PathResolver/PathResolver.h>

file EventDuplication.cxx

#include <XAMPPplotting/EventDuplication.h>#include <XAMPPplotting/TreeVarReader.h>

file EventService.cxx

#include <XAMPPplotting/EventService.h>#include <XAMPPplotting/PlottingUtils.h>#include <XAMPPplotting/Selector.h>#include <XAMPPplotting/TreeVarReader.h>#include <XAMPPplotting/Weight.h>

file FinalPlotHelpers.cxx

#include <XAMPPplotting/FinalPlotHelpers.h>#include <XAMPPplotting/PlottingUtils.h>#include <TFile.h>#include <TH1.h>

file Histo.cxx

#include <TError.h>#include <TFile.h>#include <TH1D.h>#include <TH2D.h>#include <TH3D.h>#include <TMath.h>#include <iostream>#include <sstream>#include <PathResolver/PathResolver.h>#include <XAMPPplotting/Histo.h>#include <XAMPPplotting/HistoTemplates.h>#include <XAMPPplotting/LumiCalculator.h>#include <XAMPPplotting/ObservableReader.h>#include <XAMPPplotting/TreeVarReader.h>#include <XAMPPplotting/UtilityReader.h>#include <XAMPPplotting/Weight.h>

file HistoBins.cxx

#include <TError.h>#include <TFile.h>#include <TH1D.h>#include <TH2D.h>#include <TH3D.h>#include <TMath.h>#include <iostream>#include <sstream>#include <XAMPPplotting/Histo.h>#include <XAMPPplotting/HistoBins.h>#include <XAMPPplotting/HistoTemplates.h>#include <XAMPPplotting/TreeVarReader.h>#include <XAMPPplotting/UtilityReader.h>#include <XAMPPplotting/Weight.h>

file HistoTemplates.cxx

#include <TError.h>#include <TH1D.h>#include <TH2D.h>#include <TH3D.h>#include <TMath.h>#include <iostream>#include <sstream>#include <PathResolver/PathResolver.h>#include <XAMPPplotting/HistoTemplates.h>#include <XAMPPplotting/PlottingUtils.h>

file IfDefHelpers.cxx

#include <XAMPPplotting/IfDefHelpers.h>#include <XAMPPplotting/PlottingUtils.h>#include <XAMPPplotting/Weight.h>

file LumiCalculator.cxx

#include <XAMPPplotting/LumiCalculator.h>#include <XAMPPplotting/MetaDataTreeReader.h>#include <XAMPPplotting/PlottingUtils.h>#include <XAMPPplotting/Weight.h>#include <PathResolver/PathResolver.h>#include <PileupReweighting/PileupReweightingTool.h>

file MergeHelpers.cxx

#include <TFriendElement.h>#include <XAMPPplotting/MergeHelpers.h>#include <XAMPPplotting/PlottingUtils.h>

file MetaDataTreeReader.cxx

#include <XAMPPplotting/CombinatoricSelection.h>#include <XAMPPplotting/EventService.h>#include <XAMPPplotting/HistoTemplates.h>#include <XAMPPplotting/MetaDataTreeReader.h>#include <XAMPPplotting/ParticleTagger.h>#include <XAMPPplotting/PlottingUtils.h>#include <XAMPPplotting/Weight.h>#include <TFile.h>#include <TStopwatch.h>#include <TTree.h>#include <iostream>#include <sstream>

file NTupleWriter.cxx

#include <TSystem.h>#include <XAMPPplotting/DataDrivenWeights.h>#include <XAMPPplotting/NTupleWriter.h>#include <XAMPPplotting/TreeVarWriter.h>#include <XAMPPplotting/UtilityReader.h>#include <XAMPPplotting/Weight.h>

file ObservableReader.cxx

#include <FourMomUtils/xAODP4Helpers.h>#include <TRandom3.h>#include <XAMPPplotting/ArithmetricReaders.h>#include <XAMPPplotting/ObservableReader.h>#include <XAMPPplotting/ReaderProvider.h>#include <XAMPPplotting/ReconstructedParticleReaders.h>#include <XAMPPplotting/UtilityReader.h>#include <XAMPPplotting/Weight.h>

file ParticleTagger.cxx

#include <XAMPPplotting/ObservableReader.h>#include <XAMPPplotting/ParticleTagger.h>#include <XAMPPplotting/ReconstructedParticleReaders.h>#include <XAMPPplotting/TreeVarReader.h>#include <XAMPPplotting/Cuts.h>#include <XAMPPplotting/PlottingUtils.h>#include <XAMPPplotting/ReaderProvider.h>#include <XAMPPplotting/Weight.h>

file PlottingUtils.cxx

#include <PathResolver/PathResolver.h>#include <TH2Poly.h>#include <XAMPPplotting/Cuts.h>#include <XAMPPplotting/Histo.h>#include <XAMPPplotting/IfDefHelpers.h>#include <XAMPPplotting/ParticleTagger.h>#include <XAMPPplotting/PlottingUtils.h>#include <XAMPPplotting/ReaderProvider.h>#include <XAMPPplotting/ReconstructedParticleReaders.h>#include <XAMPPplotting/TreeVarReader.h>#include <XAMPPplotting/TreeVarWriter.h>#include <XAMPPplotting/Weight.h>#include <dirent.h>#include <algorithm>#include <cfloat>#include <climits>#include <cmath>#include <cstdlib>#include <fstream>#include <iomanip>#include <iostream>#include <sstream>

file ReaderProvider.cxx

#include <XAMPPplotting/ArithmetricReaders.h>#include <XAMPPplotting/CombinatoricSelection.h>#include <XAMPPplotting/IfDefHelpers.h>#include <XAMPPplotting/ObservableReader.h>#include <XAMPPplotting/ParticleTagger.h>#include <XAMPPplotting/PlottingUtils.h>#include <XAMPPplotting/ReaderProvider.h>#include <XAMPPplotting/ReconstructedParticleReaders.h>#include <XAMPPplotting/TreeVarReader.h>#include <XAMPPplotting/UtilityReader.h>

file ReconstructedParticleReaders.cxx

#include <FourMomUtils/xAODP4Helpers.h>#include <XAMPPplotting/PlottingUtils.h>#include <XAMPPplotting/ReconstructedParticleReaders.h>#include <XAMPPplotting/Weight.h>#include <algorithm>#include <stdexcept>

file SampleHisto.cxx

#include <XAMPPplotting/FinalPlotHelpers.h>#include <XAMPPplotting/PlottingUtils.h>#include <XAMPPplotting/SampleHisto.h>#include <TFile.h>#include <TH1D.h>#include <TH2D.h>#include <TH3D.h>

file Selector.cxx

#include <XAMPPplotting/Histo.h>#include <XAMPPplotting/HistoTemplates.h>#include <XAMPPplotting/MetaDataTreeReader.h>#include <XAMPPplotting/Selector.h>#include <XAMPPplotting/TreeVarReader.h>#include <XAMPPplotting/Weight.h>#include <TSystem.h>

file TreeVarReader.cxx

#include <XAMPPplotting/ArithmetricReaders.h>#include <XAMPPplotting/PlottingUtils.h>#include <XAMPPplotting/TreeVarReader.h>#include <XAMPPplotting/TreeVarWriter.h>#include <XAMPPplotting/UtilityReader.h>#include <XAMPPplotting/Cuts.h>#include <XAMPPplotting/Weight.h>#include <cmath>#include <functional>#include <sstream>

file TreeVarWriter.cxx

#include <XAMPPplotting/PlottingUtils.h>#include <XAMPPplotting/TreeVarWriter.h>#include <cmath>#include <sstream>

file UtilityReader.cxx

#include <XAMPPplotting/AnalysisSetup.h>#include <XAMPPplotting/ArithmetricReaders.h>#include <XAMPPplotting/Cuts.h>#include <XAMPPplotting/DataDrivenWeights.h>#include <XAMPPplotting/HistoTemplates.h>#include <XAMPPplotting/LumiCalculator.h>#include <XAMPPplotting/ObservableReader.h>#include <XAMPPplotting/ReaderProvider.h>#include <XAMPPplotting/ReconstructedParticleReaders.h>#include <XAMPPplotting/TreeVarReader.h>#include <XAMPPplotting/UtilityReader.h>#include <XAMPPplotting/Weight.h>#include <TH1D.h>

file Weight.cxx

#include <XAMPPplotting/LumiCalculator.h>#include <XAMPPplotting/ReconstructedParticleReaders.h>#include <XAMPPplotting/UtilityReader.h>#include <XAMPPplotting/Weight.h>#include <PATInterfaces/SystematicRegistry.h>#include <PATInterfaces/SystematicsUtil.h>#include <PathResolver/PathResolver.h>#include <PileupReweighting/PileupReweightingTool.h>

file Analysis.h

#include <TFile.h>#include <TStopwatch.h>#include <TTree.h>#include <XAMPPplotting/EventService.h>#include <map>#include <memory>#include <string>#include <vector>

file AnalysisSetup.h

#include <XAMPPplotting/Analysis.h>#include <XAMPPplotting/IfDefHelpers.h>#include <XAMPPplotting/PlottingUtils.h>#include <map>#include <memory>#include <string>#include <vector>

file ArithmetricReaders.h

#include <XAMPPplotting/TreeVarReader.h>#include <cmath>#include <fstream>#include <functional>#include <map>#include <memory>#include <set>#include <sstream>

file BTaggingScaleFactor.h

file CombinatoricSelection.h

#include <XAMPPplotting/EventService.h>#include <XAMPPplotting/NTupleWriter.h>#include <XAMPPplotting/PlottingUtils.h>#include <XAMPPplotting/TreeVarReader.h>#include <XAMPPplotting/Weight.h>

file DataDrivenWeights.h

#include <TF1.h>#include <TH1.h>#include <XAMPPplotting/CombinatoricSelection.h>#include <XAMPPplotting/IfDefHelpers.h>#include <XAMPPplotting/Weight.h>#include <fstream>#include <iostream>#include <map>#include <memory>#include <string>#include <vector>

file DMXSecUpdater.h

#include <string>

file EventDuplication.h

#include <XAMPPplotting/Selector.h>

file EventService.h

#include <TFriendElement.h>#include <TTree.h>#include <XAMPPplotting/PlottingUtils.h>#include <cmath>#include <fstream>#include <map>#include <memory>#include <set>#include <sstream>#include <string>#include <vector>

file FinalPlotHelpers.h

#include <TFile.h>#include <XAMPPplotting/PlottingUtils.h>#include <map>#include <memory>#include <string>#include <vector>

file Histo.h

#include <TH1D.h>#include <TH2D.h>#include <TH2Poly.h>#include <TH3D.h>#include <TFile.h>#include <map>#include <set>#include <XAMPPplotting/HistoBins.h>#include <XAMPPplotting/HistoTemplates.h>#include <vector>

file HistoBins.h

#include <XAMPPplotting/PlottingUtils.h>#include <TH1D.h>#include <TH2D.h>#include <TH2Poly.h>#include <TH3D.h>#include <TFile.h>#include <map>#include <memory>#include <set>#include <vector>

file HistoTemplates.h

#include <TH1.h>#include <TH2Poly.h>#include <fstream>#include <iostream>#include <map>#include <memory>#include <string>

file IfDefHelpers.h

#include <map>#include <memory>#include <string>#include <vector>

file LumiCalculator.h

#include <memory>#include <string>#include <vector>

file MergeHelpers.h

#include <TFile.h>#include <TTree.h>#include <XAMPPplotting/PlottingUtils.h>#include <memory>#include <vector>

file MetaDataTreeReader.h

#include <TFile.h>#include <TTree.h>#include <iostream>#include <memory>#include <set>#include <string>#include <vector>

file NTupleWriter.h

#include <XAMPPplotting/Analysis.h>#include <XAMPPplotting/TreeVarWriter.h>#include <map>

file ObservableReader.h

#include <XAMPPplotting/TreeVarReader.h>#include <cmath>#include <fstream>#include <functional>#include <map>#include <set>#include <sstream>

file ParticleTagger.h

#include <XAMPPplotting/PlottingUtils.h>#include <XAMPPplotting/TreeVarReader.h>#include <XAMPPplotting/Cuts.h>#include <map>#include <memory>#include <string>#include <vector>

file PlottingUtils.h

#include <XAMPPplotting/Cuts.h>#include <cfloat>#include <climits>#include <cmath>#include <fstream>#include <future>#include <iostream>#include <memory>#include <set>#include <string>#include <thread>#include <vector>

file ReaderProvider.h

#include <fstream>#include <iostream>#include <string>#include <vector>#include <XAMPPplotting/IfDefHelpers.h>#include <XAMPPplotting/PlottingUtils.h>

file ReconstructedParticleReaders.h

#include <XAMPPplotting/ArithmetricReaders.h>#include <XAMPPplotting/ObservableReader.h>#include <XAMPPplotting/TreeVarReader.h>#include <cmath>#include <sstream>

file SampleHisto.h

#include <map>#include <memory>#include <set>#include <vector>#include <XAMPPplotting/Histo.h>#include <XAMPPplotting/HistoTemplates.h>#include <XAMPPplotting/PlottingUtils.h>#include <TH1.h>

file Selector.h

#include <XAMPPplotting/Analysis.h>#include <XAMPPplotting/EventService.h>#include <XAMPPplotting/PlottingUtils.h>#include <map>

file TreeVarReader.h

#include <fstream>#include <iostream>#include <map>#include <memory>#include <string>#include <vector>#include <TLorentzVector.h>#include <TTree.h>#include <XAMPPplotting/EventService.h>#include <XAMPPplotting/IfDefHelpers.h>#include <XAMPPplotting/PlottingUtils.h>#include <XAMPPplotting/TreeVarReader.ixx>

file TreeVarReader.ixx

#include <XAMPPplotting/TreeVarReader.h>

file TreeVarWriter.h

#include <XAMPPplotting/TreeVarReader.h>#include <TLorentzVector.h>#include <TTree.h>#include <fstream>#include <iostream>#include <map>#include <memory>#include <string>#include <vector>#include <XAMPPplotting/TreeVarWriter.ixx>

file TreeVarWriter.ixx

#include <XAMPPplotting/PlottingUtils.h>#include <XAMPPplotting/TreeVarWriter.h>

file UtilityReader.h

#include <XAMPPplotting/TreeVarReader.h>#include <cmath>#include <fstream>#include <map>#include <memory>#include <set>#include <sstream>

file Weight.h

#include <AsgTools/ToolHandle.h>#include <TTree.h>#include <PATInterfaces/SystematicSet.h>#include <XAMPPplotting/EventService.h>#include <XAMPPplotting/MetaDataTreeReader.h>#include <XAMPPplotting/TreeVarReader.h>#include <xAODEventInfo/EventInfo.h>#include <xAODEventInfo/EventInfoAuxContainer.h>#include <xAODEventInfo/EventInfoContainer.h>#include <string>#include <vector>

file XAMPPplottingDict.h

#include <XAMPPplotting/Analysis.h>#include <XAMPPplotting/AnalysisSetup.h>#include <XAMPPplotting/ArithmetricReaders.h>#include <XAMPPplotting/BTaggingScaleFactor.h>#include <XAMPPplotting/Cuts.h>#include <XAMPPplotting/DMXSecUpdater.h>#include <XAMPPplotting/DataDrivenWeights.h>#include <XAMPPplotting/EventDuplication.h>#include <XAMPPplotting/EventService.h>#include <XAMPPplotting/FinalPlotHelpers.h>#include <XAMPPplotting/Histo.h>#include <XAMPPplotting/HistoBins.h>#include <XAMPPplotting/HistoTemplates.h>#include <XAMPPplotting/IfDefHelpers.h>#include <XAMPPplotting/LumiCalculator.h>#include <XAMPPplotting/MergeHelpers.h>#include <XAMPPplotting/MetaDataTreeReader.h>#include <XAMPPplotting/NTupleWriter.h>#include <XAMPPplotting/ObservableReader.h>#include <XAMPPplotting/ParticleTagger.h>#include <XAMPPplotting/PlottingUtils.h>#include <XAMPPplotting/ReaderProvider.h>#include <XAMPPplotting/ReconstructedParticleReaders.h>#include <XAMPPplotting/SampleHisto.h>#include <XAMPPplotting/Selector.h>#include <XAMPPplotting/TreeVarReader.h>#include <XAMPPplotting/TreeVarWriter.h>#include <XAMPPplotting/UtilityReader.h>#include <XAMPPplotting/Weight.h>

dir /builds/atlas-mpp-xampp/XAMPPmonoH/XAMPPmonoH/Root

dir /builds/atlas-mpp-xampp/XAMPPmonoH/XAMPPplotting/Root

dir /builds/atlas-mpp-xampp/XAMPPmonoH/XAMPPbase/XAMPPbase/Root

dir /builds/atlas-mpp-xampp/XAMPPmonoH/XAMPPbase/XAMPPbase/XAMPPbase

dir /builds/atlas-mpp-xampp/XAMPPmonoH/XAMPPbase/XAMPPbase

dir /builds/atlas-mpp-xampp/XAMPPmonoH/XAMPPbase

dir /builds/atlas-mpp-xampp/XAMPPmonoH/XAMPPmonoH/XAMPPmonoH

dir /builds/atlas-mpp-xampp/XAMPPmonoH/XAMPPplotting/XAMPPplotting

dir /builds/atlas-mpp-xampp/XAMPPmonoH/XAMPPplotting