DerivationFramework Namespace Reference

THE reconstruction tool. More...

Namespaces
	CellsInCone
	ClustersInCone
	TriggerMatchingUtils

Classes
class	AnalysisMuonThinningAlg
class	AnyVertexSkimmingTool
class	AsgSelectionToolWrapper
class	AugmentationToolExample
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	DiLepFilters
class	DiLepSkim
class	DiMuonTaggingAlg
class	DiphotonVertexDecorator
class	DistanceInTrainAugmentationTool
class	DiTauMassDecorator
class	DiTauTrackParticleThinning
class	DRAW_ZMUMUSkimmingTool
class	DVMeffFilterTool
class	DVMissingETFilterTool
class	DVTracklessJetFilterTool
class	EGammaClusterCoreCellRecovery
class	EgammaTrackParticleThinning
class	EGammaTracksThinning
class	EGCrackVetoCleaningTool
class	EGElectronAmbiguityTool
class	EGElectronLikelihoodToolWrapper
class	EGInvariantMassTool
class	EGPhotonCleaningWrapper
class	EGSelectionToolWrapper
class	EGTransverseMassTool
class	EmergingJetsFilterTool
class	EmergingJetsHighPtFilterTool
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	HardScatterCollectionMaker
class	HardScatterVertexDecorator
class	HardTruthThinning
class	HnlSkimmingTool
class	HVJetMETFilterTool
class	IAugmentationTool
class	IDiLepFilters
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	KinkTrkSingleJetMetFilterTool
class	KinkTrkZeeTagTool
class	KinkTrkZmumuTagTool
class	LArCollisionTimeDecorator
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	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	RpvEgammaIDTool
class	RpvElectronD0Tool
class	RpvMuonD0Tool
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	TauIDDecoratorWrapper
class	TauJets_LepRMParticleThinning
class	TauPVRefitTool
class	TauPVTrkSelectionTool
class	TauSelectionWrapper
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	VHLowTrackJetFilterTool
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	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{})

Variables
constexpr double	s_CONST = 1000./299.792

Detailed Description

THE reconstruction tool.

wrapper tool for tau truth matching

tool for selecting tracks associated to tau candidates (xAOD::TauJetContainer) for the purpose of PV refit, returns a xAOD::TrackParticleContainer if UseTrueTracks = true, use truth matched tracks only

refit any primary vertex in the PV collection that contains any of the TrackParticles provided via a xAOD::TrackParticleContainer set links to original PV container and decorate PV container with links to the refitted PV container

wrapper tool for decorating tau ID scores and WPs

-*- C++ -*-

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 36 of file MuPlusDsCascade.cxx.

MuonsLinkVector

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

Definition at line 37 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 23 of file PsiPlusPsiSingleVertex.cxx.

TrackParticleLinkVector

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

Definition at line 24 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 28 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 JetLargeD0TrackParticleThinning.h.

{ kJetSelection, kTrackThinning, kNumJetTPThinningParser};

EJetTrPThinningParser [2/2]

enum DerivationFramework::EJetTrPThinningParser

Enumerator
kJetSelection
kTrackThinning
kNumJetTPThinningParser
kJetSelection
kTrackThinning
kNumJetTPThinningParser

Definition at line 27 of file JetTrackParticleThinning.h.

{ kJetSelection, kTrackThinning, kNumJetTPThinningParser};

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

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

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.