DerivationFramework Namespace Reference

THE reconstruction tool. More...

Namespaces
namespace	CellsInCone
namespace	ClustersInCone
namespace	TriggerMatchingUtils

Classes
class	AnalysisMuonThinningAlg
class	AnyVertexSkimmingTool
class	AsgSelectionToolWrapper
class	AugmentationToolExample
class	AugmentationToolLeadingJets
class	AugOriginalCounts
	Augmentation with primary vertex counts (before thinning) More...
class	BadBatmanAugmentationTool
class	BkgElectronClassification
class	Bmumu_metadata
	Store JO metadata specific to the Bmumu analysis. More...
class	BoostedHadTopAndTopPairFilterAugmentation
class	BoostedHadTopAndTopPairFilterTool
class	BPhysBGammaFinder
class	BPhysMetadataBase
class	BPhysPVCascadeTools
class	BPhysPVThinningTool
class	BPhysPVTools
class	CaloCellDecorator
class	CaloClusterThinning
class	CaloIsolationDecorAlg
class	CascadeTools
class	CfAthAlgTool
class	ClassifyAndCalculateHFAugmentation
class	ClassifyAndCalculateHFTool
class	ClusterEnergyPerLayerDecorator
	Decorate egamma objects with the energy per layer for a rectangular cluster of size neta X nphi built on the fly. More...
class	CollectionMakerHelpers
struct	Combination
class	CommonAugmentation
class	CompactHardTruth
struct	DecayGraphHelper
class	DeltaRTool
class	DerivationKernel
class	DESDM_EXOTHIP_SkimmingTool
class	DiMuonTaggingAlg
class	DiphotonVertexDecorator
class	DistanceInTrainAugmentationTool
class	DiTauChargeDecorator
class	DiTauIDDecoratorWrapper
class	DiTauTrackParticleThinning
class	DRAW_ZMUMUSkimmingTool
	the code used in this implementation is kindly stolen from: atlasoff:: ISF/ISF_Core/ISF_Tools More...
class	DStarSelectionTool
class	EGammaClusterCoreCellRecovery
class	EGammaCookieCutClusterTool
class	EGammaGSFCalo
class	EgammaTrackParticleThinning
class	EGammaTracksThinning
class	EGElectronAmbiguityTool
class	EGElectronLikelihoodToolWrapper
class	EGInvariantMassTool
class	EGPhotonCleaningWrapper
class	EGSelectionToolWrapper
class	EGTransverseMassTool
class	EventInfoBSErrDecorator
class	EventInfoPixelModuleStatusMonitoring
class	FilterCombinationAND
	the code used in this implementation is kindly stolen from: atlasoff:: ISF/ISF_Core/ISF_Tools More...
class	FilterCombinationOR
	the code used in this implementation is kindly stolen from: atlasoff:: ISF/ISF_Core/ISF_Tools More...
class	FourLeptonVertexingAlgorithm
class	FourMuonTool
class	GainDecorator
class	GenericObjectThinning
class	GenericTruthThinning
class	GenFilterTool
class	GoodRunsListFilterAlgorithm
class	HadronOriginClassifier
class	HadronOriginDecorator
class	HardScatterVertexDecorator
class	HardTruthThinning
class	HICentralityDecorationTool
class	HIGlobalAugmentationTool
class	HIJetAugmentationTool
class	HITrackParticleThinningTool
class	HITrackQualityAugmentationTool
class	IAugmentationTool
class	IDTrackCaloDepositsDecoratorAlg
class	InDetTrackSelectionToolWrapper
class	InvariantMassTool
class	ISkimmingTool
class	IsolationTrackDecorator
class	IThinningTool
class	JetCaloClusterThinning
class	JetConstituentThinning
class	JetGhostThinning
class	JetLargeD0TrackParticleThinning
class	JetMatchingTool
class	JetMSVAugmentation
class	JetTrackParticleThinning
class	JpsiPlusDpstCascade
class	JpsiPlusDs1Cascade
class	JpsiPlusDsCascade
class	JpsiPlusPsiCascade
class	JpsiPlusV0Cascade
class	JpsiUpsilonCommon
class	JpsiXPlus2V0
class	JpsiXPlusDisplaced
class	LockDecorations
	Algorithm to explicitly lock a set of decorations. More...
class	MaxCellDecorator
class	MbtsToVectorsTool
class	MenuTruthThinning
class	MergedElectronDetailsDecorator
class	METRemappingAlg
class	MuonExtrapolationTool
class	MuonJetDrTool
class	MuonTPExtrapolationAlg
class	MuonTrackParticleThinning
class	MuonTruthClassifierFallback
class	MuonTruthIsolationDecorAlg
class	MuPlusDpstCascade
class	MuPlusDsCascade
class	NTUPStringSkimmingTool
class	PdgConditional
class	PFlowAugmentationTool
class	PflowIsolationDecorAlg
class	PhotonsDirectionTool
class	PhotonVertexSelectionWrapper
class	PixeldEdxTrackParticleThinning
class	PixelNtupleMaker
class	PrescaleTool
class	PseudoTrackSelector
	Class-algorithm for pseudo track selection. More...
class	PsiPlusPsiCascade
class	PsiPlusPsiSingleVertex
class	RCJetSubstructureAug
class	Reco_4mu
class	Reco_mumu
class	Reco_V0Finder
class	Reco_Vertex
class	ReVertex
class	SaturatedTriggerTower
class	Select_onia2mumu
class	SkimmingToolExample
	the code used in this implementation is kindly stolen from: atlasoff:: ISF/ISF_Core/ISF_Tools More...
class	SkimmingToolHIGG1
class	SkimmingToolHIGG2
class	SkimmingToolHIGG5VBF
class	SUSYSignalTagger
class	SV1TrackThinning
class	TagAndProbeTrackParticleThinning
class	TauIDDecoratorWrapper
class	TauJets_LepRMParticleThinning
class	TauThinningTool
class	TauTrackParticleThinning
class	TauTruthMatchingWrapper
class	Thin_vtxDuplicates
class	Thin_vtxTrk
class	ThinningToolExample
class	TileCellsDecorator
class	TileCellsMuonDecorator
class	TopHeavyFlavorFilterAugmentation
class	TrackIsolationDecorAlg
class	TrackMeasurementThinning
class	TrackParametersAtPV
	the code used in this implementation is kindly stolen from: atlasoff:: ISF/ISF_Core/ISF_Tools More...
class	TrackParametersKVU
	the code used in this implementation is kindly stolen from: atlasoff:: ISF/ISF_Core/ISF_Tools More...
class	TrackParticleCaloCellDecorator
class	TrackParticleThinning
struct	TracksInCone
class	TrackStateOnSurfaceDecorator
class	TrackToVertexWrapper
class	TriggerGenericObjectThinningTool
class	TriggerMatchingTool
	Tool to perform trigger matching in the derivation framework. More...
class	TriggerSkimmingTool
class	TriggerTowerThinningAlg
class	TruthBornLeptonCollectionMaker
class	TruthCategoriesDecorator
class	TruthClassificationDecorator
class	TruthCollectionMaker
class	TruthCollectionMakerTau
class	TruthD2Decorator
class	TruthDecayCollectionMaker
class	TruthDressingTool
class	TruthEDDecorator
class	TruthIsolationTool
class	TruthLinkRepointTool
class	TruthMetaDataWriter
class	TruthNavigationDecorator
class	TruthPVCollectionMaker
class	TruthQGDecorationTool
class	TTbarPlusHeavyFlavorFilterTool
class	TVAAugmentationTool
class	UFOTrackParticleThinning
class	UnassociatedHitsDecorator
class	UnassociatedHitsGetterTool
class	UsedInVertexFitTrackDecorator
class	VertexPlus1TrackCascade
class	VertexTrackIsolation
class	ViewContainerThinning
class	VSITrackParticleThinning
class	xAODStringSkimmingTool
class	ZeeVertexRefittingTool

Typedefs
typedef ElementLink< xAOD::VertexContainer >	VertexLink
typedef std::vector< VertexLink >	VertexLinkVector
typedef std::vector< const xAOD::TrackParticle * >	TrackBag
typedef ElementLink< xAOD::MuonContainer >	MuonsLink
typedef std::vector< MuonsLink >	MuonsLinkVector
typedef ElementLink< xAOD::TrackParticleContainer >	TrackParticleLink
typedef std::vector< TrackParticleLink >	TrackParticleLinkVector

Enumerations
enum	EEGInvariantMassToolParser { kParser1 , kParser2 , kNumEGInvariantMassToolParser }
enum	EJetTrPThinningParser {   kJetSelection , kTrackThinning , kNumJetTPThinningParser , kJetSelection ,   kTrackThinning , kNumJetTPThinningParser }
enum	EJetTrPThinningParser {   kJetSelection , kTrackThinning , kNumJetTPThinningParser , kJetSelection ,   kTrackThinning , kNumJetTPThinningParser }
enum	EJetParser { kRCJetSelection , kNumJetParser }
enum	EDvTrPThinningParser { kDvSelection , kdvTrackThinning , kNumDvTPThinningParser }
enum	EGenericTruthThinningParser { kGenericTruthThinningPartParser , kGenericTruthThinningParserNum }
enum	SUSYCountIndices {   chi01 , chi02 , chi03 , chi04 ,   ch1plus , ch1minus , ch2plus , ch2minus ,   gluino , squark , antisquark , sbottom ,   stop , sbottom2 , stop2 , antisbottom ,   antistop , antisbottom2 , antistop2 , selecRminus ,   selecRplus , selecLminus , selecLplus , selnuL ,   smuonRminus , smuonRplus , smuonLminus , smuonLplus ,   smunuL , stau1minus , stau1plus , stau2minus ,   stau2plus , staunuL , unattributed , nParticleIndices }
enum	EDeltaRToolParser { kDeltaRToolParser1 , kDeltaRToolParser2 , kDeltaRToolParserNum }
enum	EInvariantMassToolParser { kInvariantMassToolParser1 , kInvariantMassToolParser2 , kInvariantMassToolParserNum }

Functions
double	deltaR (double eta1, double eta2, double phi1, double phi2)
template<class T_Parent, class T_Cont>
void	createDecoratorKeys (T_Parent &parent, const SG::ReadHandleKey< T_Cont > &container_key, const std::string &prefix, const std::vector< std::string > &decor_names, std::vector< SG::WriteDecorHandleKey< T_Cont > > &decor_out)
template<class T_Cont, class T>
std::vector< SG::WriteDecorHandle< T_Cont, T > >	createDecorators (const std::vector< SG::WriteDecorHandleKey< T_Cont > > &keys, const EventContext &ctx)
static bool	isFromWZTau (unsigned int orig)
template<class dType, class ContType>
SG::WriteDecorHandle< ContType, dType >	makeHandle (const EventContext &ctx, const SG::WriteDecorHandleKey< ContType > &key, const dType &defValue=dType{})
int	gluinoSquarkClassification (const std::array< int, 35 > &c)
int	gauginoPairProduction (const std::array< int, 35 > &c)
int	slepton (const std::array< int, 35 > &c)
int	smuon (const std::array< int, 35 > &c)
unsigned int	finalStateID (const int SUSY_Spart1_pdgId, const int SUSY_Spart2_pdgId)
int	gluinoSquarkClassification (const std::array< int, nParticleIndices > &c)
int	gauginoPairProduction (const std::array< int, nParticleIndices > &c)
int	slepton (const std::array< int, nParticleIndices > &c)
int	smuon (const std::array< int, nParticleIndices > &c)

Variables
constexpr double	s_CONST = 1000./299.792
static const SG::AuxElement::Decorator< float >	sumPt2 ("sumPt2")
static const SG::AuxElement::Decorator< float >	vertices_dPhi ("vertices_dPhi")
static const SG::AuxElement::Decorator< float >	vertices_sumPt ("vertices_sumPt")
static const SG::AuxElement::Decorator< float >	vertices_sumPt2 ("vertices_sumPt2")
static const SG::AuxElement::Decorator< std::vector< ElementLink< xAOD::TrackParticleContainer > > >	electronTrackLinksDecor ("ElectronTrackLinks")

Detailed Description

THE reconstruction tool.

wrapper tool for tau truth matching

wrapper tool for decorating tau ID scores and WPs

Class holding an int or some function of an int for use in categorisation of pdg codes.

Algorithm to store decorate the IParticle with all energy deposits in the calorimeter needed for post fine tuning of the cut-based calorimeter tagging working points.

Algorithm to decorate the calorimeter isolation variables to the track particles.

refit the primary vertex after removing the tracks of electrons from a Z->ee decay to imitate the primary vertex reconstruction in H->yy events with unconverted photons

Algorithm that refits all possible four lepton combinations to a common space point.

THE candidate selection tool.

Leptons are selected by exploting the common CP tools / Loose cut on the delta Z0 of the associated tracks is applied to avoid hopeless fits

The tool adds the following three decorations Vector containing all energy deposits std::vector<float> CaloDeposits Vector containing all energy losses std::vector<float> CaloElosses Vector declaring the type of the deposit/loss (EMB1,HEC0,etc.) std::vector<unit_16> CaloDepType Deposits can be either saved to the Muon particle itself or to the associated ID track particle However, in the latter case, the first ID track from the container is always decorated to ensure file integrety

Typedef Documentation

MuonsLink

typedef ElementLink<xAOD::MuonContainer> DerivationFramework::MuonsLink

Definition at line 35 of file MuPlusDsCascade.cxx.

MuonsLinkVector

typedef std::vector<MuonsLink> DerivationFramework::MuonsLinkVector

Definition at line 36 of file MuPlusDsCascade.cxx.

TrackBag

typedef std::vector< const xAOD::TrackParticle * > DerivationFramework::TrackBag

Definition at line 25 of file JpsiPlusDpstCascade.cxx.

TrackParticleLink

typedef ElementLink<xAOD::TrackParticleContainer> DerivationFramework::TrackParticleLink

Definition at line 22 of file PsiPlusPsiSingleVertex.cxx.

TrackParticleLinkVector

typedef std::vector<TrackParticleLink> DerivationFramework::TrackParticleLinkVector

Definition at line 23 of file PsiPlusPsiSingleVertex.cxx.

VertexLink

typedef ElementLink< xAOD::VertexContainer > DerivationFramework::VertexLink

Definition at line 23 of file JpsiPlusDpstCascade.cxx.

VertexLinkVector

typedef std::vector< VertexLink > DerivationFramework::VertexLinkVector

Definition at line 24 of file JpsiPlusDpstCascade.cxx.

Enumeration Type Documentation

EDeltaRToolParser

enum DerivationFramework::EDeltaRToolParser

Enumerator
kDeltaRToolParser1
kDeltaRToolParser2
kDeltaRToolParserNum

Definition at line 23 of file DeltaRTool.h.

{kDeltaRToolParser1,kDeltaRToolParser2,kDeltaRToolParserNum};

EDvTrPThinningParser

enum DerivationFramework::EDvTrPThinningParser

Enumerator
kDvSelection
kdvTrackThinning
kNumDvTPThinningParser

Definition at line 28 of file VSITrackParticleThinning.h.

{ kDvSelection, kdvTrackThinning, kNumDvTPThinningParser};

EEGInvariantMassToolParser

enum DerivationFramework::EEGInvariantMassToolParser

Enumerator
kParser1
kParser2
kNumEGInvariantMassToolParser

Definition at line 25 of file EGInvariantMassTool.h.

{
  kParser1,
  kParser2,
  kNumEGInvariantMassToolParser
};

EGenericTruthThinningParser

enum DerivationFramework::EGenericTruthThinningParser

Enumerator
kGenericTruthThinningPartParser
kGenericTruthThinningParserNum

Definition at line 27 of file GenericTruthThinning.h.

{ kGenericTruthThinningPartParser,kGenericTruthThinningParserNum };

EInvariantMassToolParser

enum DerivationFramework::EInvariantMassToolParser

Enumerator
kInvariantMassToolParser1
kInvariantMassToolParser2
kInvariantMassToolParserNum

Definition at line 25 of file InvariantMassTool.h.

{ kInvariantMassToolParser1, kInvariantMassToolParser2, kInvariantMassToolParserNum };

EJetParser

enum DerivationFramework::EJetParser

Enumerator
kRCJetSelection
kNumJetParser

Definition at line 27 of file RCJetSubstructureAug.h.

{ kRCJetSelection , kNumJetParser };

EJetTrPThinningParser [1/2]

enum DerivationFramework::EJetTrPThinningParser

Enumerator
kJetSelection
kTrackThinning
kNumJetTPThinningParser
kJetSelection
kTrackThinning
kNumJetTPThinningParser

Definition at line 27 of file JetTrackParticleThinning.h.

{ kJetSelection, kTrackThinning, kNumJetTPThinningParser};

EJetTrPThinningParser [2/2]

enum DerivationFramework::EJetTrPThinningParser

Enumerator
kJetSelection
kTrackThinning
kNumJetTPThinningParser
kJetSelection
kTrackThinning
kNumJetTPThinningParser

Definition at line 27 of file JetLargeD0TrackParticleThinning.h.

{ kJetSelection, kTrackThinning, kNumJetTPThinningParser};

SUSYCountIndices

enum DerivationFramework::SUSYCountIndices

Enumerator
chi01
chi02
chi03
chi04
ch1plus
ch1minus
ch2plus
ch2minus
gluino
squark
antisquark
sbottom
stop
sbottom2
stop2
antisbottom
antistop
antisbottom2
antistop2
selecRminus
selecRplus
selecLminus
selecLplus
selnuL
smuonRminus
smuonRplus
smuonLminus
smuonLplus
smunuL
stau1minus
stau1plus
stau2minus
stau2plus
staunuL
unattributed
nParticleIndices

Definition at line 10 of file utilityFunctions.h.

                       {
    chi01, chi02, chi03, chi04, ch1plus, ch1minus, ch2plus, ch2minus, gluino, squark,
    antisquark, sbottom, stop, sbottom2, stop2, antisbottom, antistop, antisbottom2, 
    antistop2, selecRminus, selecRplus, selecLminus, selecLplus, selnuL, 
    smuonRminus, smuonRplus, smuonLminus, smuonLplus, smunuL, stau1minus, stau1plus,
    stau2minus, stau2plus, staunuL, unattributed, nParticleIndices
  };

Function Documentation

createDecoratorKeys()

template<class T_Parent, class T_Cont>

void DerivationFramework::createDecoratorKeys	(	T_Parent &	parent,
		const SG::ReadHandleKey< T_Cont > &	container_key,
		const std::string &	prefix,
		const std::vector< std::string > &	decor_names,
		std::vector< SG::WriteDecorHandleKey< T_Cont > > &	decor_out )

Definition at line 20 of file DecoratorUtils.h.

                                                                              {
    decor_out.clear();
    decor_out.reserve(decor_names.size());
    for (const std::string &a_decor_name : decor_names) {
      assert( !a_decor_name.empty() );
      decor_out.push_back(SG::WriteDecorHandleKey<T_Cont>(container_key.key()+"."+prefix+a_decor_name) );
    }
 
    for (SG::WriteDecorHandleKey<T_Cont> &a_decor_handle_key : decor_out) {
      // need to declare handles, otherwise the scheduler would not pick up the data dependencies
      // introduced by the decorations
      parent.declare(a_decor_handle_key);
      a_decor_handle_key.setOwner(&parent);
      if (a_decor_handle_key.initialize().isFailure()) {
         std::stringstream msg;
         msg << "Failed to initialize " << a_decor_handle_key.key() << " after initializing: ";
         for (SG::WriteDecorHandleKey<T_Cont> &b_decor_handle_key : decor_out) {
            if (&b_decor_handle_key == &a_decor_handle_key) break;
            msg << " " << b_decor_handle_key.key();
         }
         throw std::runtime_error(msg.str());
      }
    }
  }

createDecorators()

template<class T_Cont, class T>

std::vector< SG::WriteDecorHandle< T_Cont, T > > DerivationFramework::createDecorators	(	const std::vector< SG::WriteDecorHandleKey< T_Cont > > &	keys,
		const EventContext &	ctx )

Definition at line 51 of file DecoratorUtils.h.

                                              {
    std::vector<SG::WriteDecorHandle<T_Cont,T> > out;
    out.reserve(keys.size());
    for( const SG::WriteDecorHandleKey<T_Cont> &a_key : keys) {
      out.push_back(SG::WriteDecorHandle<T_Cont,T>(a_key,ctx));
      if (not out.back().isValid()) {
        std::stringstream msg;
        msg << "Failed to create decorator handdle " << a_key.key();
        throw std::runtime_error( msg.str() );
      }
    }
    return out;
  }

deltaR()

double DerivationFramework::deltaR	(	double	eta1,
		double	eta2,
		double	phi1,
		double	phi2 )

Definition at line 47 of file HIJetAugmentationTool.cxx.

                                                                    {
    double deltaPhi = TVector2::Phi_mpi_pi(phi1 - phi2);
    double deltaEta = eta1 - eta2;
    return std::sqrt(deltaEta * deltaEta + deltaPhi * deltaPhi);
  }

finalStateID()

unsigned int DerivationFramework::finalStateID	(	const int	SUSY_Spart1_pdgId,
		const int	SUSY_Spart2_pdgId )

Definition at line 135 of file utilityFunctions.cxx.

                                                                        {
    std::array<int, nParticleIndices> particleCountByType{};
    std::array<PdgConditional,34> conditions{
      unsigned(1000022), //unsigned number does an std::abs before comparison
      unsigned(1000023),
      unsigned(1000025),
      unsigned(1000035),
      1000024, //signed int does a straight equality comparison
      -1000024,
      1000037,
      -1000037,
      1000021,
      //insert a lambda to do the comparison
      PdgConditional([](int pdgId)->bool{return ((std::abs(pdgId)>1000000 && std::abs(pdgId)<= 1000004) || (std::abs(pdgId)>2000000 && std::abs(pdgId)<=2000004)) && (pdgId>0);}),
      PdgConditional([](int pdgId)->bool{return (std::abs(pdgId)>1000000 && std::abs(pdgId)<= 1000004) || (std::abs(pdgId)>2000000 && std::abs(pdgId)<=2000004);}),
      1000005,
      1000006,
      2000005,
      2000006,
      -1000005,
      -1000006,
      -2000005,
      -2000006,
      2000011,
      -2000011,
      1000011,
      -1000011,
      unsigned(1000012),
      2000013,
      -2000013,
      1000013,
      -1000013,
      unsigned(1000014),
      1000015,
      -1000015,
      2000015,
      -2000015,
      unsigned(1000016)
    };
    auto it = std::find(conditions.begin(),conditions.end(), SUSY_Spart1_pdgId);
    int idx = std::distance(conditions.begin(), it);
    ++particleCountByType[idx];
    //
    it = std::find(conditions.begin(),conditions.end(), SUSY_Spart2_pdgId);
    idx = std::distance(conditions.begin(), it);
    ++particleCountByType[idx];
    if (const auto & v=gluinoSquarkClassification(particleCountByType);v) return v;
    // Gaugino pair-production
    // chi^{0}_1 + X
    if (const auto & v=gauginoPairProduction(particleCountByType);v) return v;
    // slepton
    if (const auto & v=slepton(particleCountByType);v) return v;
    // smuon
    if (const auto & v=smuon(particleCountByType);v) return v;
    return 0;
  }

gauginoPairProduction() [1/2]

int DerivationFramework::gauginoPairProduction

(

const std::array< int, 35 > &

c

)

Definition at line 58 of file utilityFunctions.cxx.

                                                    {
  // Gaugino pair-production
    // chi^{0}_1 + X
    int result{};
    if (c[chi01]==2) return 111;
    else if (c[chi01]==1 && c[chi02]==1) return 112;
    else if (c[chi01]==1 && c[chi03]==1) return 113;
    else if (c[chi01]==1 && c[chi04]==1) return 114;
    else if (c[chi01]==1 && c[ch1plus]==1) return 115;
    else if (c[chi01]==1 && c[ch2plus]==1) return 116;
    else if (c[chi01]==1 && c[ch1minus]==1) return 117;
    else if (c[chi01]==1 && c[ch2minus]==1) return 118;
 
    // chi^{0}_2 + X
    else if (c[chi02]==2) return 122;
    else if (c[chi02]==1 && c[chi03]==1) return 123;
    else if (c[chi02]==1 && c[chi04]==1) return 124;
    else if (c[chi02]==1 && c[ch1plus]==1) return 125;
    else if (c[chi02]==1 && c[ch2plus]==1) return 126;
    else if (c[chi02]==1 && c[ch1minus]==1) return 127;
    else if (c[chi02]==1 && c[ch2minus]==1) return 128;
 
    // chi^{0}_3 + X
    else if (c[chi03]==2) return 133;
    else if (c[chi03]==1 && c[chi04]==1) return 134;
    else if (c[chi03]==1 && c[ch1plus]==1) return 135;
    else if (c[chi03]==1 && c[ch2plus]==1) return 136;
    else if (c[chi03]==1 && c[ch1minus]==1) return 137;
    else if (c[chi03]==1 && c[ch2minus]==1) return 138;
 
    // chi^{0}_4 + X
    else if (c[chi04]==2) return 144;
    else if (c[chi04]==1 && c[ch1plus]==1) return 145;
    else if (c[chi04]==1 && c[ch2plus]==1) return 146;
    else if (c[chi04]==1 && c[ch1minus]==1) return 147;
    else if (c[chi04]==1 && c[ch2minus]==1) return 148;
 
    // chi^{+}_1/2 + chi^{-}_1/2
    else if (c[ch1plus]==1 && c[ch1minus]==1) return 157;
    else if (c[ch1plus]==1 && c[ch2minus]==1) return 158;
 
    else if (c[ch2plus]==1 && c[ch1minus]==1) return 167;
    else if (c[ch2plus]==1 && c[ch2minus]==1) return 168;
    return result;
  }

gauginoPairProduction() [2/2]

int DerivationFramework::gauginoPairProduction

(

const std::array< int, nParticleIndices > &

c

)

gluinoSquarkClassification() [1/2]

int DerivationFramework::gluinoSquarkClassification

(

const std::array< int, 35 > &

c

)

Definition at line 22 of file utilityFunctions.cxx.

                                                         {
    int result{};
    // gluino/squark + X
    if (c[gluino]==1 && (c[squark]==1 || c[antisquark] ==1)) return 1;
    else if (c[gluino]==2) return 2;
    else if (c[squark]==2 || c[antisquark]==2) return 3;
    else if (c[squark]==1 && c[antisquark]==1) return 4;
 
    else if (c[sbottom]==1 && c[antisbottom]==1) return 51;
    else if (c[sbottom2]==1 && c[antisbottom2]==1) return 52;
    else if (c[stop]==1 && c[antistop]==1) return 61;
    else if (c[stop2]==1 && c[antistop2]==1) return 62;
 
    else if (c[gluino]==1 && c[chi01]==1) return 71;
    else if (c[gluino]==1 && c[chi02]==1) return 72;
    else if (c[gluino]==1 && c[chi03]==1) return 73;
    else if (c[gluino]==1 && c[chi04]==1) return 74;
 
    else if (c[gluino]==1 && c[ch1plus]==1) return 75;
    else if (c[gluino]==1 && c[ch2plus]==1) return 76;
    else if (c[gluino]==1 && c[ch1minus]==1) return 77;
    else if (c[gluino]==1 && c[ch2minus]==1) return 78;
 
    else if ((c[squark]==1 || c[antisquark ]==1) && c[chi01]==1) return 81;
    else if ((c[squark]==1 || c[antisquark ]==1) && c[chi02]==1) return 82;
    else if ((c[squark]==1 || c[antisquark ]==1) && c[chi03]==1) return 83;
    else if ((c[squark]==1 || c[antisquark ]==1) && c[chi04]==1) return 84;
 
    else if ((c[squark]==1 || c[antisquark ]==1) && c[ch1plus]==1) return 85;
    else if ((c[squark]==1 || c[antisquark ]==1) && c[ch2plus]==1) return 86;
    else if ((c[squark]==1 || c[antisquark ]==1) && c[ch1minus]==1) return 87;
    else if ((c[squark]==1 || c[antisquark ]==1) && c[ch2minus]==1) return 88;
    return result;
  }

gluinoSquarkClassification() [2/2]

int DerivationFramework::gluinoSquarkClassification

(

const std::array< int, nParticleIndices > &

c

)

isFromWZTau()

bool DerivationFramework::isFromWZTau ( unsigned int orig )

static

Definition at line 20 of file GenFilterTool.cxx.

                                             {
    switch(orig) {
    case ParticleOrigin::WBoson:
    case ParticleOrigin::ZBoson:
    case ParticleOrigin::TauLep:
      return true;
    default:
      return false;
    }
    return false;
  }

makeHandle()

template<class dType, class ContType>

SG::WriteDecorHandle< ContType, dType > DerivationFramework::makeHandle	(	const EventContext &	ctx,
		const SG::WriteDecorHandleKey< ContType > &	key,
		const dType &	defValue = dType{} )

Definition at line 14 of file PhysicsAnalysis/DerivationFramework/DerivationFrameworkMuons/DerivationFrameworkMuons/Utils.h.

                                                                                                                         {}) {
        SG::WriteDecorHandle<ContType, dType> handle{key, ctx};
        if (handle->size()) handle(*handle->at(0)) = defValue;
        return handle;
    }

slepton() [1/2]

int DerivationFramework::slepton

(

const std::array< int, 35 > &

c

)

Definition at line 104 of file utilityFunctions.cxx.

                                      {
    int result{};
     // slepton
    if (c[selecLplus]==1 && c[selecLminus]==1) return 201; // sElectronLPair
    else if (c[selecRplus]==1 && c[selecRminus]==1) return 202; // sElectronRPair
    else if (c[selnuL]==2) return 203; // sElectron neutrino pair
    else if (c[selecLplus]==1 && c[selnuL]==1) return 204;  // sElectron+ sNutrino
    else if (c[selecLminus]==1 && c[selnuL]==1) return 205; // sElectron- sNutrino
    else if (c[stau1plus]==1 && c[stau1minus]==1) return 206;
    else if (c[stau2plus]==1 && c[stau2minus]==1) return 207;
    else if ((c[stau1plus]==1 || c[stau1minus]==1) && (c[stau2plus]==1 || c[stau2minus]==1)) return 208;
    else if (c[staunuL]==2) return 209; // sTau neutrino pair
    else if (c[stau1plus]==1 && c[staunuL]==1) return 210;
    else if (c[stau1minus]==1 && c[staunuL]==1) return 211;
    else if (c[stau2plus]==1 && c[staunuL]==1) return 212;
    else if (c[stau2minus]==1 && c[staunuL]==1) return 213;
    return result;
  }

slepton() [2/2]

int DerivationFramework::slepton

(

const std::array< int, nParticleIndices > &

c

)

smuon() [1/2]

int DerivationFramework::smuon

(

const std::array< int, 35 > &

c

)

Definition at line 123 of file utilityFunctions.cxx.

                                    {
    int result{};
    if (c[smuonLplus]==1 && c[smuonLminus]==1) return 216; // sMuonPair
    else if (c[smuonRplus]==1 && c[smuonRminus]==1) return 217; // sMuonPair
    else if (c[smunuL]==2) return 218; // sMuon neutrino pair
    else if (c[smuonLplus]==1 && c[smunuL]==1) return 219;  // sMuon+ sNutrino
    else if (c[smuonLminus]==1 && c[smunuL]==1) return 220; // sMuon- sNutrino
    return result;
  }

smuon() [2/2]

int DerivationFramework::smuon

(

const std::array< int, nParticleIndices > &

c

)

Variable Documentation

electronTrackLinksDecor

const SG::AuxElement::Decorator< std::vector< ElementLink< xAOD::TrackParticleContainer > > > DerivationFramework::electronTrackLinksDecor("ElectronTrackLinks") ( "ElectronTrackLinks" )

static

s_CONST

double DerivationFramework::s_CONST = 1000./299.792

constexpr

Definition at line 22 of file CascadeTools.cxx.

sumPt2

const SG::AuxElement::Decorator< float > DerivationFramework::sumPt2("sumPt2") ( "sumPt2" )

static

vertices_dPhi

const SG::AuxElement::Decorator< float > DerivationFramework::vertices_dPhi("vertices_dPhi") ( "vertices_dPhi" )

static

vertices_sumPt

const SG::AuxElement::Decorator< float > DerivationFramework::vertices_sumPt("vertices_sumPt") ( "vertices_sumPt" )

static

vertices_sumPt2

const SG::AuxElement::Decorator< float > DerivationFramework::vertices_sumPt2("vertices_sumPt2") ( "vertices_sumPt2" )

static