DerivationFramework Namespace Reference

THE reconstruction tool. More...

Namespaces
	CellsInCone
	ClustersInCone
	TriggerMatchingUtils

Classes
class	AnalysisMuonThinningAlg
class	AnyVertexSkimmingTool
class	AsgSelectionToolWrapper
class	AugmentationToolExample
class	AugmentationToolLeadingJets
class	AugOriginalCounts
	Augmentation with primary vertex counts (before thinning) More...
class	BadBatmanAugmentationTool
struct	BasedInvCache
class	BdKstarMuMu_metadata
	Store JO metadata specific to the Bd->KstarMuMu analysis. More...
class	BkgElectronClassification
class	Bmumu_metadata
	Store JO metadata specific to the Bmumu analysis. More...
class	Bmumu_reco_mumu
class	BmumuThinningTool
	Primary vertex, track and muon thinning for Bmumu analysis. More...
class	BMuonTrackIsoTool
class	BoostedHadTopAndTopPairFilterAugmentation
class	BoostedHadTopAndTopPairFilterTool
class	BPhysAddMuonBasedInvMass
	Augment secondary vertices with muon-information-based mass. More...
class	BPhysBGammaFinder
class	BPhysConversionFinder
class	BPhysMetadataBase
class	BPhysPVCascadeTools
class	BPhysPVThinningTool
class	BPhysPVTools
class	BPhysVarBlinder
class	BPhysVertexTrackBase
class	BTrackVertexMapLogger
class	BVertexClosestTrackTool
class	BVertexTrackIsoTool
class	CaloClusterThinning
class	CaloIsolationDecorAlg
struct	Candidate
class	Cascade3Plus1
class	CascadeTools
class	CellsInConeThinning
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	DiTauTrackParticleThinning
class	DRAW_ZMUMUSkimmingTool
class	EGammaClusterCoreCellRecovery
class	EgammaTrackParticleThinning
class	EGammaTracksThinning
class	EGElectronAmbiguityTool
class	EGElectronLikelihoodToolWrapper
class	EGInvariantMassTool
class	EGPhotonCleaningWrapper
class	EGSelectionToolWrapper
class	EGTransverseMassTool
class	EventInfoBSErrDecorator
class	EventInfoPixelDecorator
class	EventInfoPixelModuleStatusMonitoring
class	ExpressionParserHelper
	Helper class for using ExpressionParsing::ExpressionParser. More...
class	FilterCombinationAND
class	FilterCombinationOR
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	HITrackParticleThinningTool
class	HITrackQualityAugmentationTool
class	IAugmentationTool
class	IDTrackCaloDepositsDecoratorAlg
class	InDetTrackSelectionToolWrapper
class	InvariantMassTool
class	ISkimmingTool
class	IsolationTrackDecorator
class	IThinningTool
class	JetCaloClusterThinning
class	JetExternalAssocTool
class	JetLargeD0TrackParticleThinning
class	JetMatchingTool
class	JetMSVAugmentation
class	JetTrackParticleThinning
class	JpsiPlusDpstCascade
class	JpsiPlusDs1Cascade
class	JpsiPlusDsCascade
class	JpsiPlusPsiCascade
class	JpsiPlusV0Cascade
class	JpsiXPlus2V0
class	JpsiXPlusDisplaced
class	LArCollisionTimeDecorator
class	LockDecorations
	Algorithm to explicitly lock a set of decorations. More...
class	MaxCellDecorator
class	MbtsToVectorsTool
class	MenuTruthThinning
class	MergedElectronDetailsDecorator
class	MergerTester
	Class-algorithm for track particle collection merging. More...
class	METRemappingAlg
class	METTriggerAugmentationTool
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_Bmumu
class	Select_onia2mumu
class	SkimmingToolExample
class	SkimmingToolEXOT14
class	SkimmingToolEXOT5
class	SkimmingToolHIGG1
class	SkimmingToolHIGG2
class	SkimmingToolHIGG5VBF
class	StreamAuditorTool
class	SUSYGenFilterTool
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	trackIsolationDecorator
class	TrackMeasurementThinning
class	TrackParametersAtPV
class	TrackParametersKVU
class	TrackParticleCaloCellDecorator
class	TrackParticleThinning
struct	TracksInCone
class	TrackStateOnSurfaceDecorator
class	TrackToVertexWrapper
class	TriggerCountToMetadata
class	TriggerGenericObjectThinningTool
class	TriggerMatchingAugmentation
class	TriggerMatchingTool
	Tool to perform trigger matching in the derivation framework. More...
class	TriggerSkimmingTool
class	TriggerTowerThinningAlg
class	Truth3CollectionMaker
class	TruthBornLeptonCollectionMaker
class	TruthCaloShowerDecorator
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	VertexCaloIsolation
struct	VertexCand
class	VertexPlus1TrackCascade
class	VertexTrackIsolation
class	ViewContainerThinning
class	VSITrackParticleThinning
class	xAODStringSkimmingTool
class	ZeeVertexRefittingTool

Typedefs
typedef std::vector< const xAOD::TrackParticle * >	TrackBag
typedef std::vector< const xAOD::Muon * >	MuonBag
typedef InDet::IInDetTrackSelectionTool	TrkSelTool
typedef ElementLink< xAOD::VertexContainer >	VertexLink
typedef std::vector< VertexLink >	VertexLinkVector
typedef ROOT::Math::LorentzVector< ROOT::Math::PtEtaPhiM4D< double > >	GenVecFourMom_t
	Base 4 Momentum type for TrackParticle. More...
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
	AmgSymMatrix (3) BPhysAddMuonBasedInvMass
template<size_t N>
GenVecFourMom_t	SumVector (const std::array< GenVecFourMom_t, N > &vectors)
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)
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

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.

Qi Zeng Nov 2016.

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

Tool to build link to third party objects through the intermediate object e.g. b already has link to c this tool build a link from a to c by matching b to a, assuming thereis a one-to-one correspondence between a and b

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

GenVecFourMom_t

typedef ROOT::Math::LorentzVector<ROOT::Math::PtEtaPhiM4D<double> > DerivationFramework::GenVecFourMom_t

Base 4 Momentum type for TrackParticle.

Definition at line 27 of file Cascade3Plus1.cxx.

MuonBag

typedef std::vector< const xAOD::Muon * > DerivationFramework::MuonBag

Definition at line 33 of file BPhysAddMuonBasedInvMass.h.

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 32 of file BPhysAddMuonBasedInvMass.h.

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.

TrkSelTool

typedef InDet::IInDetTrackSelectionTool DerivationFramework::TrkSelTool

Definition at line 54 of file BPhysVertexTrackBase.h.

VertexLink

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

Definition at line 23 of file Cascade3Plus1.cxx.

VertexLinkVector

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

Definition at line 24 of file Cascade3Plus1.cxx.

Enumeration Type Documentation

EDeltaRToolParser

enum DerivationFramework::EDeltaRToolParser

Enumerator
kDeltaRToolParser1
kDeltaRToolParser2
kDeltaRToolParserNum

Definition at line 25 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 23 of file InvariantMassTool.h.

{ kInvariantMassToolParser1, kInvariantMassToolParser2, kInvariantMassToolParserNum };

EJetParser

enum DerivationFramework::EJetParser

Enumerator
kRCJetSelection
kNumJetParser

Definition at line 30 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

AmgSymMatrix()

DerivationFramework::AmgSymMatrix

(

3

)

Definition at line 601 of file BPhysAddMuonBasedInvMass.cxx.

                                                         {
    
    AmgSymMatrix(3) cov;
    cov.setZero();
    
    if ( track != NULL ) {
      cov = getMomentumCov( &track->perigeeParameters() );
    }
    return cov;
  }
  //--------------------------------------------------------------------------
  // 
  // Extract the 3x3 momentum covariance matrix in (x,y,z) notation
  // from the (phi, theta, qoverp) notation from a Perigee.
  //
  //--------------------------------------------------------------------------
  AmgSymMatrix(3) BPhysAddMuonBasedInvMass
    ::getMomentumCov(const Trk::Perigee* perigee) const {
    
    AmgSymMatrix(3) cov;
    cov.setZero();
 
    if ( perigee != NULL ) {
      cov = getMomentumCov(perigee->parameters(), *perigee->covariance());
    }
    return cov;
  }
  //--------------------------------------------------------------------------
  // Extract the 3x3 momentum covariance matrix in (x,y,z) notation
  // from the (phi, theta, qoverp) notation from a vector of
  // track parameters and the error matrix
  //
  // Coding ideas orignally taken from
  // V0Tools::massErrorVKalVrt(...),
  // Code converted from BPhysToolBox::getMomentumCov(...).
  //--------------------------------------------------------------------------
  //
  AmgSymMatrix(3) BPhysAddMuonBasedInvMass
    ::getMomentumCov(const AmgVector(5)& pars,
             const AmgSymMatrix(5)& cMatrix) const {
    
    AmgSymMatrix(3) cov;
    cov.setZero();
    
    AmgMatrix(3,3) der;
    der.setZero();
    
    double phi    = pars[Trk::phi];
    double theta  = pars[Trk::theta];
    double qoverp = pars[Trk::qOverP];
 
    if ( qoverp != 0. ) {
      AmgVector(3) p( cos(phi)*sin(theta)/fabs(qoverp),
              sin(phi)*sin(theta)/fabs(qoverp),
              cos(theta)/fabs(qoverp) );
      
      // d(px,py,pz)/d(phi,theta,qoverp)
      der(0,0) = - p.y();
      der(1,0) =   p.x();
      der(2,0) =   0.;
      der(0,1) =   cos(phi) * p.z();
      der(1,1) =   sin(phi) * p.z();
      der(2,1) = - sin(theta) / fabs(qoverp);
      der(0,2) = - p.x()/qoverp;
      der(1,2) = - p.y()/qoverp;
      der(2,2) = - p.z()/qoverp;
 
      for (unsigned int i=0; i<3; i++) {
    for (unsigned int j=0; j<3; j++) {
      for (unsigned int k=0; k<3; k++) {
        for (unsigned int l=0; l<3; l++) {
          cov(i,j) += der(i,k)*cMatrix(k+2,l+2)*der(j,l);
        }
      }
    }
      }
      
      // debug output
      ATH_MSG_DEBUG("BPhysAddMuonBasedInvMass::getTracksWithMuons:"
            << "\nlocalErrCov:\n" 
            << std::setprecision(10) << cMatrix 
            << "\ncov:\n" 
            << std::setprecision(10) << cov 
            << "\np: " << std::setprecision(10) << p 
            << "\nder:\n"
            << std::setprecision(10) << der);
    } // if qoverp
  
    return cov;
  }
  //--------------------------------------------------------------------------
  // Initialize PV-to-SV association type vector
  //--------------------------------------------------------------------------
  void BPhysAddMuonBasedInvMass::initPvAssocTypeVec() {
 
    m_pvAssocTypes.clear();
    for (unsigned int i=0; i<xAOD::BPhysHelper::n_pv_types; ++i) {
      if ( (m_doVertexType & (1 << i)) > 0 )
        m_pvAssocTypes.push_back((xAOD::BPhysHelper::pv_type)i);
    }
  }

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;
  }

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

)

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 13 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

)

SumVector()

template<size_t N>

GenVecFourMom_t DerivationFramework::SumVector

(

const std::array< GenVecFourMom_t, N > &

vectors

)

Definition at line 39 of file Cascade3Plus1.cxx.

                                                                       {
    GenVecFourMom_t total = vectors[0];
    for(size_t i =1; i<N; i++) total+= vectors[i];
    return total;
}

Variable Documentation

s_CONST

constexpr double DerivationFramework::s_CONST = 1000./299.792

constexpr

Definition at line 23 of file CascadeTools.cxx.