VKalVrtAthena::VrtSecInclusive Class Reference

#include <VrtSecInclusive.h>

Inheritance diagram for VKalVrtAthena::VrtSecInclusive:

Classes
struct	track_summary_properties
struct	WrkVrt

Public Member Functions
	VrtSecInclusive (const std::string &name, ISvcLocator *pSvcLocator)
	Standard Athena-Algorithm Constructor.
virtual	~VrtSecInclusive () override
	Default Destructor.
virtual StatusCode	initialize () override
virtual StatusCode	execute () override
virtual StatusCode	initEvent ()
template<class TrackT>
void	getIntersection (TrackT *trk, vector< IntersectionPos * > &layers, const Trk::Perigee *per)
template<class TrackT>
void	setIntersection (TrackT *trk, IntersectionPos *layer, const Trk::Perigee *per)
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
enum	TrkParameter {   k_d0 =0 , k_z0 =1 , k_theta =2 , k_phi =3 ,   k_qOverP =4 , k_nTP =5 }
enum	TrkParameterUnc { k_d0d0 =0 , k_z0z0 =1 , k_nTPU =2 }
enum	mergeStep {   RECONSTRUCT_NTRK , REASSEMBLE , SHUFFLE1 , SHUFFLE2 ,   SHUFFLE3 , FINAL }
using	PatternStrategyFunc = bool (VrtSecInclusive::*) ( const xAOD::TrackParticle *trk, const Amg::Vector3D& vertex )
using	IPDecoratorType = SG::AuxElement::Decorator< std::vector< std::vector<float> > >
using	VertexELType = SG::AuxElement::Decorator< std::vector<ElementLink< xAOD::VertexContainer > > >
using	Detector = int
using	Bec = int
using	Layer = int
using	Flag = int
using	ExtrapolatedPoint = std::tuple<const TVector3, Detector, Bec, Layer, Flag>
using	ExtrapolatedPattern = std::vector< ExtrapolatedPoint >
using	PatternBank = std::map<const xAOD::TrackParticle*, std::pair< std::unique_ptr<ExtrapolatedPattern>, std::unique_ptr<ExtrapolatedPattern> > >
using	TrackSelectionAlg = StatusCode (VrtSecInclusive::*)(const EventContext&)
using	CutFunc = bool (VrtSecInclusive::*) ( const xAOD::TrackParticle* ) const
	track selection
using	vertexingAlg = StatusCode (VrtSecInclusive::*)( const EventContext&, std::vector<WrkVrt>* )
using	AlgForVerticesPair = double (VrtSecInclusive::*)( const WrkVrt&, const WrkVrt& ) const
typedef struct VKalVrtAthena::VrtSecInclusive::track_summary_properties	track_summary
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	defineDummyCollections (const EventContext &ctx)
StatusCode	dummyVertexContainer (const EventContext &ctx, const SG::WriteHandleKey< xAOD::VertexContainer > &handleKey)
void	declareProperties ()
StatusCode	addEventInfo ()
StatusCode	setupNtupleVariables ()
StatusCode	setupNtuple ()
StatusCode	clearNtupleVariables ()
StatusCode	deleteNtupleVariables ()
StatusCode	processPrimaryVertices ()
StatusCode	fillAANT_SelectedBaseTracks ()
StatusCode	fillAANT_SecondaryVertices (xAOD::VertexContainer *)
void	selectTrack (const xAOD::TrackParticle *)
	Vertexing Algorithm Member Functions.
StatusCode	selectTracksInDet (const EventContext &ctx)
StatusCode	selectTracksFromMuons (const EventContext &ctx)
StatusCode	selectTracksFromElectrons (const EventContext &ctx)
StatusCode	selectInDetAndGSFTracks (const EventContext &ctx)
bool	selectTrack_notPVassociated (const xAOD::TrackParticle *) const
	track-by-track selection strategies
bool	selectTrack_pTCut (const xAOD::TrackParticle *) const
bool	selectTrack_chi2Cut (const xAOD::TrackParticle *) const
bool	selectTrack_hitPattern (const xAOD::TrackParticle *) const
bool	selectTrack_hitPatternTight (const xAOD::TrackParticle *) const
bool	selectTrack_d0Cut (const xAOD::TrackParticle *) const
bool	selectTrack_z0Cut (const xAOD::TrackParticle *) const
bool	selectTrack_d0errCut (const xAOD::TrackParticle *) const
bool	selectTrack_z0errCut (const xAOD::TrackParticle *) const
bool	selectTrack_LRTR3Cut (const xAOD::TrackParticle *) const
StatusCode	extractIncompatibleTrackPairs (const EventContext &ctx, std::vector< WrkVrt > *)
	related to the graph method and verte finding
StatusCode	findNtrackVertices (const EventContext &ctx, std::vector< WrkVrt > *)
StatusCode	rearrangeTracks (const EventContext &ctx, std::vector< WrkVrt > *)
StatusCode	reassembleVertices (const EventContext &ctx, std::vector< WrkVrt > *)
	attempt to merge vertices when all tracks of a vertex A is close to vertex B in terms of impact parameter
StatusCode	mergeByShuffling (const EventContext &ctx, std::vector< WrkVrt > *)
	attempt to merge splitted vertices when they are significantly distant due to the long-tail behavior of the vertex reconstruction resolution
StatusCode	mergeFinalVertices (const EventContext &ctx, std::vector< WrkVrt > *)
	attempt to merge vertices by lookng at the distance between two vertices
StatusCode	associateNonSelectedTracks (const EventContext &ctx, std::vector< WrkVrt > *)
	in addition to selected tracks, associate as much tracks as possible
StatusCode	refitAndSelectGoodQualityVertices (const EventContext &ctx, std::vector< WrkVrt > *)
	finalization of the vertex and store to xAOD::VertexContainer
bool	getSVImpactParameters (const xAOD::TrackParticle *trk, const Amg::Vector3D &vertex, std::vector< double > &impactParameters, std::vector< double > &impactParErrors)
	get secondary vertex impact parameters
void	printWrkSet (const std::vector< WrkVrt > *WrkVrtSet, const std::string &name)
	print the contents of reconstructed vertices
StatusCode	refitVertex (WrkVrt &)
	refit the vertex.
StatusCode	refitVertex (WrkVrt &, Trk::IVKalState &istate)
StatusCode	refitVertexWithSuggestion (WrkVrt &, const Amg::Vector3D &)
	refit the vertex with suggestion
StatusCode	refitVertexWithSuggestion (WrkVrt &, const Amg::Vector3D &, Trk::IVKalState &istate)
double	improveVertexChi2 (WrkVrt &)
	attempt to improve the vertex chi2 by removing the most-outlier track one by one until the vertex chi2 satisfies a certain condition.
StatusCode	disassembleVertex (std::vector< WrkVrt > *, const unsigned &vertexIndex)
void	trackClassification (std::vector< WrkVrt > *, std::map< long int, std::vector< long int > > &)
double	findWorstChi2ofMaximallySharedTrack (std::vector< WrkVrt > *, std::map< long int, std::vector< long int > > &, long int &, long int &)
double	significanceBetweenVertices (const WrkVrt &, const WrkVrt &) const
	calculate the significance (Mahalanobis distance) between two reconstructed vertices
double	distanceBetweenVertices (const WrkVrt &, const WrkVrt &) const
	calculate the physical distance
double	findMinVerticesPair (std::vector< WrkVrt > *, std::pair< unsigned, unsigned > &, const AlgForVerticesPair &)
	returns the pair of vertices that give minimum in terms of some observable (e.g.
StatusCode	mergeVertices (WrkVrt &destination, WrkVrt &source)
	the 2nd vertex is merged into the 1st vertex.
ExtrapolatedPattern *	extrapolatedPattern (const xAOD::TrackParticle *, enum Trk::PropDirection)
bool	patternCheck (const uint32_t &pattern, const Amg::Vector3D &vertex)
bool	patternCheckOuterOnly (const uint32_t &pattern, const Amg::Vector3D &vertex)
bool	checkTrackHitPatternToVertex (const xAOD::TrackParticle *trk, const Amg::Vector3D &vertex)
	A classical method with hard-coded geometry.
bool	checkTrackHitPatternToVertexOuterOnly (const xAOD::TrackParticle *trk, const Amg::Vector3D &vertex)
	A classical method with hard-coded geometry.
bool	checkTrackHitPatternToVertexByExtrapolation (const xAOD::TrackParticle *trk, const Amg::Vector3D &vertex)
	New method with track extrapolation.
bool	checkTrackHitPatternToVertexByExtrapolationAssist (const xAOD::TrackParticle *trk, const Amg::Vector3D &vertex)
	New method with track extrapolation.
bool	passedFakeReject (const Amg::Vector3D &FitVertex, const xAOD::TrackParticle *itrk, const xAOD::TrackParticle *jtrk)
	Flag false if the consistituent tracks are not consistent with the vertex position.
void	removeInconsistentTracks (WrkVrt &)
	Remove inconsistent tracks from vertices.
template<class Track>
void	getIntersection (Track *trk, std::vector< IntersectionPos * > &layers, const Trk::Perigee *per)
template<class Track>
void	setIntersection (Track *trk, IntersectionPos *bec, const Trk::Perigee *per)
StatusCode	monitorVertexingAlgorithmStep (const EventContext &ctx, std::vector< WrkVrt > *, const std::string &name, bool final=false)
	monitor the intermediate status of vertexing
StatusCode	categorizeVertexTruthTopology (xAOD::Vertex *vertex)
void	dumpTruthInformation ()
template<class LeptonFlavor>
StatusCode	augmentDVimpactParametersToLeptons (const std::string &containerName)
void	lockTrackDecorations (const xAOD::TrackParticle *trk, bool onlySelection) const
	lock decorations at the end of the algorithm
void	lockLeptonDecorations (const SG::AuxVectorData *cont) const
StatusCode	lockTrackDecorations (bool onlySelection, const EventContext &ctx) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Static Private Member Functions
static bool	selectTrack_d0signifCut (const xAOD::TrackParticle *)
static bool	selectTrack_z0signifCut (const xAOD::TrackParticle *)
static void	removeTrackFromVertex (std::vector< WrkVrt > *, std::vector< std::deque< long int > > *, const long int &, const long int &)
static size_t	nTrkCommon (std::vector< WrkVrt > *WrkVrtSet, const std::pair< unsigned, unsigned > &pairIndex)
	returns the number of tracks commonly present in both vertices
static double	findMinVerticesNextPair (std::vector< WrkVrt > *, std::pair< unsigned, unsigned > &)
	returns the next pair of vertices that give next-to-minimum distance significance
static void	fillTrackSummary (track_summary &summary, const xAOD::TrackParticle *trk)
	retrieve the track hit information
static bool	patternCheckRun1 (const uint32_t &pattern, const Amg::Vector3D &vertex)
static bool	patternCheckRun2 (const uint32_t &pattern, const Amg::Vector3D &vertex)
static bool	patternCheckRun1OuterOnly (const uint32_t &pattern, const Amg::Vector3D &vertex)
static bool	patternCheckRun2OuterOnly (const uint32_t &pattern, const Amg::Vector3D &vertex)
static const xAOD::TruthParticle *	getTrkGenParticle (const xAOD::TrackParticle *)

Private Attributes
Gaudi::Property< int >	m_geoModel {this, "GeoModel", VKalVrtAthena::GeoModel::Run2}
SG::ReadHandleKey< xAOD::TrackParticleContainer >	m_TrackLocation {this, "TrackLocation", "InDetTrackParticles"}
SG::ReadHandleKey< xAOD::MuonContainer >	m_MuonLocation {this, "MuonLocation", "Muons"}
SG::ReadHandleKey< xAOD::ElectronContainer >	m_ElectronLocation {this, "ElectronLocation", "Electrons"}
SG::ReadHandleKey< xAOD::VertexContainer >	m_PrimVrtLocation {this, "PrimVrtLocation", "PrimaryVertices"}
Gaudi::Property< std::string >	m_truthParticleContainerName {this, "McParticleContainer", "TruthParticles"}
Gaudi::Property< std::string >	m_mcEventContainerName {this, "MCEventContainer", "TruthEvents"}
Gaudi::Property< std::string >	m_augVerString {this, "AugmentingVersionString", "_VSI"}
Gaudi::Property< std::string >	m_truthParticleFilter {this, "TruthParticleFilter", "Rhadron"}
Gaudi::Property< std::string >	m_all2trksVerticesContainerName {this, "All2trkVerticesContainerName", "All2TrksVertices"}
Gaudi::Property< std::string >	m_secondaryVerticesContainerName {this, "SecondaryVerticesContainerName", "SecondaryVertices"}
Gaudi::Property< bool >	m_doTruth {this, "DoTruth", false}
Gaudi::Property< bool >	m_FillHist {this, "FillHist", false}
Gaudi::Property< bool >	m_FillNtuple {this, "FillNtuple", false}
Gaudi::Property< bool >	m_FillIntermediateVertices {this, "FillIntermediateVertices", false}
Gaudi::Property< bool >	m_doIntersectionPos {this, "DoIntersectionPos", false}
Gaudi::Property< bool >	m_doMapToLocal {this, "DoMapToLocal", false}
Gaudi::Property< bool >	m_extrapPV {this, "ExtrapPV", false}
Gaudi::Property< bool >	m_passThroughTrackSelection {this, "PassThroughTrackSelection", false }
Gaudi::Property< bool >	m_doFastMode {this, "DoFastMode", false}
Gaudi::Property< unsigned int >	m_SelTrkMaxCutoff {this, "SelTrkMaxCutoff", 50}
Gaudi::Property< bool >	m_SAloneTRT {this, "DoSAloneTRT", false}
Gaudi::Property< bool >	m_do_PVvetoCut {this, "do_PVvetoCut", true}
Gaudi::Property< bool >	m_do_d0Cut {this, "do_d0Cut", true}
Gaudi::Property< bool >	m_do_z0Cut {this, "do_z0Cut", true}
Gaudi::Property< bool >	m_do_d0errCut {this, "do_d0errCut", false}
Gaudi::Property< bool >	m_do_z0errCut {this, "do_z0errCut", false}
Gaudi::Property< bool >	m_do_d0signifCut {this, "do_d0signifCut", false}
Gaudi::Property< bool >	m_do_z0signifCut {this, "do_z0signifCut", false}
Gaudi::Property< bool >	m_ImpactWrtBL {this, "ImpactWrtBL", true}
Gaudi::Property< double >	m_d0TrkPVDstMinCut {this, "a0TrkPVDstMinCut", 0. }
Gaudi::Property< double >	m_d0TrkPVDstMaxCut {this, "a0TrkPVDstMaxCut", 1000.}
Gaudi::Property< double >	m_d0TrkPVSignifCut {this, "a0TrkPVSignifCut", 0.}
Gaudi::Property< double >	m_z0TrkPVDstMinCut {this, "zTrkPVDstMinCut", 0.}
Gaudi::Property< double >	m_z0TrkPVDstMaxCut {this, "zTrkPVDstMaxCut", 1000.}
Gaudi::Property< double >	m_z0TrkPVSignifCut {this, "zTrkPVSignifCut", 0.}
Gaudi::Property< double >	m_d0TrkErrorCut {this, "TrkA0ErrCut", 10000}
Gaudi::Property< double >	m_z0TrkErrorCut {this, "TrkZErrCut", 20000}
Gaudi::Property< double >	m_twoTrkVtxFormingD0Cut {this, "twoTrkVtxFormingD0Cut", 1.}
Gaudi::Property< double >	m_TrkChi2Cut {this, "TrkChi2Cut", 3.}
Gaudi::Property< double >	m_TrkPtCut {this, "TrkPtCut", 1000.}
Gaudi::Property< bool >	m_doTRTPixCut {this, "doTRTPixCut", false, "mode for R-hadron displaced vertex"}
Gaudi::Property< int >	m_CutSctHits {this, "CutSctHits", 0}
Gaudi::Property< int >	m_CutPixelHits {this, "CutPixelHits", 0}
Gaudi::Property< int >	m_CutSiHits {this, "CutSiHits", 0}
Gaudi::Property< int >	m_CutBLayHits {this, "CutBLayHits", 0}
Gaudi::Property< int >	m_CutSharedHits {this, "CutSharedHits", 0}
Gaudi::Property< int >	m_CutTRTHits {this, "CutTRTHits", 0}
Gaudi::Property< int >	m_CutTightSCTHits {this, "CutTightSCTHits", 7}
Gaudi::Property< int >	m_CutTightTRTHits {this, "CutTightTRTHits", 20}
Gaudi::Property< int >	m_trkExtrapolator {this, "TrkExtrapolator", 2}
Gaudi::Property< bool >	m_doPVcompatibilityCut {this, "DoPVcompatibility", true}
Gaudi::Property< bool >	m_doTightPVcompatibilityCut {this, "DoTightPVcompatibility", false}
Gaudi::Property< bool >	m_removeFakeVrt {this, "RemoveFake2TrkVrt", true}
Gaudi::Property< bool >	m_removeFakeVrtLate {this, "DoDelayedFakeReject", false}
Gaudi::Property< bool >	m_doReassembleVertices {this, "doReassembleVertices", false}
Gaudi::Property< bool >	m_doMergeByShuffling {this, "doMergeByShuffling", false}
Gaudi::Property< bool >	m_doSuggestedRefitOnMerging {this, "doSuggestedRefitOnMerging", true}
Gaudi::Property< bool >	m_doMagnetMerging {this, "doMagnetMerging", true}
Gaudi::Property< bool >	m_doWildMerging {this, "doWildMerging", true}
Gaudi::Property< bool >	m_doMergeFinalVerticesDistance {this, "doMergeFinalVerticesDistance", false}
Gaudi::Property< bool >	m_doAssociateNonSelectedTracks {this, "doAssociateNonSelectedTracks", false}
Gaudi::Property< bool >	m_doFinalImproveChi2 {this, "doFinalImproveChi2", false}
Gaudi::Property< double >	m_pvCompatibilityCut {this, "PVcompatibilityCut", -20.}
Gaudi::Property< double >	m_SelVrtChi2Cut {this, "SelVrtChi2Cut", 4.5}
Gaudi::Property< double >	m_VertexMergeFinalDistCut {this, "VertexMergeFinalDistCut", 1.}
Gaudi::Property< double >	m_VertexMergeFinalDistScaling {this, "VertexMergeFinalDistScaling", 0.}
Gaudi::Property< double >	m_VertexMergeCut {this, "VertexMergeCut", 3}
Gaudi::Property< double >	m_TrackDetachCut {this, "TrackDetachCut", 6}
Gaudi::Property< bool >	m_doTwoTrSoftBtag {this, "DoTwoTrSoftBtag", false}
Gaudi::Property< double >	m_twoTrVrtAngleCut {this, "TwoTrVrtAngleCut", -10}
Gaudi::Property< double >	m_twoTrVrtMinDistFromPV {this, "TwoTrVrtMinDistFromPVCut", 0.}
Gaudi::Property< bool >	m_truncateWrkVertices {this, "TruncateListOfWorkingVertices", true}
Gaudi::Property< size_t >	m_maxWrkVertices {this, "MaxNumberOfWorkingVertices", 1500}
Gaudi::Property< double >	m_associateMinDistanceToPV {this, "associateMinDistanceToPV", 0.5}
Gaudi::Property< double >	m_associateMaxD0Signif {this, "associateMaxD0Signif", 5.}
Gaudi::Property< double >	m_associateMaxZ0Signif {this, "associateMaxZ0Signif", 5.}
Gaudi::Property< double >	m_associatePtCut {this, "associatePtCut", 0.}
Gaudi::Property< double >	m_associateChi2Cut {this, "associateChi2Cut", 20.}
Gaudi::Property< double >	m_reassembleMaxImpactParameterD0 {this, "reassembleMaxImpactParameterD0", 1.}
Gaudi::Property< double >	m_reassembleMaxImpactParameterZ0 {this, "reassembleMaxImpactParameterZ0", 5.}
Gaudi::Property< double >	m_mergeByShufflingMaxSignificance {this, "mergeByShufflingMaxSignificance", 100.}
Gaudi::Property< double >	m_mergeByShufflingAllowance {this, "mergeByShufflingAllowance", 4.}
Gaudi::Property< double >	m_improveChi2ProbThreshold {this, "improveChi2ProbThreshold", 1.e-4}
Gaudi::Property< bool >	m_doSelectTracksFromMuons {this, "doSelectTracksFromMuons", false}
Gaudi::Property< bool >	m_doRemoveCaloTaggedMuons {this, "doRemoveCaloTaggedMuons", false}
Gaudi::Property< bool >	m_doSelectTracksFromElectrons {this, "doSelectTracksFromElectrons", false}
Gaudi::Property< bool >	m_doSelectIDAndGSFTracks {this, "doSelectIDAndGSFTracks", false}
Gaudi::Property< bool >	m_doRemoveNonLeptonVertices {this, "doRemoveNonLeptonVertices", false}
Gaudi::Property< bool >	m_doDisappearingTrackVertexing {this, "doDisappearingTrackVertexing", false}
Gaudi::Property< double >	m_twoTrVrtMaxPerigeeDist {this, "twoTrVrtMaxPerigeeDist", 50}
Gaudi::Property< double >	m_twoTrVrtMinRadius {this, "twoTrVrtMinRadius", 50}
Gaudi::Property< bool >	m_doSelectTracksWithLRTCuts {this, "doSelectTracksWithLRTCuts", false}
Gaudi::Property< bool >	m_doAugmentDVimpactParametersToMuons {this, "doAugmentDVimpactParametersToMuons", false}
Gaudi::Property< bool >	m_doAugmentDVimpactParametersToElectrons {this, "doAugmentDVimpactParametersToElectrons", false}
Gaudi::Property< double >	m_mcTrkResolution {this, "MCTrackResolution", 0.06}
Gaudi::Property< double >	m_TruthTrkLen {this, "TruthTrkLen", 1000}
int	m_vertexingStatus = 0
const xAOD::VertexContainer *	m_primaryVertices {}
const xAOD::Vertex *	m_thePV {}
std::vector< const xAOD::TrackParticle * >	m_selectedTracks
std::vector< const xAOD::TrackParticle * >	m_associatedTracks
std::vector< const xAOD::TrackParticle * >	m_leptonicTracks
std::vector< double >	m_BeamPosition
ToolHandle< Trk::ITrkVKalVrtFitter >	m_fitSvc {this, "VertexFitterTool", "Trk::TrkVKalVrtFitter", " Private TrkVKalVrtFitter"}
PublicToolHandle< Trk::ITruthToTrack >	m_truthToTrack {this, "TruthToTrack", "Trk::TruthToTrack/InDetTruthToTrack"}
PublicToolHandle< Reco::ITrackToVertex >	m_trackToVertexTool {this, "TrackToVertexTool", "Reco::TrackToVertex"}
	get a handle on the Track to Vertex tool
PublicToolHandle< Trk::ITrackToVertexIPEstimator >	m_trackToVertexIPEstimatorTool {this, "TrackToVertexIPEstimatorTool", "Trk::TrackToVertexIPEstimator/TrackToVertexIPEstimator"}
PublicToolHandle< Trk::IExtrapolator >	m_extrapolator {this, "Extrapolator", "Trk::Extrapolator/AtlasExtrapolator"}
PublicToolHandle< Trk::IVertexMapper >	m_vertexMapper {this, "VertexMapper", ""}
ToolHandle< IInDetConditionsTool >	m_pixelCondSummaryTool {this, "PixelConditionsSummaryTool", "PixelConditionsSummaryTool", "Tool to retrieve Pixel Conditions summary"}
	Condition service.
ToolHandle< IInDetConditionsTool >	m_sctCondSummaryTool {this, "InDetSCT_ConditionsSummaryTool", "SCT_ConditionsSummaryTool/InDetSCT_ConditionsSummaryTool", "Tool to retrieve SCT conditions summary"}
const AtlasDetectorID *	m_atlasId {}
const PixelID *	m_pixelId {}
const SCT_ID *	m_sctId {}
Gaudi::Property< std::string >	m_checkPatternStrategy {this, "CheckHitPatternStrategy", "Classical", "Either Classical or Extrapolation"}
std::map< std::string, PatternStrategyFunc >	m_patternStrategyFuncs
std::optional< SG::Decorator< char > >	m_decor_isSelected
std::optional< SG::Decorator< char > >	m_decor_isAssociated
std::optional< SG::Decorator< char > >	m_decor_is_svtrk_final
std::map< unsigned, SG::Decorator< float > >	m_trkDecors
SG::ReadHandleKey< xAOD::EventInfo >	m_eventInfoKey {this,"EventInfoKey", "EventInfo", "EventInfo name"}
	Read/Write Handle Keys.
SG::WriteHandleKey< xAOD::VertexContainer >	m_vertexKey {this, "VertexKey", "", "Vertex key"}
SG::WriteHandleKey< xAOD::VertexContainer >	m_twoTrksVertexKey {this, "TwoTracksVertexKey", "", "Two Tracks Vertex key"}
std::map< std::string, SG::WriteHandleKey< xAOD::VertexContainer > >	m_intermediateVertexKey
SG::WriteDecorHandleKey< xAOD::EventInfo >	m_vertexingStatusKey {this, "VertexingStatusKey", m_eventInfoKey, ""}
std::vector< IPDecoratorType >	m_ipDecors
std::optional< VertexELType >	m_decor_svLink
TTree *	m_tree_Vert {}
std::unique_ptr< NtupleVars >	m_ntupleVars
std::map< std::string, TH1 * >	m_hists
PatternBank	m_extrapolatedPatternBank
std::vector< std::pair< int, int > >	m_incomp
std::map< const xAOD::TruthVertex *, bool >	m_matchMap
std::vector< TrackSelectionAlg >	m_trackSelectionAlgs
std::vector< CutFunc >	m_trackSelectionFuncs
std::vector< std::pair< std::string, vertexingAlg > >	m_vertexingAlgorithms
unsigned	m_vertexingAlgorithmStep = 0U
std::vector< const xAOD::TruthVertex * >	m_tracingTruthVertices
std::unordered_map< std::string, bool >	m_vertexCollectionsDefinitions
DataObjIDColl	m_extendedExtraObjects
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 88 of file VrtSecInclusive.h.

Member Typedef Documentation

AlgForVerticesPair

using VKalVrtAthena::VrtSecInclusive::AlgForVerticesPair = double (VrtSecInclusive::*)( const WrkVrt&, const WrkVrt& ) const

private

Definition at line 482 of file VrtSecInclusive.h.

Bec

using VKalVrtAthena::VrtSecInclusive::Bec = int

private

Definition at line 365 of file VrtSecInclusive.h.

CutFunc

using VKalVrtAthena::VrtSecInclusive::CutFunc = bool (VrtSecInclusive::*) ( const xAOD::TrackParticle* ) const

private

track selection

Definition at line 395 of file VrtSecInclusive.h.

Detector

using VKalVrtAthena::VrtSecInclusive::Detector = int

private

Definition at line 364 of file VrtSecInclusive.h.

ExtrapolatedPattern

using VKalVrtAthena::VrtSecInclusive::ExtrapolatedPattern = std::vector< ExtrapolatedPoint >

private

Definition at line 369 of file VrtSecInclusive.h.

ExtrapolatedPoint

using VKalVrtAthena::VrtSecInclusive::ExtrapolatedPoint = std::tuple<const TVector3, Detector, Bec, Layer, Flag>

private

Definition at line 368 of file VrtSecInclusive.h.

Flag

using VKalVrtAthena::VrtSecInclusive::Flag = int

private

Definition at line 367 of file VrtSecInclusive.h.

IPDecoratorType

using VKalVrtAthena::VrtSecInclusive::IPDecoratorType = SG::AuxElement::Decorator< std::vector< std::vector<float> > >

private

Definition at line 305 of file VrtSecInclusive.h.

Layer

using VKalVrtAthena::VrtSecInclusive::Layer = int

private

Definition at line 366 of file VrtSecInclusive.h.

PatternBank

using VKalVrtAthena::VrtSecInclusive::PatternBank = std::map<const xAOD::TrackParticle*, std::pair< std::unique_ptr<ExtrapolatedPattern>, std::unique_ptr<ExtrapolatedPattern> > >

private

Definition at line 370 of file VrtSecInclusive.h.

PatternStrategyFunc

using VKalVrtAthena::VrtSecInclusive::PatternStrategyFunc = bool (VrtSecInclusive::*) ( const xAOD::TrackParticle *trk, const Amg::Vector3D& vertex )

private

Definition at line 288 of file VrtSecInclusive.h.

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

track_summary

typedef struct VKalVrtAthena::VrtSecInclusive::track_summary_properties VKalVrtAthena::VrtSecInclusive::track_summary

private

TrackSelectionAlg

using VKalVrtAthena::VrtSecInclusive::TrackSelectionAlg = StatusCode (VrtSecInclusive::*)(const EventContext&)

private

Definition at line 391 of file VrtSecInclusive.h.

VertexELType

using VKalVrtAthena::VrtSecInclusive::VertexELType = SG::AuxElement::Decorator< std::vector<ElementLink< xAOD::VertexContainer > > >

private

Definition at line 308 of file VrtSecInclusive.h.

vertexingAlg

using VKalVrtAthena::VrtSecInclusive::vertexingAlg = StatusCode (VrtSecInclusive::*)( const EventContext&, std::vector<WrkVrt>* )

private

Definition at line 439 of file VrtSecInclusive.h.

Member Enumeration Documentation

mergeStep

enum VKalVrtAthena::VrtSecInclusive::mergeStep

private

Enumerator
RECONSTRUCT_NTRK
REASSEMBLE
SHUFFLE1
SHUFFLE2
SHUFFLE3
FINAL

Definition at line 493 of file VrtSecInclusive.h.

{ RECONSTRUCT_NTRK, REASSEMBLE, SHUFFLE1, SHUFFLE2, SHUFFLE3, FINAL };

TrkParameter

enum VKalVrtAthena::VrtSecInclusive::TrkParameter

private

Enumerator
k_d0
k_z0
k_theta
k_phi
k_qOverP
k_nTP

Definition at line 436 of file VrtSecInclusive.h.

{ k_d0=0, k_z0=1, k_theta=2, k_phi=3, k_qOverP=4 ,k_nTP=5 };

TrkParameterUnc

enum VKalVrtAthena::VrtSecInclusive::TrkParameterUnc

private

Enumerator
k_d0d0
k_z0z0
k_nTPU

Definition at line 437 of file VrtSecInclusive.h.

{ k_d0d0=0, k_z0z0=1, k_nTPU=2 };

Constructor & Destructor Documentation

VrtSecInclusive()

VKalVrtAthena::VrtSecInclusive::VrtSecInclusive	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Standard Athena-Algorithm Constructor.

Definition at line 39 of file VrtSecInclusive.cxx.

                                                                                 :
    AthAlgorithm                   (name,pSvcLocator),
    m_ntupleVars                   ( nullptr )
  {
    m_patternStrategyFuncs["Classical"]           = &VrtSecInclusive::checkTrackHitPatternToVertex;
    m_patternStrategyFuncs["ClassicalOuter"]      = &VrtSecInclusive::checkTrackHitPatternToVertexOuterOnly;
    m_patternStrategyFuncs["Extrapolation"]       = &VrtSecInclusive::checkTrackHitPatternToVertexByExtrapolation;
    m_patternStrategyFuncs["ExtrapolationAssist"] = &VrtSecInclusive::checkTrackHitPatternToVertexByExtrapolationAssist;
 
    if( m_FillNtuple ) {
      m_ntupleVars = std::make_unique<NtupleVars>( );
    }
  }

~VrtSecInclusive()

VKalVrtAthena::VrtSecInclusive::~VrtSecInclusive ( )

overridevirtual

Default Destructor.

Definition at line 55 of file VrtSecInclusive.cxx.

  {
  }

Member Function Documentation

addEventInfo()

StatusCode VKalVrtAthena::VrtSecInclusive::addEventInfo ( )

private

Definition at line 236 of file AANT_Tools.cxx.

                                           {
    // add event level variables
    //
    ATH_MSG_DEBUG( " > addEventInfo: in addEventInfo");
    
    // this code has been taken from AnalysisExamples/VFitZmmOnAOD
    // 
    //get EventInfo for run and event number
    
    const xAOD::EventInfo* eventInfo;
    ATH_CHECK( evtStore()->retrieve(eventInfo) );
    
    //
    //m_ntupleVars->m_runNumber   = eventInfo->runNumber();
    m_ntupleVars->get<unsigned int>( "RunNumber" )  = eventInfo->runNumber();
    m_ntupleVars->get<unsigned int>( "Event")       = eventInfo->eventNumber();
    m_ntupleVars->get<unsigned int>( "Time" )       = eventInfo->timeStamp() ; 
    m_ntupleVars->get<unsigned int>( "LumiBlock" )  = eventInfo->lumiBlock() ;
    m_ntupleVars->get<unsigned int>( "BCID" )       = eventInfo->bcid();
    
    ATH_MSG_DEBUG( " > addEventInfo: event "<< m_ntupleVars->get<unsigned int>( "Event" ) );
    
    return StatusCode::SUCCESS;
  }  

associateNonSelectedTracks()

StatusCode VKalVrtAthena::VrtSecInclusive::associateNonSelectedTracks ( const EventContext & ctx, std::vector< WrkVrt > * workVerticesContainer )

private

in addition to selected tracks, associate as much tracks as possible

Definition at line 1107 of file VertexingAlgs.cxx.

  {
    SG::ReadHandle<xAOD::TrackParticleContainer> trackHandle = SG::makeHandle( m_TrackLocation, ctx );
    ATH_CHECK( trackHandle.isValid() );
    const xAOD::TrackParticleContainer *allTracks = trackHandle.cptr();
 
    SG::ReadHandle<xAOD::VertexContainer> primVtxHandle = SG::makeHandle( m_PrimVrtLocation, ctx );
    ATH_CHECK( primVtxHandle.isValid() );
    const xAOD::VertexContainer *pvs = primVtxHandle.cptr();
 
    if( !m_decor_isAssociated ) {
      m_decor_isAssociated.emplace ( "is_associated" + m_augVerString );
    }
 
    ATH_MSG_DEBUG( " > " << __FUNCTION__ << ": #verticess = " << workVerticesContainer->size() );
 
    unsigned associateCounter { 0 };
 
    // Loop over vertices
    for( auto& wrkvrt : *workVerticesContainer ) {
 
      if( !wrkvrt.isGood               ) continue;
      if(  wrkvrt.selectedTrackIndices.size() <= 1 ) continue;
 
      improveVertexChi2( wrkvrt );
 
      wrkvrt.Chi2_core = wrkvrt.Chi2;
 
      auto& vertexPos = wrkvrt.vertex;
 
      std::vector<double> distanceToPVs;
 
      for( const auto* pv : *pvs ) {
        distanceToPVs.emplace_back( VKalVrtAthena::vtxVtxDistance( vertexPos, pv->position() ) );
      }
      const auto& minDistance = *( std::min_element( distanceToPVs.begin(), distanceToPVs.end() ) );
 
      if( minDistance < m_associateMinDistanceToPV ) continue;
 
 
      ATH_MSG_DEBUG( " > " << __FUNCTION__ << ": vertex pos = (" << vertexPos.x() << ", " << vertexPos.y() << ", " << vertexPos.z() << "), "
                     "#selected = " << wrkvrt.selectedTrackIndices.size() << ", #assoc = " << wrkvrt.associatedTrackIndices.size() );
 
      std::vector<const xAOD::TrackParticle*> candidates;
 
      // Search for candidate tracks
      for( auto itr = allTracks->begin(); itr != allTracks->end(); ++itr ) {
        const auto* trk = *itr;
 
        // If the track is already used for any DV candidate, reject.
        {
          auto result = std::find_if( workVerticesContainer->begin(), workVerticesContainer->end(),
                                      [&] ( WrkVrt& wrkvrt ) {
                                        auto found = std::find_if( wrkvrt.selectedTrackIndices.begin(), wrkvrt.selectedTrackIndices.end(),
                                                                   [&]( long int index ) {
                                                                     // when using selected tracks from electrons, also check the orginal track particle from GSF to see if InDetTrackParticle (trk) is an electron that is already in the vertex
                                                                     if (m_doSelectTracksFromElectrons || m_doSelectIDAndGSFTracks) {
                                                                       const xAOD::TrackParticle *id_tr;
                                                                       id_tr = xAOD::EgammaHelpers::getOriginalTrackParticleFromGSF(m_selectedTracks.at(index));
                                                                       return trk == m_selectedTracks.at(index) or trk == id_tr;
                                                                     }
                                                                     else{
                                                                       return trk == m_selectedTracks.at(index);
                                                                     }
                                                                   } );
                                        return found != wrkvrt.selectedTrackIndices.end();
                                      } );
          if( result != workVerticesContainer->end() ) continue;
        }
 
        // If the track is already registered to the associated track list, reject.
        {
          auto result = std::find_if( m_associatedTracks.begin(), m_associatedTracks.end(),
                                      [&] (const auto* atrk) { return trk == atrk; } );
          if( result != m_associatedTracks.end() ) continue;
        }
 
        // Reject PV-associated tracks
        // if( !selectTrack_notPVassociated( trk ) ) continue;
 
        // pT selection
        if( trk->pt() < m_associatePtCut ) continue;
 
        // chi2 selection
        if( trk->chiSquared() / trk->numberDoF() > m_associateChi2Cut ) continue;
 
        // Hit pattern consistentcy requirement
        if( !checkTrackHitPatternToVertexOuterOnly( trk, vertexPos ) ) continue;
 
        // Get the closest approach
        std::vector<double> impactParameters;
        std::vector<double> impactParErrors;
 
        if( !getSVImpactParameters( trk, vertexPos, impactParameters, impactParErrors) ) continue;
 
        if( std::abs( impactParameters.at(0) ) / sqrt( impactParErrors.at(0) ) > m_associateMaxD0Signif ) continue;
        if( std::abs( impactParameters.at(1) ) / sqrt( impactParErrors.at(1) ) > m_associateMaxZ0Signif ) continue;
 
        ATH_MSG_DEBUG( " > " << __FUNCTION__ << ": trk " << trk
                       << ": d0 to vtx = " << impactParameters.at(k_d0)
                       << ", z0 to vtx = " << impactParameters.at(k_z0)
                       << ", distance to vtx = " << hypot( impactParameters.at(k_d0), impactParameters.at(k_z0) ) );
 
        candidates.emplace_back( trk );
 
      }
 
      ATH_MSG_DEBUG( " > " << __FUNCTION__ << ": number of candidate tracks = " << candidates.size() );
 
      std::unique_ptr<Trk::IVKalState> state = m_fitSvc->makeState();
      // Attempt to add the track to the vertex and try fitting
      for( const auto* trk : candidates ) {
 
        ATH_MSG_DEBUG( " > " << __FUNCTION__ << ": attempting to associate track = " << trk );
 
        // Backup the current vertes status
        WrkVrt wrkvrt_backup = wrkvrt;
 
        m_fitSvc->setApproximateVertex( vertexPos.x(), vertexPos.y(), vertexPos.z(), *state );
 
        std::vector<const xAOD::TrackParticle*>   baseTracks;
        std::vector<const xAOD::NeutralParticle*> dummyNeutrals;
 
        wrkvrt.Chi2PerTrk.clear();
 
        for( const auto& index : wrkvrt.selectedTrackIndices ) {
          baseTracks.emplace_back( m_selectedTracks.at( index ) );
          wrkvrt.Chi2PerTrk.emplace_back( AlgConsts::chi2PerTrackInitValue );
        }
        for( const auto& index : wrkvrt.associatedTrackIndices ) {
          baseTracks.emplace_back( m_associatedTracks.at( index ) );
          wrkvrt.Chi2PerTrk.emplace_back( AlgConsts::chi2PerTrackInitValue );
        }
 
        baseTracks.emplace_back( trk );
        wrkvrt.Chi2PerTrk.emplace_back( AlgConsts::chi2PerTrackInitValue );
 
        Amg::Vector3D initPos;
 
        {
          StatusCode sc = m_fitSvc->VKalVrtFitFast( baseTracks, initPos, *state );/* Fast crude estimation */
 
          if( sc.isFailure() ) ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": fast crude estimation failed.");
 
          const auto& diffPos = initPos - vertexPos;
 
          if( diffPos.norm() > 10. ) {
 
            ATH_MSG_VERBOSE( " > " << __FUNCTION__ << ": approx vertex as original" );
            m_fitSvc->setApproximateVertex( vertexPos.x(), vertexPos.y(), vertexPos.z(), *state );
 
          } else {
 
            ATH_MSG_VERBOSE( " > " << __FUNCTION__ << ": approx vertex set to (" << initPos.x() << ", " << initPos.y() << ", " << initPos.z() << ")" );
            m_fitSvc->setApproximateVertex( initPos.x(), initPos.y(), initPos.z(), *state );
 
          }
        }
 
 
        ATH_MSG_VERBOSE( " > " << __FUNCTION__ << ": now vertex fitting..." );
 
        StatusCode sc = m_fitSvc->VKalVrtFit(baseTracks, dummyNeutrals,
                                             wrkvrt.vertex,
                                             wrkvrt.vertexMom,
                                             wrkvrt.Charge,
                                             wrkvrt.vertexCov,
                                             wrkvrt.Chi2PerTrk,
                                             wrkvrt.TrkAtVrt,
                                             wrkvrt.Chi2,
                                             *state);
 
        if( sc.isFailure() ) {
          ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": VKalVrtFit failure. Revert to backup");
          wrkvrt = wrkvrt_backup;
 
          if( m_FillHist ) m_hists["associateMonitor"]->Fill( 1 );
 
          continue;
        }
 
 
        if( m_FillHist ) m_hists["associateMonitor"]->Fill( 0 );
 
        auto& cov = wrkvrt.vertexCov;
 
        ATH_MSG_DEBUG( " > " << __FUNCTION__ << ": succeeded in associating. New vertex pos = (" << vertexPos.perp() << ", " << vertexPos.z() << ", " << vertexPos.perp()*vertexPos.phi() << ")" );
        ATH_MSG_VERBOSE( " > " << __FUNCTION__ << ": New vertex cov = (" << cov.at(0) << ", " << cov.at(1) << ", " << cov.at(2) << ", " << cov.at(3) << ", " << cov.at(4) << ", " << cov.at(5) << ")" );
 
        associateCounter++;
 
        wrkvrt.associatedTrackIndices.emplace_back( m_associatedTracks.size() );
 
        m_associatedTracks.emplace_back( trk );
        (*m_decor_isAssociated)( *trk ) = true;
 
      }
 
    }
 
    ATH_MSG_DEBUG(" > " << __FUNCTION__ << "----------------------------------------------" );
    ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": total associated number of tracks = " << associateCounter );
    ATH_MSG_DEBUG(" > " << __FUNCTION__ << "----------------------------------------------" );
 
    return StatusCode::SUCCESS;
  }

augmentDVimpactParametersToLeptons()

template<class LeptonFlavor>

StatusCode VKalVrtAthena::VrtSecInclusive::augmentDVimpactParametersToLeptons ( const std::string & containerName )

private

Definition at line 108 of file Reconstruction/VKalVrt/VrtSecInclusive/VrtSecInclusive/details/Utilities.h.

  {
 
    const xAOD::VertexContainer *secondaryVertexContainer{};
    ATH_CHECK( evtStore()->retrieve( secondaryVertexContainer, "VrtSecInclusive_" + m_secondaryVerticesContainerName + m_augVerString) );
 
    using LeptonContainer = DataVector<LeptonFlavor>;
 
    const LeptonContainer *leptonContainer{};
    ATH_CHECK( evtStore()->retrieve( leptonContainer, containerName ) );
 
    if (m_ipDecors.empty()) {
      m_ipDecors.emplace_back( "d0_wrtSVs"    + m_augVerString );
      m_ipDecors.emplace_back( "z0_wrtSVs"    + m_augVerString );
      m_ipDecors.emplace_back( "pt_wrtSVs"    + m_augVerString );
      m_ipDecors.emplace_back( "eta_wrtSVs"   + m_augVerString );
      m_ipDecors.emplace_back( "phi_wrtSVs"   + m_augVerString );
      m_ipDecors.emplace_back( "d0err_wrtSVs" + m_augVerString );
      m_ipDecors.emplace_back( "z0err_wrtSVs" + m_augVerString );
    }
 
    // Grouping decorators
    enum { k_ip_d0, k_ip_z0, k_ip_pt, k_ip_eta, k_ip_phi, k_ip_d0err, k_ip_z0err };
 
    if( !m_decor_svLink ) {
      m_decor_svLink.emplace ( "svLinks" + m_augVerString );
    }
 
    // Loop over leptons
    for( const auto& lepton : *leptonContainer ) {
 
      std::vector< std::vector< std::vector<float> > > ip_wrtSVs( m_ipDecors.size() ); // triple nest of { ip parameters, tracks, DVs }
 
      bool linkFlag { false };
 
      std::vector<unsigned> trackTypes;
      genSequence<LeptonFlavor>( lepton, trackTypes );
 
      // Loop over lepton types
      for( auto& trackType : trackTypes ) {
 
        std::vector< std::vector<float> > ip_wrtSV( m_ipDecors.size() ); // nest of { tracks, DVs }
 
        const auto* trk = getLeptonTrackParticle<LeptonFlavor>( lepton, trackType );
 
        if( !trk ) continue;
 
        std::map< const xAOD::Vertex*, std::vector<double> > distanceMap;
 
        std::vector<ElementLink< xAOD::VertexContainer > > links;
 
        // Loop over vertices
        for( const auto vtx : *secondaryVertexContainer ) {
 
          std::vector<double> impactParameters;
          std::vector<double> impactParErrors;
 
          m_fitSvc->VKalGetImpact( trk, vtx->position(), static_cast<int>( lepton->charge() ), impactParameters, impactParErrors );
 
          enum { k_d0, k_z0, k_theta, k_phi, k_qOverP }; // for the impact parameter
          enum { k_d0d0, k_d0z0, k_z0z0 };               // for the par errors
 
          const auto& theta = impactParameters.at( k_theta );
          const auto& phi   = impactParameters.at( k_phi );
          const auto  p     = fabs( 1.0 / impactParameters.at(k_qOverP) );
          const auto  pt    = fabs( p * sin( theta ) );
          const auto  eta   = -log( tan(theta/2.) );
 
          // filling the parameters to the corresponding container
          ip_wrtSV.at( k_ip_d0 )    .emplace_back( impactParameters.at(k_d0) );
          ip_wrtSV.at( k_ip_z0 )    .emplace_back( impactParameters.at(k_z0) );
          ip_wrtSV.at( k_ip_pt )    .emplace_back( pt );
          ip_wrtSV.at( k_ip_eta )   .emplace_back( eta );
          ip_wrtSV.at( k_ip_phi )   .emplace_back( phi );
          ip_wrtSV.at( k_ip_d0err ) .emplace_back( impactParErrors.at(k_d0d0) );
          ip_wrtSV.at( k_ip_z0err ) .emplace_back( impactParErrors.at(k_z0z0) );
 
          if( !linkFlag ) {
 
            ElementLink<xAOD::VertexContainer> link_SV( *( dynamic_cast<const xAOD::VertexContainer*>( vtx->container() ) ), static_cast<size_t>( vtx->index() ) );
            links.emplace_back( link_SV );
 
          }
 
        } // end of vertex loop
 
        // The linking to the vertices need to be done only once
        if( !linkFlag ) {
          ( *m_decor_svLink )( *lepton ) = links;
          linkFlag = true;
        }
 
        for( size_t ipar = 0; ipar < ip_wrtSVs.size(); ipar++ ) ip_wrtSVs.at( ipar ).emplace_back( ip_wrtSV.at( ipar ) );
 
      } // end of track type loop
 
      // decoration
      for( size_t ipar = 0; ipar < m_ipDecors.size(); ipar++ ) {
        m_ipDecors.at( ipar )( *lepton ) = ip_wrtSVs.at( ipar );
      }
 
    } // end of lepton container loop
 
    return StatusCode::SUCCESS;
  }

categorizeVertexTruthTopology()

StatusCode VKalVrtAthena::VrtSecInclusive::categorizeVertexTruthTopology ( xAOD::Vertex * vertex )

private

Definition at line 44 of file TruthAlgs.cxx.

  {
 
    enum vertexCatogory_tracks {
      allTruthAssociated,
      hasFakeTracks,
      allFakeTracks
    };
 
    enum vertexCategory_vertex {
      uniqueTruthVertex,
      multipleTruthVertices,
      noTruthVertex
    };
 
 
    // std::multiset allows to have multiplicity of the element
    multiset<const xAOD::TruthVertex*> truth_vertices;
 
    // std::multiset doesn't allow to have multiplicity of the element
    set<const xAOD::TruthVertex*>      truth_vertices_types;
 
    vector<const xAOD::TrackParticle*> reco_tracks;   // associated with truth and has prodVtx
    vector<const xAOD::TrackParticle*> orphan_tracks; // associated with truth, but does not have prodVtx
    vector<const xAOD::TrackParticle*> fake_tracks;   // no association with truth ( fake )
 
    // loop over tracks
    ATH_MSG_VERBOSE( "categorizeVertexTruthTopology(): loop over tracks" );
    for(  size_t itrk=0; itrk<vertex->nTrackParticles(); itrk++ ) {
      const auto *trk = vertex->trackParticle( itrk );
 
      ATH_MSG_VERBOSE( "categorizeVertexTruthTopology(): track loop itrk = " << itrk );
      typedef ElementLink<xAOD::TruthParticleContainer> truthLink;
      static const SG::ConstAccessor< truthLink > truthParticleLinkAcc( "truthParticleLink" );
      const truthLink& link = truthParticleLinkAcc(*trk);
 
      if (  ! link ) {
        fake_tracks.emplace_back(  trk );
        continue;
      }
 
      const xAOD::TruthParticle *truth = *link;
      if(  ! truth->hasProdVtx() ) {
        orphan_tracks.emplace_back(  trk );
        continue;
      }
 
      reco_tracks.emplace_back(  trk );
 
      truth_vertices_types .insert(  truth->prodVtx() );
      truth_vertices       .insert(  truth->prodVtx() );
 
    }
 
 
    // Add truth track pattern to the reco vertex
    ATH_MSG_VERBOSE( "categorizeVertexTruthTopology(): Add truth track pattern to the reco vertex" );
    const static SG::Accessor<char> trkpatAcc( "truth_trk_pattern" );
    if(  reco_tracks.size() == vertex->nTrackParticles() ) {
      trkpatAcc( *vertex ) = allTruthAssociated;
    } else if(  fake_tracks.size() == vertex->nTrackParticles() ) {
      trkpatAcc( *vertex ) = allFakeTracks;
    } else {
      trkpatAcc( *vertex ) = hasFakeTracks;
    }
 
 
    // Histogramming - counting the number of appearing truth vertices connected
    ATH_MSG_VERBOSE( "categorizeVertexTruthTopology(): Histogramming - counting the number of appearing truth vertices connected" );
    vector< tuple<const xAOD::TruthVertex*, size_t> > truth_vertex_histogram;
    for(  const auto *v : truth_vertices_types ) {
      size_t count = truth_vertices.count(  v );
      truth_vertex_histogram.emplace_back(  v, count );
    }
 
    // Determine the truth vertex associated to this vertex by majority decision
    ATH_MSG_VERBOSE( "categorizeVertexTruthTopology(): Determine the truth vertex associated to this vertex by majority decision" );
    tuple<const xAOD::TruthVertex*, size_t> tmp_tuple(  nullptr, 0 );
    for(  const auto& t : truth_vertex_histogram ) {
      const size_t& size_tmp  = get<1>( tmp_tuple );
      const size_t& size_this = get<1>( t );
      if(  size_tmp < size_this ) tmp_tuple = t;
    }
 
    // Add truth track pattern to the reco vertex
    ATH_MSG_VERBOSE( "categorizeVertexTruthTopology(): Add truth track pattern to the reco vertex" );
    char truth_vtx_pattern = 0;
    if(  truth_vertices_types.empty() ) {
      truth_vtx_pattern = noTruthVertex;
    } else if(  truth_vertices_types.size() == 1 ) {
      truth_vtx_pattern = uniqueTruthVertex;
    } else {
      truth_vtx_pattern = multipleTruthVertices;
    }
    static const SG::Accessor<char> vtxpatAcc( "truth_vtx_pattern" );
    vtxpatAcc(*vertex) = truth_vtx_pattern;
 
 
    ElementLink<xAOD::TruthVertexContainer> vtx_link;
    if( noTruthVertex != truth_vtx_pattern ) {
 
      // Retrieve the truth vertex container for element link
      ATH_MSG_VERBOSE( "categorizeVertexTruthTopology(): Retrieve the truth vertex container for element link" );
      const xAOD::TruthVertexContainer* truthVertexContainer{};
      ATH_CHECK(  evtStore()->retrieve( truthVertexContainer, "TruthVertices") );
 
      // create the element link
      ATH_MSG_VERBOSE( "categorizeVertexTruthTopology(): create the element link" );
      const auto *theVertex = get<0>( tmp_tuple );
      if(  theVertex ) {
        // Add the truth vertex element link to the reco vertex
        vtx_link.toIndexedElement(*truthVertexContainer,theVertex->index());
        ATH_MSG_VERBOSE( "categorizeVertexTruthTopology(): Add the truth vertex element link to the reco vertex" );
      }
    }
    // [JDC] a ElementLink decorator should be filled every event
    // although using a null link
    static const SG::Accessor<ElementLink<xAOD::TruthVertexContainer> >
      linkAcc( "truth_vtx_link" );
    linkAcc(*vertex) = vtx_link;
 
    return StatusCode::SUCCESS;
  }

checkTrackHitPatternToVertex()

bool VKalVrtAthena::VrtSecInclusive::checkTrackHitPatternToVertex ( const xAOD::TrackParticle * trk, const Amg::Vector3D & vertex )

private

A classical method with hard-coded geometry.

Definition at line 2046 of file Reconstruction/VKalVrt/VrtSecInclusive/src/Utilities.cxx.

  {
 
    const uint32_t pattern = trk->hitPattern();
 
    return patternCheck( pattern, vertex );
 
  }

checkTrackHitPatternToVertexByExtrapolation()

bool VKalVrtAthena::VrtSecInclusive::checkTrackHitPatternToVertexByExtrapolation ( const xAOD::TrackParticle * trk, const Amg::Vector3D & vertex )

private

New method with track extrapolation.

Definition at line 1039 of file Reconstruction/VKalVrt/VrtSecInclusive/src/Utilities.cxx.

  {
 
    if( m_extrapolatedPatternBank.find( trk ) == m_extrapolatedPatternBank.end() ) {
 
      std::unique_ptr<ExtrapolatedPattern> exPattern_along( extrapolatedPattern( trk, Trk::alongMomentum ) );
      std::unique_ptr<ExtrapolatedPattern> exPattern_oppos( extrapolatedPattern( trk, Trk::oppositeMomentum ) );
 
      m_extrapolatedPatternBank.emplace( trk, std::make_pair( std::move(exPattern_along), std::move(exPattern_oppos) ) );
 
    }
 
    auto& exPattern = m_extrapolatedPatternBank.at( trk );
 
    using LayerCombination = std::vector<int>;
 
    std::map<LayerCombination, unsigned> layerMap;
    if( layerMap.empty() ) {
      layerMap[ { 1, 0, 0 } ] = Trk::pixelBarrel0;
      layerMap[ { 1, 0, 1 } ] = Trk::pixelBarrel1;
      layerMap[ { 1, 0, 2 } ] = Trk::pixelBarrel2;
      layerMap[ { 1, 0, 3 } ] = Trk::pixelBarrel3;
 
      layerMap[ { 1, 2, 0 } ] = Trk::pixelEndCap0;
      layerMap[ { 1, 2, 1 } ] = Trk::pixelEndCap1;
      layerMap[ { 1, 2, 2 } ] = Trk::pixelEndCap2;
      layerMap[ { 1,-2, 0 } ] = Trk::pixelEndCap0;
      layerMap[ { 1,-2, 1 } ] = Trk::pixelEndCap1;
      layerMap[ { 1,-2, 2 } ] = Trk::pixelEndCap2;
 
      layerMap[ { 2, 0, 0 } ] = Trk::sctBarrel0;
      layerMap[ { 2, 0, 1 } ] = Trk::sctBarrel1;
      layerMap[ { 2, 0, 2 } ] = Trk::sctBarrel2;
      layerMap[ { 2, 0, 3 } ] = Trk::sctBarrel3;
 
      layerMap[ { 2, 2, 0 } ] = Trk::sctEndCap0;
      layerMap[ { 2, 2, 1 } ] = Trk::sctEndCap1;
      layerMap[ { 2, 2, 2 } ] = Trk::sctEndCap2;
      layerMap[ { 2, 2, 3 } ] = Trk::sctEndCap3;
      layerMap[ { 2, 2, 4 } ] = Trk::sctEndCap4;
      layerMap[ { 2, 2, 5 } ] = Trk::sctEndCap5;
      layerMap[ { 2, 2, 6 } ] = Trk::sctEndCap6;
      layerMap[ { 2, 2, 7 } ] = Trk::sctEndCap7;
      layerMap[ { 2, 2, 8 } ] = Trk::sctEndCap8;
      layerMap[ { 2,-2, 0 } ] = Trk::sctEndCap0;
      layerMap[ { 2,-2, 1 } ] = Trk::sctEndCap1;
      layerMap[ { 2,-2, 2 } ] = Trk::sctEndCap2;
      layerMap[ { 2,-2, 3 } ] = Trk::sctEndCap3;
      layerMap[ { 2,-2, 4 } ] = Trk::sctEndCap4;
      layerMap[ { 2,-2, 5 } ] = Trk::sctEndCap5;
      layerMap[ { 2,-2, 6 } ] = Trk::sctEndCap6;
      layerMap[ { 2,-2, 7 } ] = Trk::sctEndCap7;
      layerMap[ { 2,-2, 8 } ] = Trk::sctEndCap8;
    }
 
    enum { position=0, detector=1, bec=2, layer=3, isGood=4 };
 
    // Lambda!
    auto getDetectorType = [&]( const ExtrapolatedPoint& point ) -> unsigned {
 
      const LayerCombination comb { std::get<detector>( point ), std::get<bec>( point ), std::get<layer>( point ) };
 
      for( auto& pair : layerMap ) {
        if( pair.first == comb ) {
          return pair.second;
        }
      }
 
      return AlgConsts::invalidUnsigned;
    };
 
    enum { kShouldNotHaveHit, kShouldHaveHit, kMayHaveHit };
    std::vector<unsigned> expectedHitPattern(Trk::numberOfDetectorTypes, kShouldNotHaveHit);
 
    auto minExpectedRadius = AlgConsts::maxValue;
 
    // Loop over extrapolated points (along direction)
    auto& exPattern_along = *( exPattern.first  );
 
    for( auto itr = exPattern_along.begin(); itr != exPattern_along.end(); ++itr ) {
      if( std::next( itr ) == exPattern_along.end() ) continue;
 
      const auto& point      = *itr;
      const auto& nextPoint  = *( std::next( itr ) );
 
      ATH_MSG_VERBOSE( " > " <<  __FUNCTION__ << ": isGood = " << std::get<isGood>( point ) );
 
      const auto& thisPos = std::get<position>( point );
      const auto& nextPos = std::get<position>( nextPoint );
 
      auto sectionVector = nextPos - thisPos;
      auto vertexVector  = TVector3( vertex.x(), vertex.y(), vertex.z() ) - thisPos;
 
 
      const auto& detectorType = getDetectorType( point );
 
      ATH_MSG_VERBOSE( " > " <<  __FUNCTION__ << ": detType = " << detectorType );
 
      if( detectorType == AlgConsts::invalidUnsigned ) continue;
      if( detectorType >= Trk::numberOfDetectorTypes ) continue;
 
      // if the vertex is nearby (within 10 mm), the hit may be presnet ("X")
      if( vertexVector.Mag() < 10. ) {
        expectedHitPattern.at( detectorType ) = kMayHaveHit;
        continue;
      }
 
      // if the front-end module is not active, then the hit is not expected,
      // which means the hit may be present
      if( !static_cast<bool>(std::get<isGood>( point )) ) {
        expectedHitPattern.at( detectorType ) = kMayHaveHit;
        continue;
      }
 
      // if the inner product of the above two vectors is positive,
      // then point is inner than the vertex.
      // Else, the point is outer than the vertex and expect to have hits
      // when the track is originated from the vertex.
 
      if( sectionVector.Mag() == 0. ) continue;
 
      ATH_MSG_VERBOSE( " > " <<  __FUNCTION__
                       << ": hitPos = (" << thisPos.Perp() << ", " << thisPos.z() << ", " << thisPos.Phi() << ")"
                       << ", sectionVec = (" << sectionVector.Perp() << ", " << sectionVector.z() << ", " << sectionVector.Phi() << ")"
                       << ", vertexVec = (" << vertexVector.Perp() << ", " << vertexVector.z() << ", " << vertexVector.Phi() << ")"
                       << ", cos(s,v)  = " << sectionVector * vertexVector / ( sectionVector.Mag() * vertexVector.Mag() + AlgConsts::infinitesimal ) );
 
      if( sectionVector * vertexVector > 0. ) continue;
 
      if( minExpectedRadius > thisPos.Perp() ) minExpectedRadius = thisPos.Perp();
 
      // now, the hit is expected to present.
 
      expectedHitPattern.at( detectorType ) = kShouldHaveHit;
    }
 
    // Loop over extrapolated points (opposite direction)
    auto& exPattern_oppos = *( exPattern.second );
    bool oppositeFlag = false;
 
    for( auto itr = exPattern_oppos.begin(); itr != exPattern_oppos.end(); ++itr ) {
      if( std::next( itr ) == exPattern_oppos.end() ) continue;
 
      const auto& point      = *itr;
      const auto& nextPoint  = *( std::next( itr ) );
 
      const auto& thisPos = std::get<position>( point );
      const auto& nextPos = std::get<position>( nextPoint );
 
      auto sectionVector = nextPos - thisPos;
      auto vertexVector  = TVector3( vertex.x(), vertex.y(), vertex.z() ) - thisPos;
 
      const auto& detectorType = getDetectorType( point );
 
      ATH_MSG_VERBOSE( " > " <<  __FUNCTION__ << ": detType = " << detectorType );
 
      ATH_MSG_DEBUG( " > " <<  __FUNCTION__
                       << ": hitPos = (" << thisPos.Perp() << ", " << thisPos.z() << ", " << thisPos.Phi() << ")"
                       << ", vertex = (" << vertex.perp() << ", " << vertex.z() << ", " << vertex.phi() << ")"
                       << ", cos(s,v)  = " << sectionVector * vertexVector / ( sectionVector.Mag() * vertexVector.Mag() + AlgConsts::infinitesimal ) );
 
      if( detectorType == AlgConsts::invalidUnsigned ) continue;
      if( detectorType >= Trk::numberOfDetectorTypes ) continue;
 
      if( sectionVector * vertexVector < 0. ) {
        oppositeFlag = true;
      }
    }
 
    // If the first expected point's radius is smaller than the vertex radius,
    // it's the case that the vertex was reconstructed in the opposite phi-direction
    // to the track outgoing direction. Such a case should be rejected.
    // bool oppositeFlag = ( minExpectedRadius < vertex.perp() );
 
    std::string msg = "Expected hit pattern: ";
    for( unsigned i=0; i<Trk::numberOfDetectorTypes; i++) {
      msg += Form("%s", expectedHitPattern.at(i) < kMayHaveHit? Form("%u", expectedHitPattern.at(i)) : "X" );
    }
    ATH_MSG_DEBUG( " > " << __FUNCTION__ << ": " << msg );
 
    msg = "Recorded hit pattern: ";
    for( unsigned i=0; i<Trk::numberOfDetectorTypes; i++) {
      msg += Form("%u", ( trk->hitPattern() >> i ) & 1 );
    }
    ATH_MSG_DEBUG( " > " << __FUNCTION__ << ": " << msg );
 
    std::vector<unsigned> matchedLayers;
 
    for( unsigned i=0; i<Trk::numberOfDetectorTypes; i++) {
      const unsigned recordedPattern = ( (trk->hitPattern()>>i) & 1 );
 
      if( expectedHitPattern.at(i) == kMayHaveHit ) {
        matchedLayers.emplace_back( i );
      } else if( expectedHitPattern.at(i) == kShouldHaveHit ) {
        if( expectedHitPattern.at(i) != recordedPattern ) {
          break;
        } else {
          matchedLayers.emplace_back( i );
        }
      } else {
        if( expectedHitPattern.at(i) != recordedPattern ) {
          break;
        }
      }
 
    }
 
    uint8_t PixelHits = 0;
    uint8_t SctHits   = 0;
    uint8_t TRTHits   = 0;
    if( !(trk->summaryValue( PixelHits, xAOD::numberOfPixelHits ) ) ) PixelHits =0;
    if( !(trk->summaryValue( SctHits,   xAOD::numberOfSCTHits   ) ) ) SctHits   =0;
    if( !(trk->summaryValue( TRTHits,   xAOD::numberOfTRTHits   ) ) ) TRTHits   =0;
 
    auto dphi = trk->phi() - vertex.phi();
    while( dphi >  TMath::Pi() ) dphi -= TMath::TwoPi();
    while( dphi < -TMath::Pi() ) dphi += TMath::TwoPi();
 
    ATH_MSG_DEBUG( " > " << __FUNCTION__ << ": vtx phi = " << vertex.phi() << ", track phi = " << trk->phi() << ", dphi = " << dphi
                   << ", oppositeFlag = " << oppositeFlag
                   << ", nPixelHits = " << static_cast<int>(PixelHits)
                   << ", nSCTHits = " << static_cast<int>(SctHits)
                   << ", nTRTHits = " << static_cast<int>(TRTHits)
                   << ", nMatchedLayers = " << matchedLayers.size() );
 
    if( PixelHits == 0 && vertex.perp() > 300. ) {
      ATH_MSG_DEBUG( " > " << __FUNCTION__ << ": vertex r > 300 mm, w/o no pixel hits" );
    }
 
 
    // Requires the first 2 layers with the hit matches.
    if( matchedLayers.size() < 2 ) return false;
 
    // In case of the first matched layer is not within pixel barrel, requires the first 4 layers with the hit match
    if( matchedLayers.at(0) >= Trk::pixelEndCap0 ) {
      if( matchedLayers.size() < 4 ) return false;
    }
 
    // Sometimes the vertex is reconstructed at the opposite phi direction.
    // In this case, the pattern match may pass.
    // This can be avoided by requiring that the
    if( oppositeFlag ) return false;
 
    // The following condition should apply for vertices outer than IBL.
    if( false /*matchedLayers.at(0) > Trk::pixelBarrel0*/ ) {
 
      // If the dphi (defined above) is opposite, reject.
      if( fabs( dphi ) > TMath::Pi()/2.0 ) return false;
 
      // If the track is not within the forward hemisphere to the vertex, reject.
      TVector3 trkP; trkP.SetPtEtaPhi( trk->pt(), trk->eta(), trk->phi() );
      TVector3 vtx; vtx.SetXYZ( vertex.x(), vertex.y(), vertex.z() );
      if( trkP.Dot( vtx ) < 0. ) return false;
 
    }
 
    return true;
  }

checkTrackHitPatternToVertexByExtrapolationAssist()

bool VKalVrtAthena::VrtSecInclusive::checkTrackHitPatternToVertexByExtrapolationAssist ( const xAOD::TrackParticle * trk, const Amg::Vector3D & vertex )

private

New method with track extrapolation.

Definition at line 2068 of file Reconstruction/VKalVrt/VrtSecInclusive/src/Utilities.cxx.

  {
 
    if( m_extrapolatedPatternBank.find( trk ) == m_extrapolatedPatternBank.end() ) {
 
      std::unique_ptr<ExtrapolatedPattern> exPattern_along( extrapolatedPattern( trk, Trk::alongMomentum ) );
 
      m_extrapolatedPatternBank.emplace( trk, std::make_pair( std::move(exPattern_along), nullptr ) );
 
    }
 
    if( vertex.perp() < 31.0 ) {
      double dphi = trk->phi() - vertex.phi();
      while( dphi >  TMath::Pi() ) { dphi -= TMath::TwoPi(); }
      while( dphi < -TMath::Pi() ) { dphi += TMath::TwoPi(); }
      if( cos(dphi) < -0.8 ) return false;
    }
 
    auto& exPattern = m_extrapolatedPatternBank.at( trk );
 
    using LayerCombination = std::vector<int>;
 
    std::map<LayerCombination, unsigned> layerMap;
    if( layerMap.empty() ) {
      layerMap[ { 1, 0, 0 } ] = Trk::pixelBarrel0;
      layerMap[ { 1, 0, 1 } ] = Trk::pixelBarrel1;
      layerMap[ { 1, 0, 2 } ] = Trk::pixelBarrel2;
      layerMap[ { 1, 0, 3 } ] = Trk::pixelBarrel3;
 
      layerMap[ { 1, 2, 0 } ] = Trk::pixelEndCap0;
      layerMap[ { 1, 2, 1 } ] = Trk::pixelEndCap1;
      layerMap[ { 1, 2, 2 } ] = Trk::pixelEndCap2;
      layerMap[ { 1,-2, 0 } ] = Trk::pixelEndCap0;
      layerMap[ { 1,-2, 1 } ] = Trk::pixelEndCap1;
      layerMap[ { 1,-2, 2 } ] = Trk::pixelEndCap2;
 
      layerMap[ { 2, 0, 0 } ] = Trk::sctBarrel0;
      layerMap[ { 2, 0, 1 } ] = Trk::sctBarrel1;
      layerMap[ { 2, 0, 2 } ] = Trk::sctBarrel2;
      layerMap[ { 2, 0, 3 } ] = Trk::sctBarrel3;
 
      layerMap[ { 2, 2, 0 } ] = Trk::sctEndCap0;
      layerMap[ { 2, 2, 1 } ] = Trk::sctEndCap1;
      layerMap[ { 2, 2, 2 } ] = Trk::sctEndCap2;
      layerMap[ { 2, 2, 3 } ] = Trk::sctEndCap3;
      layerMap[ { 2, 2, 4 } ] = Trk::sctEndCap4;
      layerMap[ { 2, 2, 5 } ] = Trk::sctEndCap5;
      layerMap[ { 2, 2, 6 } ] = Trk::sctEndCap6;
      layerMap[ { 2, 2, 7 } ] = Trk::sctEndCap7;
      layerMap[ { 2, 2, 8 } ] = Trk::sctEndCap8;
      layerMap[ { 2,-2, 0 } ] = Trk::sctEndCap0;
      layerMap[ { 2,-2, 1 } ] = Trk::sctEndCap1;
      layerMap[ { 2,-2, 2 } ] = Trk::sctEndCap2;
      layerMap[ { 2,-2, 3 } ] = Trk::sctEndCap3;
      layerMap[ { 2,-2, 4 } ] = Trk::sctEndCap4;
      layerMap[ { 2,-2, 5 } ] = Trk::sctEndCap5;
      layerMap[ { 2,-2, 6 } ] = Trk::sctEndCap6;
      layerMap[ { 2,-2, 7 } ] = Trk::sctEndCap7;
      layerMap[ { 2,-2, 8 } ] = Trk::sctEndCap8;
    }
 
    enum { position=0, detector=1, bec=2, layer=3, isGood=4 };
 
    // Lambda!
    auto getDetectorType = [&]( const ExtrapolatedPoint& point ) -> unsigned {
 
      const LayerCombination comb { std::get<detector>( point ), std::get<bec>( point ), std::get<layer>( point ) };
 
      for( auto& pair : layerMap ) {
        if( pair.first == comb ) {
          return pair.second;
        }
      }
 
      return AlgConsts::invalidUnsigned;
    };
 
    uint32_t disabledPattern { 0 };
 
    // Loop over extrapolated points (along direction)
    auto& exPattern_along = *( exPattern.first  );
 
    for( auto itr = exPattern_along.begin(); itr != exPattern_along.end(); ++itr ) {
      if( std::next( itr ) == exPattern_along.end() ) continue;
 
      const auto& point = *itr;
 
      ATH_MSG_VERBOSE( " > " <<  __FUNCTION__ << ": isGood = " << std::get<isGood>( point ) );
 
      if( !std::get<isGood>( point ) ) {
        const auto& detectorType = getDetectorType( point );
        disabledPattern += (1 << detectorType);
      }
    }
 
    uint32_t hitPattern      = trk->hitPattern();
    uint32_t modifiedPattern = disabledPattern | hitPattern;
 
    std::string msg = "Disabled hit pattern: ";
    for( unsigned i=0; i<Trk::numberOfDetectorTypes; i++) {
      msg += Form("%u", ( disabledPattern >> i ) & 1 );
    }
    ATH_MSG_DEBUG( " > " << __FUNCTION__ << ": " << msg );
 
    msg = "Recorded hit pattern: ";
    for( unsigned i=0; i<Trk::numberOfDetectorTypes; i++) {
      msg += Form("%u", ( hitPattern >> i ) & 1 );
    }
    ATH_MSG_DEBUG( " > " << __FUNCTION__ << ": " << msg );
 
    return patternCheck( modifiedPattern, vertex );
 
  }

checkTrackHitPatternToVertexOuterOnly()

bool VKalVrtAthena::VrtSecInclusive::checkTrackHitPatternToVertexOuterOnly ( const xAOD::TrackParticle * trk, const Amg::Vector3D & vertex )

private

A classical method with hard-coded geometry.

Definition at line 2057 of file Reconstruction/VKalVrt/VrtSecInclusive/src/Utilities.cxx.

  {
 
    const uint32_t pattern = trk->hitPattern();
 
    return patternCheckOuterOnly( pattern, vertex );
 
  }

clearNtupleVariables()

StatusCode VKalVrtAthena::VrtSecInclusive::clearNtupleVariables ( )

private

Definition at line 227 of file AANT_Tools.cxx.

                                                   {
    
    m_ntupleVars->clear();
    
    return StatusCode::SUCCESS;
  }

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperties()

void VKalVrtAthena::VrtSecInclusive::declareProperties ( )

private

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

defineDummyCollections()

StatusCode VKalVrtAthena::VrtSecInclusive::defineDummyCollections ( const EventContext & ctx )

private

Definition at line 273 of file VrtSecInclusive.cxx.

  {
    if ( not m_vertexCollectionsDefinitions.at(m_vertexKey.key()) ) {
      ATH_CHECK( dummyVertexContainer(ctx, m_vertexKey) );
    }
 
    if (m_FillIntermediateVertices) {
      if (not m_vertexCollectionsDefinitions.at( m_twoTrksVertexKey.key() )) {
    ATH_CHECK( dummyVertexContainer(ctx, m_twoTrksVertexKey) );
      }
 
      for (const auto& [nameAlgo, handleKey] : m_intermediateVertexKey) {
    if (not m_vertexCollectionsDefinitions.at( handleKey.key() )) {
      ATH_CHECK( dummyVertexContainer(ctx, handleKey) );
    }
      }
    }
    
    return StatusCode::SUCCESS;
  }

deleteNtupleVariables()

StatusCode VKalVrtAthena::VrtSecInclusive::deleteNtupleVariables ( )

private

Definition at line 209 of file AANT_Tools.cxx.

                                                    {
    
    m_ntupleVars->deleteNtupleVariables();
    
    return StatusCode::SUCCESS;
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

disassembleVertex()

StatusCode VKalVrtAthena::VrtSecInclusive::disassembleVertex ( std::vector< WrkVrt > * workVerticesContainer, const unsigned & vertexIndex )

private

Definition at line 118 of file Reconstruction/VKalVrt/VrtSecInclusive/src/Utilities.cxx.

  {
 
    auto& wrkvrt = workVerticesContainer->at(iv);
 
    ATH_MSG_VERBOSE(" >> disassembleVertex(): begin: disassembling vertex[" << iv << "], workVerticesContainer.size() = " << workVerticesContainer->size() );
    ATH_MSG_VERBOSE(" >> disassembleVertex(): Vertex: r = " << wrkvrt.vertex.perp() << ", z = " << wrkvrt.vertex.z() );
 
    // Loop over the tracks associated to the vertex and slect the maximum chi2 track
    const auto& ntrk = wrkvrt.selectedTrackIndices.size();
    size_t maxChi2TrackIndex       = AlgConsts::invalidUnsigned;
 
    // If the size of the tracks is less than 2, this algorithm is meaningless.
    if( wrkvrt.selectedTrackIndices.size() <= 2 ) return StatusCode::SUCCESS;
 
    for( auto& index : wrkvrt.selectedTrackIndices ) {
      const xAOD::TrackParticle* trk = m_selectedTracks.at( index );
 
      ATH_MSG_VERBOSE(" >> disassembleVertex(): > track at vertex[" << iv << "]: "
          << "index = " << trk->index()
          << ", pT = "  << trk->pt()
          << ", phi = " << trk->phi()
          << ", d0 = "  << trk->d0()
          << ", z0 = "  << trk->z0());
    }
 
    // find the track with the maximum chi2
    const auto& max = std::max_element( wrkvrt.Chi2PerTrk.begin(), wrkvrt.Chi2PerTrk.end() );
 
    if( max == wrkvrt.Chi2PerTrk.end() ) return StatusCode::SUCCESS;
 
    maxChi2TrackIndex = max - wrkvrt.Chi2PerTrk.begin();
 
    // return if no track is found.
    if(maxChi2TrackIndex == AlgConsts::invalidUnsigned ) return StatusCode::SUCCESS;
 
 
    // define work variables
    vector<const xAOD::NeutralParticle*>  dummyNeutrals;
 
    vector<WrkVrt> new_vertices;
 
    // Loop over the tracks associated to the vertex other than the selected tracks
    ATH_MSG_VERBOSE(" >> disassembleVertex(): Loop over the tracks associated to the vertex other than the selected tracks.");
    for(size_t itrk=0; itrk<ntrk; itrk++) {
 
      ATH_MSG_VERBOSE(" >> disassembleVertex(): > Loop itrk = " << itrk << " / " << ntrk );
 
      // reject the selected track
      if( itrk == maxChi2TrackIndex ) {
  ATH_MSG_VERBOSE(" >> disassembleVertex(): > skipped." );
  continue;
      }
 
      const size_t this_trk_id     = wrkvrt.selectedTrackIndices[itrk];
      const size_t selected_trk_id = wrkvrt.selectedTrackIndices[maxChi2TrackIndex];
 
      ATH_MSG_VERBOSE(" >> disassembleVertex(): > this_trk_id  = " << this_trk_id << ", selected_trk_id = " << selected_trk_id << ", alltrks_size = " << m_selectedTracks.size() );
      if( this_trk_id >= m_selectedTracks.size() ) {
  ATH_MSG_VERBOSE(" >> disassembleVertex(): > this_trk_id is invalid. continue!" );
  continue;
      }
      if( selected_trk_id >= m_selectedTracks.size() ) {
  ATH_MSG_VERBOSE(" >> disassembleVertex(): > selected_trk_id is invalid. continue!" );
  continue;
      }
 
      ATH_MSG_VERBOSE(" >> disassembleVertex(): > Storing tracks to ListBaseTracks" );
      ATH_MSG_VERBOSE(" >> disassembleVertex(): > m_selectedTracks.at( this_trk_id ) = " << m_selectedTracks.at( this_trk_id     )->index() );
      ATH_MSG_VERBOSE(" >> disassembleVertex(): > m_selectedTracks.at( this_trk_id ) = " << m_selectedTracks.at( selected_trk_id )->index() );
 
      vector<const xAOD::TrackParticle*>    ListBaseTracks;
      ListBaseTracks.emplace_back( m_selectedTracks.at( this_trk_id     ) );
      ListBaseTracks.emplace_back( m_selectedTracks.at( selected_trk_id ) );
 
      ATH_MSG_VERBOSE(" >> disassembleVertex(): > ListBaseTracks was stored." );
 
      WrkVrt newvrt;
      newvrt.selectedTrackIndices.emplace_back( this_trk_id );
      newvrt.selectedTrackIndices.emplace_back( selected_trk_id );
 
      // Fit the new vertex
      ATH_MSG_VERBOSE(" >> disassembleVertex(): > Fast Fit" );
 
      std::unique_ptr<Trk::IVKalState> state = m_fitSvc->makeState();
      ATH_CHECK( m_fitSvc->VKalVrtFitFast( ListBaseTracks, newvrt.vertex, *state ) );
 
      ATH_MSG_VERBOSE( " >> disassembleVertex(): > ApproxVertex: r = " << newvrt.vertex.perp() << ", z = " << newvrt.vertex.z() );
 
      if( vtxVtxDistance( wrkvrt.vertex, newvrt.vertex ) > 10. )
        {
          m_fitSvc->setApproximateVertex( wrkvrt.vertex[0], wrkvrt.vertex[1], wrkvrt.vertex[2], *state );
        }
      else
        {
          m_fitSvc->setApproximateVertex( newvrt.vertex[0], newvrt.vertex[1], newvrt.vertex[2], *state );
        }
 
      ATH_MSG_VERBOSE(" >> disassembleVertex(): > Fit the new vertex" );
      StatusCode sc = m_fitSvc->VKalVrtFit(ListBaseTracks,
                                           dummyNeutrals,
                                           newvrt.vertex,
                                           newvrt.vertexMom,
                                           newvrt.Charge,
                                           newvrt.vertexCov,
                                           newvrt.Chi2PerTrk,
                                           newvrt.TrkAtVrt,
                                           newvrt.Chi2,
                                           *state);
 
      if( sc.isFailure() ) continue;
 
      newvrt.closestWrkVrtIndex    = 0;
      newvrt.closestWrkVrtValue    = AlgConsts::maxValue;
 
      // register the new vertex to the vertex list
      ATH_MSG_VERBOSE(" >> disassembleVertex(): > register the new vertex to the vertex list" );
      new_vertices.emplace_back( newvrt );
    }
 
    // remove the selected track from the original vertex
    wrkvrt.selectedTrackIndices.erase( wrkvrt.selectedTrackIndices.begin() + maxChi2TrackIndex ); //remove track
    ATH_MSG_VERBOSE(" >> disassembleVertex(): removed the selected track from the original vertex. wrkvrt.selectedTrackIndices.size = " << wrkvrt.selectedTrackIndices.size() );
 
    // refit the original vertex
    ATH_MSG_VERBOSE(" >> disassembleVertex(): refit the original vertex" );
 
    StatusCode sc = refitVertex( wrkvrt );
    if( sc.isFailure() ) {
        // WARNING CODE ATLASRECTS-3145::001 refitVertex Failure, vertex lost
        ATH_MSG_WARNING("ATLASRECTS-3145::001" );
        return StatusCode::SUCCESS;
    }
    // end of workaround
 
    for( const auto& vertex : new_vertices ) {
      ATH_MSG_VERBOSE(" >> disassembleVertex(): > emplace_back new vertex" );
      workVerticesContainer->emplace_back( vertex );
    }
 
    ATH_MSG_VERBOSE(" >> disassembleVertex(): end. workVerticesContainer.size() = " << workVerticesContainer->size() );
    return StatusCode::SUCCESS;
  }

distanceBetweenVertices()

double VKalVrtAthena::VrtSecInclusive::distanceBetweenVertices ( const WrkVrt & v1, const WrkVrt & v2 ) const

private

calculate the physical distance

Definition at line 112 of file Reconstruction/VKalVrt/VrtSecInclusive/src/Utilities.cxx.

                                                                                            {
    return (v2.vertex - v1.vertex).norm();
  }

dummyVertexContainer()

StatusCode VKalVrtAthena::VrtSecInclusive::dummyVertexContainer ( const EventContext & ctx, const SG::WriteHandleKey< xAOD::VertexContainer > & handleKey )

private

Definition at line 263 of file VrtSecInclusive.cxx.

  {
    SG::WriteHandle<xAOD::VertexContainer> vHandle = SG::makeHandle( handleKey, ctx );
    ATH_CHECK( vHandle.record( std::make_unique<xAOD::VertexContainer>(),
                   std::make_unique<xAOD::VertexAuxContainer>() ) );
    m_vertexCollectionsDefinitions.at(handleKey.key()) = true;
    return StatusCode::SUCCESS;
  }

dumpTruthInformation()

void VKalVrtAthena::VrtSecInclusive::dumpTruthInformation ( )

private

Definition at line 2227 of file Reconstruction/VKalVrt/VrtSecInclusive/src/Utilities.cxx.

                                             {
 
    const xAOD::EventInfo*              eventInfo{};
    const xAOD::TruthParticleContainer* truthParticles{};
    const xAOD::TruthVertexContainer*   truthVertices{};
 
    auto sc0 = evtStore()->retrieve( eventInfo, "EventInfo" );
    if( sc0.isFailure() ) { return; }
 
    if( !eventInfo->eventType( xAOD::EventInfo::IS_SIMULATION ) ) {
      return;
    }
 
    auto sc1 = evtStore()->retrieve( truthParticles, "TruthParticles" );
    if( sc1.isFailure() ) { return; }
 
    auto sc2 = evtStore()->retrieve( truthVertices, "TruthVertices" );
    if( sc2.isFailure() ) { return; }
 
    if( !truthParticles ) { return; }
    if( !truthVertices  ) { return; }
 
    m_tracingTruthVertices.clear();
 
    std::vector<const xAOD::TruthParticle*> truthSvTracks;
 
    // truth particle selection functions
 
    auto selectNone = [](const xAOD::TruthVertex*) ->bool { return false; };
 
    auto selectRhadron = [](const xAOD::TruthVertex* truthVertex ) -> bool {
      if( truthVertex->nIncomingParticles() != 1 )                      return false;
      if( !truthVertex->incomingParticle(0) )                           return false;
      if( abs(truthVertex->incomingParticle(0)->pdgId()) < 1000000 )    return false;
      if( abs(truthVertex->incomingParticle(0)->pdgId()) > 1000000000 ) return false; // Nuclear codes, e.g. deuteron
      // neutralino in daughters
      bool hasNeutralino = false;
      for( unsigned ip = 0; ip < truthVertex->nOutgoingParticles(); ip++ ) {
        const auto* p = truthVertex->outgoingParticle(ip);
        if( abs( p->pdgId() ) == 1000022 ) {
          hasNeutralino = true;
          break;
        }
      }
      return hasNeutralino;
    };
 
    auto selectHNL = [](const xAOD::TruthVertex* truthVertex ) -> bool {
      if( truthVertex->nIncomingParticles() != 1 )                      return false;
      if( !truthVertex->incomingParticle(0) )                           return false;
      if( abs(truthVertex->incomingParticle(0)->pdgId()) != 50 )        return false;
      return true;
    };
 
    auto selectHiggs = [](const xAOD::TruthVertex* truthVertex ) -> bool {
      if( truthVertex->nIncomingParticles() != 1 )                      return false;
      if( !truthVertex->incomingParticle(0) )                           return false;
      if( abs(truthVertex->incomingParticle(0)->pdgId()) != 36 )        return false;
      return true;
    };
 
    auto selectKshort = [](const xAOD::TruthVertex* truthVertex ) -> bool {
      if( truthVertex->nIncomingParticles() != 1 )                      return false;
      if( !truthVertex->incomingParticle(0) )                           return false;
      if( abs(truthVertex->incomingParticle(0)->pdgId()) != 310 )       return false;
      return true;
    };
 
    auto selectBhadron = [](const xAOD::TruthVertex* truthVertex ) -> bool {
      if( truthVertex->nIncomingParticles() != 1 )                      return false;
      if( !truthVertex->incomingParticle(0) )                           return false;
      if( abs(truthVertex->incomingParticle(0)->pdgId()) <= 500 || abs(truthVertex->incomingParticle(0)->pdgId()) >= 600 ) return false;
      return true;
    };
 
    auto selectHadInt = [](const xAOD::TruthVertex* truthVertex ) -> bool {
      if( truthVertex->nIncomingParticles() != 1 )                      return false;
      if( !truthVertex->incomingParticle(0) )                           return false;
 
      const auto* parent = truthVertex->incomingParticle(0);
      if( parent->isLepton() )                                          return false;
 
      TLorentzVector p4sum_in;
      TLorentzVector p4sum_out;
      for( unsigned ip = 0; ip < truthVertex->nIncomingParticles(); ip++ ) {
        const auto* particle = truthVertex->incomingParticle(ip);
        TLorentzVector p4; p4.SetPtEtaPhiM( particle->pt(), particle->eta(), particle->phi(), particle->m() );
        p4sum_in += p4;
      }
      for( unsigned ip = 0; ip < truthVertex->nOutgoingParticles(); ip++ ) {
        const auto* particle = truthVertex->outgoingParticle(ip);
        TLorentzVector p4; p4.SetPtEtaPhiM( particle->pt(), particle->eta(), particle->phi(), particle->m() );
        p4sum_out += p4;
      }
      return p4sum_out.E() - p4sum_in.E() >= 100.;
    };
 
 
 
    using ParticleSelectFunc = bool (*)(const xAOD::TruthVertex*);
    std::map<std::string, ParticleSelectFunc> selectFuncs { { "",        selectNone    },
                                                            { "Kshort",  selectKshort  },
                                                            { "Bhadron", selectBhadron },
                                                            { "Rhadron", selectRhadron },
                                                            { "HNL",     selectHNL     },
                                                            { "Higgs",   selectHiggs   },
                                                            { "HadInt",  selectHadInt  }  };
 
 
    if( selectFuncs.find( m_truthParticleFilter ) == selectFuncs.end() ) {
      ATH_MSG_WARNING( " > " << __FUNCTION__ << ": invalid function specification: " << m_truthParticleFilter );
      return;
    }
 
    auto selectFunc = selectFuncs.at( m_truthParticleFilter );
 
    // loop over truth vertices
    for( const auto *truthVertex : *truthVertices ) {
      if( selectFunc( truthVertex ) ) {
        m_tracingTruthVertices.emplace_back( truthVertex );
        std::string msg;
        msg += Form("pdgId = %d, (r, z) = (%.2f, %.2f), ", truthVertex->incomingParticle(0)->pdgId(), truthVertex->perp(), truthVertex->z());
        msg += Form("nOutgoing = %lu, ", truthVertex->nOutgoingParticles() );
        msg += Form("mass = %.3f GeV, pt = %.3f GeV", truthVertex->incomingParticle(0)->m()/1.e3, truthVertex->incomingParticle(0)->pt()/1.e3 );
        ATH_MSG_DEBUG( " > " << __FUNCTION__ << ": " << msg );
      }
    }
 
    if( m_FillHist ) {
      for( const auto* truthVertex : m_tracingTruthVertices ) {
        m_hists["nMatchedTruths"]->Fill( 0., truthVertex->perp() );
      }
    }
 
  }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode VKalVrtAthena::VrtSecInclusive::execute ( )

overridevirtual

Definition at line 314 of file VrtSecInclusive.cxx.

  {
    const EventContext& ctx = Gaudi::Hive::currentContext();
    
    //
    ATH_MSG_DEBUG("VrtSecInclusive execute()");
 
    // Reset values
    for (auto& [key, val] : m_vertexCollectionsDefinitions) {
      val = false;
    }
    
    m_vertexingStatus = -1;
 
    SG::ReadHandle<xAOD::EventInfo> eventInfo = SG::makeHandle(m_eventInfoKey, ctx);
    if (!eventInfo.isValid()) {
      ATH_MSG_ERROR ("Could not retrieve EventInfo");
      return StatusCode::FAILURE;
    }
 
    SG::WriteDecorHandle<xAOD::EventInfo,int> vertexingStatusDecor(m_vertexingStatusKey, ctx);
 
    // clear ntuple variables
    StatusCode sc = this->initEvent();
    if(sc.isFailure()) {
      ATH_MSG_WARNING("Problem in initEvent ");
      vertexingStatusDecor(*eventInfo) = m_vertexingStatus;
      ATH_CHECK(defineDummyCollections(ctx));
      return StatusCode::SUCCESS;
    }
 
    // add event level info to ntuple
    if( m_FillNtuple ) sc = addEventInfo();
 
    if (sc.isFailure() ) {
      ATH_MSG_WARNING("Failure in getEventInfo() ");
      vertexingStatusDecor(*eventInfo) = m_vertexingStatus;
      ATH_CHECK(defineDummyCollections(ctx));
      return StatusCode::SUCCESS;
    }
 

    //
    // Setup StoreGate Variables
    //
 
    // Check Return StatusCode::Failure if the user-specified container names have duplication.
    {
      std::vector<std::string> userContainerNames { m_secondaryVerticesContainerName, m_all2trksVerticesContainerName };
      std::set<std::string> userContainerNamesSet;
      for( auto& name : userContainerNames ) userContainerNamesSet.insert( name );
      if( userContainerNamesSet.size() != userContainerNames.size() ) {
        ATH_MSG_ERROR( " > " << __FUNCTION__ << ": detected duplicated user-specified container name. Please check your job property" );
        return StatusCode::FAILURE;
      }
    }
 
 
    dumpTruthInformation();
 
 
    // Later use elsewhere in the algorithm
    m_selectedTracks.clear();
    m_associatedTracks.clear();
    m_leptonicTracks.clear();
 
    m_extrapolatedPatternBank.clear();

    //
    // now start algorithm
    //
 
    //--------------------------------------------------------
    //  Primary vertex processing
    //
    sc = this->processPrimaryVertices(); // fetch the 1st primary reconstructed vertex
 
    if( sc.isFailure() or !m_thePV ) {
 
      ATH_MSG_WARNING("processPrimaryVertices() failed");
      vertexingStatusDecor(*eventInfo) = m_vertexingStatus;
      ATH_CHECK(defineDummyCollections(ctx));
      return StatusCode::SUCCESS;
    }
 
    // Perform track selection and store it to selectedBaseTracks
    for( auto alg : m_trackSelectionAlgs ) {
      ATH_CHECK( (this->*alg)(ctx) );
    }
 
    if( m_FillNtuple )
      m_ntupleVars->get<unsigned int>( "NumSelTrks" ) = static_cast<int>( m_selectedTracks.size() );
 
    // fill information about selected tracks in AANT
    ATH_CHECK( fillAANT_SelectedBaseTracks() );
 
    //-------------------------------------------------------
    // Skip the event if the number of selected tracks is more than m_SelTrkMaxCutoff
    if( m_selectedTracks.size() < 2 ) {
      ATH_MSG_DEBUG( "execute: Too few (<2) selected reco tracks. Terminated reconstruction." );
      m_vertexingStatus = 1;
      vertexingStatusDecor(*eventInfo) = m_vertexingStatus;
      ATH_CHECK( lockTrackDecorations( true, ctx ) );
      ATH_CHECK(defineDummyCollections(ctx));
      return StatusCode::SUCCESS;
    }
 
    if( m_selectedTracks.size() > m_SelTrkMaxCutoff ) {
      ATH_MSG_INFO( "execute: Too many selected reco tracks. Terminated reconstruction." );
      m_vertexingStatus = 2;
      vertexingStatusDecor(*eventInfo) = m_vertexingStatus;
      ATH_CHECK( lockTrackDecorations( true, ctx ) );
      ATH_CHECK(defineDummyCollections(ctx));
      return StatusCode::SUCCESS;
    }
 
    //-------------------------------------------------------
    // Core part of Vertexing
    //
 
    {
 
      m_vertexingAlgorithmStep = 0;
 
      // set of vertices created in the following while loop.
      std::vector<WrkVrt> workVerticesContainer;
 
      // the main sequence of the main vertexing algorithms
      // see initialize() what kind of algorithms exist.
      for( auto itr = m_vertexingAlgorithms.begin(); itr!=m_vertexingAlgorithms.end(); ++itr ) {
 
        auto& name = itr->first;
        auto alg   = itr->second;
 
        auto t_start = std::chrono::system_clock::now();
 
        ATH_CHECK( (this->*alg)( ctx, &workVerticesContainer ) );
 
        auto t_end = std::chrono::system_clock::now();
 
        if( m_FillHist ) {
          auto sec = std::chrono::duration_cast<std::chrono::microseconds>( t_end - t_start ).count();
          m_hists["CPUTime"]->Fill( m_vertexingAlgorithmStep, sec/1.e6 );
        }
 
        std::erase_if( workVerticesContainer,
                       []( WrkVrt& wrkvrt ) {
                         return ( !wrkvrt.isGood || wrkvrt.nTracksTotal() < 2 ); }
                       );
 
        ATH_CHECK( monitorVertexingAlgorithmStep( ctx, &workVerticesContainer, name, std::next( itr ) == m_vertexingAlgorithms.end() ) );
 
        m_vertexingAlgorithmStep++;
 
      }
    }
 
    m_vertexingStatus = 0;
    vertexingStatusDecor(*eventInfo) = m_vertexingStatus;
 
    // Fill AANT
    if( m_FillNtuple ) {
      m_tree_Vert->Fill();
      ATH_CHECK( clearNtupleVariables() );
    }
 
    ATH_CHECK( lockTrackDecorations( false, ctx ) );
 
    ATH_MSG_VERBOSE( "execute: process done." );
    // end
    ATH_CHECK(defineDummyCollections(ctx));
    return StatusCode::SUCCESS;
 
  }

extractIncompatibleTrackPairs()

StatusCode VKalVrtAthena::VrtSecInclusive::extractIncompatibleTrackPairs ( const EventContext & ctx, std::vector< WrkVrt > * workVerticesContainer )

private

related to the graph method and verte finding

Definition at line 39 of file VertexingAlgs.cxx.

  {
 
    // Output SVs as xAOD::Vertex
    // Needs a conversion function from WrkVrtSet to xAOD::Vertex here.
    // The supposed form of the function will be as follows:
 
    SG::WriteHandle<xAOD::VertexContainer> trackHandle;
    xAOD::VertexContainer *twoTrksVertexContainer{};
    if( m_FillIntermediateVertices ) {
      trackHandle = SG::makeHandle( m_twoTrksVertexKey, ctx );
      ATH_CHECK( trackHandle.record(std::make_unique<xAOD::VertexContainer>(),
                    std::make_unique<xAOD::VertexAuxContainer>()) );
      twoTrksVertexContainer = trackHandle.ptr();
      m_vertexCollectionsDefinitions[m_twoTrksVertexKey.key()] = true;
    }
 
    m_incomp.clear();
 
    // Work variables
    std::vector<const xAOD::TrackParticle*>    baseTracks;
    std::vector<const xAOD::NeutralParticle*>  dummyNeutrals;
 
    ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": Selected Tracks = "<< m_selectedTracks.size());
    if( m_FillHist ) { m_hists["selTracksDist"]->Fill( m_selectedTracks.size() ); }
 
    std::string msg;
 
    enum recoStep { kStart, kInitVtxPosition, kImpactParamCheck, kVKalVrtFit, kChi2, kVposCut, kPatternMatch };
 
    const double maxR { 563. };         // r = 563 mm is the TRT inner surface
    double roughD0Cut = 100.;
    double roughZ0Cut = 50.;
    if(m_doDisappearingTrackVertexing){
      roughD0Cut = 1000.;
      roughZ0Cut = 1000.;
    }
 
    // Truth match map
    std::map<const xAOD::TruthVertex*, bool> matchMap;
    std::unique_ptr<Trk::IVKalState> state = m_fitSvc->makeState();
    // first make all 2-track vertices
    for( auto itrk = m_selectedTracks.begin(); itrk != m_selectedTracks.end(); ++itrk ) {
      for( auto jtrk = std::next(itrk); jtrk != m_selectedTracks.end(); ++jtrk ) {
 
        // avoid both tracks are too close to the beam line
 
        const int itrk_id = itrk - m_selectedTracks.begin();
        const int jtrk_id = jtrk - m_selectedTracks.begin();
 
        WrkVrt wrkvrt;
        wrkvrt.selectedTrackIndices.emplace_back( itrk_id );
        wrkvrt.selectedTrackIndices.emplace_back( jtrk_id );
 
        // Attempt to think the combination is incompatible by default
        m_incomp.emplace_back( itrk_id, jtrk_id );
 
        if(m_doDisappearingTrackVertexing) {
 
          const auto* cont_i = dynamic_cast<const xAOD::TrackParticleContainer*>( (*itrk)->container() );
          const auto* cont_j = dynamic_cast<const xAOD::TrackParticleContainer*>( (*jtrk)->container() );
 
          if ( !cont_i || !cont_j ) {
            ATH_MSG_DEBUG("  one of the track containers is null");
            continue;
          }
 
          ElementLink<xAOD::TrackParticleContainer> link_i, link_j;
          link_i.toIndexedElement( *cont_i, (*itrk)->index() );
          link_j.toIndexedElement( *cont_j, (*jtrk)->index() );
 
          if (!link_i.isValid() || !link_j.isValid()) {
            ATH_MSG_DEBUG("  link itrk (" << (*itrk)->index() << ") or jtrk (" << (*jtrk)->index() << ") is not valid");
          }
          else {
            if( link_i.dataID() == link_j.dataID() ) {
              continue;
            }
          }
        }
 
 
        if( std::abs( (*itrk)->d0() ) < m_twoTrkVtxFormingD0Cut && std::abs( (*jtrk)->d0() ) < m_twoTrkVtxFormingD0Cut ) continue;
 
        baseTracks.clear();
        baseTracks.emplace_back( *itrk );
        baseTracks.emplace_back( *jtrk );
 
        if( m_FillHist ) m_hists["incompMonitor"]->Fill( kStart );
 
        // new code to find initial approximate vertex
        Amg::Vector3D initVertex;
 
        StatusCode sc = m_fitSvc->VKalVrtFitFast( baseTracks, initVertex, *state );/* Fast crude estimation */
        if( sc.isFailure() ) {
          ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": fast crude estimation fails ");
          continue;
        }
 
        if( initVertex.perp() > maxR ) {
          continue;
        }
        if( m_doDisappearingTrackVertexing && initVertex.perp() <m_twoTrVrtMinRadius){
          continue;
        }
        if( m_FillHist ) m_hists["incompMonitor"]->Fill( kInitVtxPosition );
 
        std::vector<double> impactParameters;
        std::vector<double> impactParErrors;
 
        if( !getSVImpactParameters( *itrk, initVertex, impactParameters, impactParErrors) ) continue;
        const auto roughD0_itrk = impactParameters.at(TrkParameter::k_d0);
        const auto roughZ0_itrk = impactParameters.at(TrkParameter::k_z0);
        if( fabs( impactParameters.at(0)) > roughD0Cut || fabs( impactParameters.at(1) ) > roughZ0Cut ) {
          continue;
        }
 
        if( !getSVImpactParameters( *jtrk, initVertex, impactParameters, impactParErrors) ) continue;
        const auto roughD0_jtrk = impactParameters.at(TrkParameter::k_d0);
        const auto roughZ0_jtrk = impactParameters.at(TrkParameter::k_z0);
        if( fabs( impactParameters.at(0) ) > roughD0Cut || fabs( impactParameters.at(1) ) > roughZ0Cut ) {
          continue;
        }
        if( m_FillHist ) m_hists["incompMonitor"]->Fill( kImpactParamCheck );
 
        m_fitSvc->setApproximateVertex( initVertex.x(), initVertex.y(), initVertex.z(), *state );
 
 
 
        // Vertex VKal Fitting
        sc = m_fitSvc->VKalVrtFit( baseTracks,
                                   dummyNeutrals,
                                   wrkvrt.vertex, wrkvrt.vertexMom, wrkvrt.Charge,
                                   wrkvrt.vertexCov, wrkvrt.Chi2PerTrk,
                                   wrkvrt.TrkAtVrt, wrkvrt.Chi2, *state  );
 
        if( sc.isFailure() ) {
          continue;          /* No fit */
        }
        if( m_FillHist ) m_hists["incompMonitor"]->Fill( kVKalVrtFit );
 
        // Compatibility to the primary vertex.
        Amg::Vector3D vDist = wrkvrt.vertex - m_thePV->position();
        const double vPos = ( vDist.x()*wrkvrt.vertexMom.Px()+vDist.y()*wrkvrt.vertexMom.Py()+vDist.z()*wrkvrt.vertexMom.Pz() )/wrkvrt.vertexMom.Rho();
        const double vPosMomAngT = ( vDist.x()*wrkvrt.vertexMom.Px()+vDist.y()*wrkvrt.vertexMom.Py() ) / vDist.perp() / wrkvrt.vertexMom.Pt();
        const double vPosMomAng3D = ( vDist.x()*wrkvrt.vertexMom.Px()+vDist.y()*wrkvrt.vertexMom.Py()+vDist.z()*wrkvrt.vertexMom.Pz() ) / (vDist.norm() * wrkvrt.vertexMom.Rho());
 
        double dphi1 = TVector2::Phi_mpi_pi(vDist.phi() - (*itrk)->phi());
        double dphi2 = TVector2::Phi_mpi_pi(vDist.phi() - (*jtrk)->phi());
 
        const double dist_fromPV = vDist.norm();
        if( m_FillHist ) m_hists["2trkVtxDistFromPV"]->Fill( dist_fromPV );
 
        if( m_FillNtuple ) {
          // Fill the 2-track vertex properties to AANT
          m_ntupleVars->get<unsigned int>( "All2TrkVrtNum" )++;
          m_ntupleVars->get< std::vector<double> >( "All2TrkVrtMass" )   .emplace_back(wrkvrt.vertexMom.M());
          m_ntupleVars->get< std::vector<double> >( "All2TrkVrtPt" )     .emplace_back(wrkvrt.vertexMom.Perp());
          m_ntupleVars->get< std::vector<int> >   ( "All2TrkVrtCharge" ) .emplace_back(wrkvrt.Charge);
          m_ntupleVars->get< std::vector<double> >( "All2TrkVrtX" )      .emplace_back(wrkvrt.vertex.x());
          m_ntupleVars->get< std::vector<double> >( "All2TrkVrtY" )      .emplace_back(wrkvrt.vertex.y());
          m_ntupleVars->get< std::vector<double> >( "All2TrkVrtZ" )      .emplace_back(wrkvrt.vertex.z());
          m_ntupleVars->get< std::vector<double> >( "All2TrkVrtChiSq" )  .emplace_back(wrkvrt.Chi2);
        }
 
 
        // Create a xAOD::Vertex instance
        xAOD::Vertex *vertex{};
 
        if( m_FillIntermediateVertices ) {
          vertex = new xAOD::Vertex;
          twoTrksVertexContainer->emplace_back( vertex );
 
          for( const auto *trk: baseTracks ) {
 
            // Acquire link to the track
            ElementLink<xAOD::TrackParticleContainer>  trackElementLink( *( dynamic_cast<const xAOD::TrackParticleContainer*>( trk->container() ) ), trk->index() );
 
            // Register link to the vertex
            vertex->addTrackAtVertex( trackElementLink, 1. );
          }
 
          vertex->setVertexType( xAOD::VxType::SecVtx );
          vertex->setPosition( wrkvrt.vertex );
          vertex->setFitQuality( wrkvrt.Chi2, 1 ); // Ndof is always 1
 
          static const SG::Accessor<float> massAcc("mass");
          static const SG::Accessor<float> pTAcc("pT");
          static const SG::Accessor<float> chargeAcc("charge");
          static const SG::Accessor<float> vPosAcc("vPos");
          static const SG::Accessor<bool>  isFakeAcc("isFake");
          massAcc(*vertex)   = wrkvrt.vertexMom.M();
          pTAcc(*vertex)     = wrkvrt.vertexMom.Perp();
          chargeAcc(*vertex) = wrkvrt.Charge;
          vPosAcc(*vertex)   = vPos;
          isFakeAcc(*vertex) = true;
        }
 

 
        uint8_t trkiBLHit,trkjBLHit;
        if( !((*itrk)->summaryValue( trkiBLHit,xAOD::numberOfInnermostPixelLayerHits)))  trkiBLHit=0;
        if( !((*jtrk)->summaryValue( trkjBLHit,xAOD::numberOfInnermostPixelLayerHits)))  trkjBLHit=0;
 
        if( m_FillNtuple ) m_ntupleVars->get< std::vector<int> >( "All2TrkSumBLHits" ).emplace_back( trkiBLHit + trkjBLHit );
 
        // track chi2 cut
        if( m_FillHist ) m_hists["2trkChi2Dist"]->Fill( log10( wrkvrt.Chi2 ) );
 
        if( wrkvrt.fitQuality() > m_SelVrtChi2Cut) {
          ATH_MSG_VERBOSE(" > " << __FUNCTION__ << ": failed to pass chi2 threshold." );
          continue;          /* Bad Chi2 */
        }
        if( m_FillHist ) m_hists["incompMonitor"]->Fill( kChi2 );
 
 
        ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": attempting form vertex from ( " << itrk_id << ", " << jtrk_id << " )." );
        ATH_MSG_DEBUG( " > " << __FUNCTION__ << ": candidate vertex: "
                       << " isGood  = "            << (wrkvrt.isGood? "true" : "false")
                       << ", #ntrks = "            << wrkvrt.nTracksTotal()
                       << ", #selectedTracks = "   << wrkvrt.selectedTrackIndices.size()
                       << ", #associatedTracks = " << wrkvrt.associatedTrackIndices.size()
                       << ", chi2/ndof = "         << wrkvrt.fitQuality()
                       << ", (r, z) = ("           << wrkvrt.vertex.perp()
                       <<", "                      << wrkvrt.vertex.z() << ")" );
 
        for( const auto* truthVertex : m_tracingTruthVertices ) {
          Amg::Vector3D vTruth( truthVertex->x(), truthVertex->y(), truthVertex->z() );
          Amg::Vector3D vReco ( wrkvrt.vertex.x(), wrkvrt.vertex.y(), wrkvrt.vertex.z() );
 
          const auto distance = vReco - vTruth;
 
          AmgSymMatrix(3) cov;
          cov.fillSymmetric( 0, 0, wrkvrt.vertexCov.at(0) );
          cov.fillSymmetric( 1, 0, wrkvrt.vertexCov.at(1) );
          cov.fillSymmetric( 1, 1, wrkvrt.vertexCov.at(2) );
          cov.fillSymmetric( 2, 0, wrkvrt.vertexCov.at(3) );
          cov.fillSymmetric( 2, 1, wrkvrt.vertexCov.at(4) );
          cov.fillSymmetric( 2, 2, wrkvrt.vertexCov.at(5) );
 
          const double s2 = distance.transpose() * cov.inverse() * distance;
 
          if( distance.norm() < 2.0 || s2 < 100. )  {
            ATH_MSG_DEBUG ( " > " << __FUNCTION__ << ": truth-matched candidate! : signif^2 = " << s2 );
            matchMap.emplace( truthVertex, true );
          }
        }
 
        if( m_FillHist ) {
          dynamic_cast<TH2F*>( m_hists["vPosDist"] )->Fill( wrkvrt.vertex.perp(), vPos );
          dynamic_cast<TH2F*>( m_hists["vPosMomAngTDist"] )->Fill( wrkvrt.vertex.perp(), vPosMomAngT );
          m_hists["vPosMomAngT"] ->Fill( vPosMomAngT );
          m_hists["vPosMomAng3D"] ->Fill(  vPosMomAng3D );
        }
 
        if( m_doTwoTrSoftBtag ){
          if(dist_fromPV < m_twoTrVrtMinDistFromPV ){
            ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": failed to pass the 2tr vertex min distance from PV cut." );
            continue;
          }
 
          if( vPosMomAng3D < m_twoTrVrtAngleCut ){
            ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": failed to pass the vertex angle cut." );
            continue;
          }
        }
 
        if( m_doPVcompatibilityCut ) {
          if( cos( dphi1 ) < -0.8 && cos( dphi2 ) < -0.8 ) {
            ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": failed to pass the vPos cut. (both tracks are opposite against the vertex pos)" );
            continue;
          }
          if (m_doTightPVcompatibilityCut && (cos( dphi1 ) < -0.8 || cos( dphi2 ) < -0.8)){
            ATH_MSG_DEBUG(" > "<< __FUNCTION__ << ": failed to pass the tightened vPos cut. (at least one track is opposite against the vertex pos)" );
            continue;
          }
          if( vPosMomAngT < -0.8 ) {
            ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": failed to pass the vPos cut. (pos-mom directions are opposite)" );
            continue;
          }
          if( vPos < m_pvCompatibilityCut ) {
            ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": failed to pass the vPos cut." );
            continue;
          }
        }
        if( m_FillHist ) m_hists["incompMonitor"]->Fill( kVposCut );
 
        // fake rejection cuts with track hit pattern consistencies
        if( m_removeFakeVrt && !m_removeFakeVrtLate ) {
          if( !this->passedFakeReject( wrkvrt.vertex, (*itrk), (*jtrk) ) ) {
 
            ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": failed to pass fake rejection algorithm." );
            continue;
          }
        }
        if( m_FillHist ) m_hists["incompMonitor"]->Fill( kPatternMatch );
 
        ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": passed fake rejection." );
 
        if( m_FillNtuple ) {
          // Fill AANT for vertices after fake rejection
          m_ntupleVars->get< unsigned int >( "AfFakVrtNum" )++;
          m_ntupleVars->get< std::vector<double> >( "AfFakVrtMass" )   .emplace_back(wrkvrt.vertexMom.M());
          m_ntupleVars->get< std::vector<double> >( "AfFakVrtPt" )     .emplace_back(wrkvrt.vertexMom.Perp());
          m_ntupleVars->get< std::vector<int> >   ( "AfFakVrtCharge" ) .emplace_back(wrkvrt.Charge);
          m_ntupleVars->get< std::vector<double> >( "AfFakVrtX" )      .emplace_back(wrkvrt.vertex.x());
          m_ntupleVars->get< std::vector<double> >( "AfFakVrtY" )      .emplace_back(wrkvrt.vertex.y());
          m_ntupleVars->get< std::vector<double> >( "AfFakVrtZ" )      .emplace_back(wrkvrt.vertex.z());
          m_ntupleVars->get< std::vector<double> >( "AfFakVrtChiSq" )  .emplace_back(wrkvrt.Chi2);
        }
 
        // The vertex passed the quality cut: overwrite isFake to false
        if( m_FillIntermediateVertices && vertex ) {
          static const SG::Accessor<bool> isFakeAcc("isFake");
          isFakeAcc(*vertex)  = false;
        }
 
 
        // Now this vertex passed all criteria and considred to be a compatible vertices.
        // Therefore the track pair is removed from the incompatibility list.
        m_incomp.pop_back();
 
        wrkvrt.isGood = true;
 
        workVerticesContainer->emplace_back( wrkvrt );
 
        msg += Form(" (%d, %d), ", itrk_id, jtrk_id );
 
        if( m_FillHist ) {
          m_hists["initVertexDispD0"]->Fill( roughD0_itrk, initVertex.perp() );
          m_hists["initVertexDispD0"]->Fill( roughD0_jtrk, initVertex.perp() );
          m_hists["initVertexDispZ0"]->Fill( roughZ0_itrk, initVertex.z()    );
          m_hists["initVertexDispZ0"]->Fill( roughZ0_jtrk, initVertex.z()    );
        }
 
      }
    }
 
 
    ATH_MSG_DEBUG( " > " << __FUNCTION__ << ": compatible track pairs = " << msg );
 
    if( m_FillNtuple ) m_ntupleVars->get<unsigned int>( "SizeIncomp" ) = m_incomp.size();
 
    if( m_FillHist ) {
      for( auto& pair: matchMap ) {
        if( pair.second ) m_hists["nMatchedTruths"]->Fill( 1, pair.first->perp() );
      }
    }
 
    return StatusCode::SUCCESS;
  }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return Algorithm::extraOutputDeps();
}

extrapolatedPattern()

VrtSecInclusive::ExtrapolatedPattern * VKalVrtAthena::VrtSecInclusive::extrapolatedPattern ( const xAOD::TrackParticle * trk, enum Trk::PropDirection direction )

private

Definition at line 971 of file Reconstruction/VKalVrt/VrtSecInclusive/src/Utilities.cxx.

                                                                                                                                          {
 
    auto* pattern = new ExtrapolatedPattern;
    const EventContext& ctx = Gaudi::Hive::currentContext();
    std::vector<std::unique_ptr<Trk::TrackParameters>> paramsVector =
      m_extrapolator->extrapolateBlindly(ctx, trk->perigeeParameters(), direction);
 
    TVector3 prevPos( AlgConsts::invalidFloat, AlgConsts::invalidFloat, AlgConsts::invalidFloat );
 
    auto nDisabled = 0;
 
    for( auto& params : paramsVector ) {
 
      const TVector3 position( params->position().x(), params->position().y(), params->position().z() );
 
      if( prevPos == position ) {
        continue;
      }
 
      prevPos = position;
 
      const auto* detElement = params->associatedSurface().associatedDetectorElement();
 
      if( detElement ) {
 
        enum { Pixel = 1, SCT = 2 };
 
        const auto& id = detElement->identify();
        Flag good = false;
 
        if( m_atlasId->is_pixel(id) ) {
 
          auto idHash = m_pixelId->wafer_hash( id );
          good = m_pixelCondSummaryTool->isGood( idHash, ctx );
 
          pattern->emplace_back( std::make_tuple( position, Pixel, m_pixelId->barrel_ec(id), m_pixelId->layer_disk(id), good ) );
 
        } else if( m_atlasId->is_sct(id) ) {
 
          auto idHash = m_sctId->wafer_hash( id );
          good = m_sctCondSummaryTool->isGood( idHash, ctx );
 
          pattern->emplace_back( std::make_tuple( position, SCT, m_sctId->barrel_ec(id), m_sctId->layer_disk(id), good ) );
 
        }
 
        if( !pattern->empty() ) {
 
          ATH_MSG_VERBOSE(" >> " << __FUNCTION__ << ", track " << trk << ": position = (" << position.Perp() << ", " << position.z() << ", " << position.Phi() << "), detElement ID = " << id << ", good = " << good
                          << ": (det, bec, layer) = (" << std::get<1>( pattern->back() ) << ", " << std::get<2>( pattern->back() ) << ", "  << std::get<3>( pattern->back() ) << ")" );
 
    if( !good ) nDisabled++;
        }
 
      }
 
    }
 
    if( m_FillHist ) {
      m_hists["disabledCount"]->Fill( nDisabled );
    }
 
    return pattern;
 
  }

fillAANT_SecondaryVertices()

StatusCode VKalVrtAthena::VrtSecInclusive::fillAANT_SecondaryVertices ( xAOD::VertexContainer * vertices )

private

Definition at line 351 of file AANT_Tools.cxx.

                                                                                        {
    
    // Loop over vertices
    for( xAOD::Vertex *vertex : *vertices ) {
      
      // Track Loop
      for(size_t itrk=0; itrk<vertex->nTrackParticles(); itrk++) {
        
        // Here trk is not const - will augment SV perigee variables in the loop.
        const xAOD::TrackParticle* trk = vertex->trackParticle( itrk );
        
        //
        // add variables for each track into ntuple
        // Add all vertices to same ntuple, and extract later in root macro 
        //
        m_ntupleVars->get< vector<double> >( "SecVtx_TrkPt" )      .emplace_back( trk->pt() );
        m_ntupleVars->get< vector<double> >( "SecVtx_TrkPhi" )     .emplace_back( trk->phi() );
        m_ntupleVars->get< vector<double> >( "SecVtx_TrkEta" )     .emplace_back( trk->eta() );
        m_ntupleVars->get< vector<double> >( "SecVtx_Trk2dIP" )    .emplace_back( trk->d0() );
        m_ntupleVars->get< vector<double> >( "SecVtx_TrkZIP" )     .emplace_back( trk->z0() );
        m_ntupleVars->get< vector<double> >( "SecVtx_Trkdel2dIP" ) .emplace_back( trk->definingParametersCovMatrix()(Trk::d0, Trk::d0) );
        m_ntupleVars->get< vector<double> >( "SecVtx_TrkdelZIP" )  .emplace_back( trk->definingParametersCovMatrix()(Trk::z0, Trk::z0) );
        
        track_summary trk_summary;
        fillTrackSummary( trk_summary, trk );
        
        m_ntupleVars->get< vector<int> >( "SecVtx_TrkBLay" )        .emplace_back( trk_summary.numIBLHits );
        m_ntupleVars->get< vector<int> >( "SecVtx_TrkPixExclBLay" ) .emplace_back( trk_summary.numPixelHits - trk_summary.numIBLHits );
        m_ntupleVars->get< vector<int> >( "SecVtx_TrkSCT" )         .emplace_back( trk_summary.numSctHits );
        
        static const SG::ConstAccessor<float> pt_wrtSVAcc("pt_wrtSV");
        static const SG::ConstAccessor<float> eta_wrtSVAcc("eta_wrtSV");
        static const SG::ConstAccessor<float> phi_wrtSVAcc("phi_wrtSV");
        static const SG::ConstAccessor<float> d0_wrtSVAcc("d0_wrtSV");
        static const SG::ConstAccessor<float> z0_wrtSVAcc("z0_wrtSV");
        static const SG::ConstAccessor<float> errP_wrtSVAcc("errP_wrtSV");
        static const SG::ConstAccessor<float> errd0_wrtSVAcc("errd0_wrtSV");
        static const SG::ConstAccessor<float> errz0_wrtSVAcc("errz0_wrtSV");
        ATH_MSG_VERBOSE(" >> fillAANT_SecondaryVertices : filling track vars wrt. SV");
        if( pt_wrtSVAcc.isAvailable(*trk) &&
            eta_wrtSVAcc.isAvailable(*trk) &&
            phi_wrtSVAcc.isAvailable(*trk) &&
            d0_wrtSVAcc.isAvailable(*trk) &&
            z0_wrtSVAcc.isAvailable(*trk) &&
            errP_wrtSVAcc.isAvailable(*trk) &&
            errd0_wrtSVAcc.isAvailable(*trk) &&
            errz0_wrtSVAcc.isAvailable(*trk)       ) {
          
          m_ntupleVars->get< vector<double> >( "SecVtx_TrkPtWrtSV" )      .emplace_back( pt_wrtSVAcc(*trk) );
          m_ntupleVars->get< vector<double> >( "SecVtx_TrkEtaWrtSV" )     .emplace_back( eta_wrtSVAcc(*trk) );
          m_ntupleVars->get< vector<double> >( "SecVtx_TrkPhiWrtSV" )     .emplace_back( phi_wrtSVAcc(*trk) );
          m_ntupleVars->get< vector<double> >( "SecVtx_Trk2dIPWrtSV" )    .emplace_back( d0_wrtSVAcc(*trk) );
          m_ntupleVars->get< vector<double> >( "SecVtx_TrkZIPWrtSV" )     .emplace_back( z0_wrtSVAcc(*trk) );
          m_ntupleVars->get< vector<double> >( "SecVtx_TrkdelPWrtSV" )    .emplace_back( errP_wrtSVAcc(*trk) );
          m_ntupleVars->get< vector<double> >( "SecVtx_Trkdel2dIPWrtSV" ) .emplace_back( errd0_wrtSVAcc(*trk) );
          m_ntupleVars->get< vector<double> >( "SecVtx_TrkdelZIPWrtSV" )  .emplace_back( errz0_wrtSVAcc(*trk) );
          
        } else {
          
          ATH_MSG_VERBOSE(" >> fillAANT_SecondaryVertices : filling track vars wrt. SV (invalid values)");
          
          m_ntupleVars->get< vector<double> >( "SecVtx_TrkPtWrtSV" )      .emplace_back( AlgConsts::invalidFloat );
          m_ntupleVars->get< vector<double> >( "SecVtx_TrkEtaWrtSV" )     .emplace_back( AlgConsts::invalidFloat );
          m_ntupleVars->get< vector<double> >( "SecVtx_TrkPhiWrtSV" )     .emplace_back( AlgConsts::invalidFloat );
          m_ntupleVars->get< vector<double> >( "SecVtx_Trk2dIPWrtSV" )    .emplace_back( AlgConsts::invalidFloat );
          m_ntupleVars->get< vector<double> >( "SecVtx_TrkZIPWrtSV" )     .emplace_back( AlgConsts::invalidFloat );
          m_ntupleVars->get< vector<double> >( "SecVtx_TrkdelPWrtSV" )    .emplace_back( AlgConsts::invalidFloat );
          m_ntupleVars->get< vector<double> >( "SecVtx_Trkdel2dIPWrtSV" ) .emplace_back( AlgConsts::invalidFloat );
          m_ntupleVars->get< vector<double> >( "SecVtx_TrkdelZIPWrtSV" )  .emplace_back( AlgConsts::invalidFloat );
          
        }
        
      } // loop over tracks in vertex
      
      ATH_MSG_DEBUG(" >> fillAANT_SecondaryVertices : Track loop end. ");
      
      ATH_MSG_VERBOSE(" >> fillAANT_SecondaryVertices : filling vertex vars");
 
      static const SG::ConstAccessor<float> massAcc("mass");
      static const SG::ConstAccessor<float> mass_eAcc("mass_e");
      static const SG::ConstAccessor<float> pTAcc("pT");
      static const SG::ConstAccessor<float> pzAcc("pz");
      static const SG::ConstAccessor<float> vtx_chargeAcc("vtx_charge");
      static const SG::ConstAccessor<float> sumBLayHitsAcc("sumBLayHits");
      static const SG::ConstAccessor<float> allTrksBLayHitsAcc("allTrksBLayHits");
      static const SG::ConstAccessor<float> minOpAngAcc("minOpAng");
 
      m_ntupleVars->get< vector<int>    >( "SecVtx_NumTrks" )         .emplace_back( vertex->nTrackParticles()   );
      m_ntupleVars->get< vector<double> >( "SecVtx_Chi2" )            .emplace_back( vertex->chiSquared()   );
      m_ntupleVars->get< vector<double> >( "SecVtxX" )                .emplace_back( vertex->x()     );
      m_ntupleVars->get< vector<double> >( "SecVtxY" )                .emplace_back( vertex->y()     );
      m_ntupleVars->get< vector<double> >( "SecVtxZ" )                .emplace_back( vertex->z()     );
      m_ntupleVars->get< vector<double> >( "SecVtx_Mass" )            .emplace_back( massAcc.withDefault(*vertex, AlgConsts::invalidFloat) );
      m_ntupleVars->get< vector<double> >( "SecVtx_Mass_electron" )   .emplace_back( mass_eAcc.withDefault(*vertex, AlgConsts::invalidFloat) );
      m_ntupleVars->get< vector<double> >( "SecVtx_pT" )              .emplace_back( pTAcc.withDefault(*vertex, AlgConsts::invalidFloat) );
      m_ntupleVars->get< vector<double> >( "SecVtx_pZ" )              .emplace_back( pzAcc.withDefault(*vertex, AlgConsts::invalidFloat) );
      m_ntupleVars->get< vector<int> >( "SecVtx_Charge" )             .emplace_back( vtx_chargeAcc.withDefault(*vertex, AlgConsts::invalidFloat) );
      m_ntupleVars->get< vector<int>    >( "SecVtx_SumBLayHits" )     .emplace_back( sumBLayHitsAcc.withDefault(*vertex, AlgConsts::invalidFloat) );
      m_ntupleVars->get< vector<int>    >( "SecVtx_AllTrksBLayHits" ) .emplace_back( allTrksBLayHitsAcc.withDefault(*vertex, AlgConsts::invalidFloat) );
      m_ntupleVars->get< vector<double> >( "SecVtx_MinOpAng" )        .emplace_back( minOpAngAcc.withDefault(*vertex, AlgConsts::invalidFloat) );
      
      
    } // loop over vertices
    
    return StatusCode::SUCCESS;
  }

fillAANT_SelectedBaseTracks()

StatusCode VKalVrtAthena::VrtSecInclusive::fillAANT_SelectedBaseTracks ( )

private

Definition at line 263 of file AANT_Tools.cxx.

                                                          {
    
    for ( const xAOD::TrackParticle* trk : m_selectedTracks ) {
      
      if( m_FillNtuple ) {
        uint8_t tmpT;
        if( !(trk->summaryValue(tmpT,xAOD::numberOfPixelHits)) )  tmpT=0;
        m_ntupleVars->get< vector<int> >( "SVTrk_PixHits" ).emplace_back( (int) tmpT);
        
        if( !(trk->summaryValue(tmpT,xAOD::numberOfSCTHits)) )  tmpT=0;
        m_ntupleVars->get< vector<int> >( "SVTrk_SCTHits" ).emplace_back( (int) tmpT);
        
        if( !(trk->summaryValue(tmpT,xAOD::numberOfTRTHits)) )  tmpT=0;
        m_ntupleVars->get< vector<int> >( "SVTrk_TRTHits" ).emplace_back( (int) tmpT);
        
        if( !(trk->summaryValue(tmpT,xAOD::numberOfInnermostPixelLayerHits)) )  tmpT=0;
        m_ntupleVars->get< vector<int> >( "SVTrk_BLayHits" ).emplace_back( (int) tmpT);
      }
      
      
      //
      // get perigee params
      //
      const auto& perigee = trk->perigeeParameters();
      
      if( m_FillNtuple ) {
      
        double phi       = perigee.parameters()[Trk::phi];
        double theta     = perigee.parameters()[Trk::theta];
        double d0        = perigee.parameters()[Trk::d0];
        double qOverP    = perigee.parameters()[Trk::qOverP];
        double errqOverP = (*(perigee.covariance()))(Trk::qOverP,Trk::qOverP);
        double errd0     = (*(perigee.covariance()))(Trk::d0,Trk::d0);
        double ptrk      = (1./qOverP);
        double pT        = ptrk*sin(theta);
        double trketa    = -1.*log( tan(theta/2) );
      
        // here we have to look at the original recotrack id to establish cross-link
        // between "SVTrk" vars and "RecoTrk" vars:
        static const SG::ConstAccessor<unsigned long> trk_idAcc("trk_id");
        m_ntupleVars->get< vector<int> >( "SVTrk_id" )      .emplace_back( trk_idAcc(*trk) );
      
        m_ntupleVars->get< vector<double> >( "SVTrk_pT" )   .emplace_back(pT);
        m_ntupleVars->get< vector<double> >( "SVTrk_p" )    .emplace_back(ptrk);
        m_ntupleVars->get< vector<double> >( "SVTrk_phi" )  .emplace_back(phi);
        m_ntupleVars->get< vector<double> >( "SVTrk_eta" )  .emplace_back(trketa);
        m_ntupleVars->get< vector<double> >( "SVTrk_2dIP" ) .emplace_back(d0);
        m_ntupleVars->get< vector<double> >( "SVTrk_ZIP" )  .emplace_back(perigee.parameters()[Trk::z0]);
      
        double matchProb = -1;
        int uniqueID = HepMC::UNDEFINED_ID;
        if(m_doTruth) 
          {  
            const xAOD::TruthParticle* aTemp_truth = getTrkGenParticle( trk );
            if( aTemp_truth )
              {
                uniqueID = HepMC::uniqueID(aTemp_truth);
                static const SG::ConstAccessor<float> truthMatchProbabilityAcc( "truthMatchProbability" ); 
                matchProb= truthMatchProbabilityAcc( *trk );
              }
          }
      
        m_ntupleVars->get< vector<int>    >( "SVTrk_barcode" ) .emplace_back( uniqueID );
        m_ntupleVars->get< vector<double> >( "SVTrk_matchPr" ) .emplace_back( matchProb );
      
        ATH_MSG_DEBUG(" > fillAANT_SelectedBaseTracks: Sel Trk d0/pT/eta/match bc/pr "
                      << d0      << ","
                      << pT      << ","
                      << trketa  << ","
                      << uniqueID << ","
                      << matchProb );
      
        double errp = ptrk*ptrk*errqOverP;
      
        m_ntupleVars->get< vector<double> >( "SVTrk_delp" )    .emplace_back( errp );
        m_ntupleVars->get< vector<double> >( "SVTrk_del2dIP" ) .emplace_back( errd0 );
        m_ntupleVars->get< vector<double> >( "SVTrk_delzIP" )  .emplace_back( (*(perigee.covariance()))(Trk::z0,Trk::z0) );
      
      }
      
      
    } // end of selected tracks
    
    return StatusCode::SUCCESS;
  }

fillTrackSummary()

void VKalVrtAthena::VrtSecInclusive::fillTrackSummary ( track_summary & summary, const xAOD::TrackParticle * trk )

staticprivate

retrieve the track hit information

Definition at line 954 of file Reconstruction/VKalVrt/VrtSecInclusive/src/Utilities.cxx.

                                                                                               {
    summary.numIBLHits    = 0;
    summary.numBLayerHits = 0;
    summary.numPixelHits  = 0;
    summary.numSctHits    = 0;
    summary.numTrtHits    = 0;
 
    trk->summaryValue( summary.numIBLHits,    xAOD::numberOfInnermostPixelLayerHits );
    trk->summaryValue( summary.numBLayerHits, xAOD::numberOfNextToInnermostPixelLayerHits );
    trk->summaryValue( summary.numPixelHits,  xAOD::numberOfPixelHits );
    trk->summaryValue( summary.numSctHits,    xAOD::numberOfSCTHits );
    trk->summaryValue( summary.numTrtHits,    xAOD::numberOfTRTHits );
  }

findMinVerticesNextPair()

double VKalVrtAthena::VrtSecInclusive::findMinVerticesNextPair ( std::vector< WrkVrt > * workVerticesContainer, std::pair< unsigned, unsigned > & indexPair )

staticprivate

returns the next pair of vertices that give next-to-minimum distance significance

Definition at line 414 of file Reconstruction/VKalVrt/VrtSecInclusive/src/Utilities.cxx.

  {
    //
    // Give minimal distance between nonmodifed yet vertices
    //
 
    indexPair.first = 0;
    indexPair.second = 0;
 
    double minValue = AlgConsts::maxValue;
 
    for(unsigned iv=0; iv<workVerticesContainer->size()-1; iv++) {
      auto& vertex = workVerticesContainer->at(iv);
 
      if( vertex.selectedTrackIndices.size() < 2) continue;   /* Bad vertex */
      if( vertex.closestWrkVrtIndex == 0 )        continue;   /* Used vertex */
 
      if( vertex.closestWrkVrtValue < minValue ) {
 
        unsigned jv = vertex.closestWrkVrtIndex;
 
        // Close vertex to given [iv] one is modified already
        if( workVerticesContainer->at(jv).closestWrkVrtIndex == 0 ) continue;
 
        minValue = vertex.closestWrkVrtValue;
 
        indexPair.first  = iv;
        indexPair.second = jv;
 
      }
    }
 
    return minValue;
  }

findMinVerticesPair()

double VKalVrtAthena::VrtSecInclusive::findMinVerticesPair ( std::vector< WrkVrt > * workVerticesContainer, std::pair< unsigned, unsigned > & indexPair, const AlgForVerticesPair & algorithm )

private

returns the pair of vertices that give minimum in terms of some observable (e.g.

distance, significance)

Definition at line 374 of file Reconstruction/VKalVrt/VrtSecInclusive/src/Utilities.cxx.

  {
    //
    //  Minimal normalized vertex-vertex distance
    //
 
    for( auto& workVertex : *workVerticesContainer ) {
      workVertex.closestWrkVrtValue = AlgConsts::maxValue;
      workVertex.closestWrkVrtIndex = 0;
    }
 
    double minValue = AlgConsts::maxValue;
 
    for( auto iv = workVerticesContainer->begin(); iv != workVerticesContainer->end(); ++iv ) {
      if( (*iv).selectedTrackIndices.size()< 2) continue;   /* Bad vertices */
 
      auto i_index = iv - workVerticesContainer->begin();
 
      for( auto jv = std::next(iv); jv != workVerticesContainer->end(); ++jv ) {
        if( (*jv).selectedTrackIndices.size()< 2) continue;   /* Bad vertices */
 
        auto j_index = iv - workVerticesContainer->begin();
 
        double value = (this->*algorithm)( (*iv), (*jv) );
 
        if( value < minValue ){
          minValue = value;
          indexPair.first  = i_index;
          indexPair.second = j_index;
        }
        if( value < (*iv).closestWrkVrtValue ) {(*iv).closestWrkVrtValue = value; (*iv).closestWrkVrtIndex = j_index; }
        if( value < (*jv).closestWrkVrtValue ) {(*jv).closestWrkVrtValue = value; (*jv).closestWrkVrtIndex = i_index; }
      }
    }
 
    return minValue;
  }

findNtrackVertices()

StatusCode VKalVrtAthena::VrtSecInclusive::findNtrackVertices ( const EventContext & ctx, std::vector< WrkVrt > * workVerticesContainer )

private

Definition at line 395 of file VertexingAlgs.cxx.

  {
    ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": begin");
    if(m_doDisappearingTrackVertexing){
      ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": skip");
      return StatusCode::SUCCESS;
    }
 
 
    const auto compSize = m_selectedTracks.size()*(m_selectedTracks.size() - 1)/2 - m_incomp.size();
    if( m_FillHist ) { m_hists["2trkVerticesDist"]->Fill( compSize ); }
 
    ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": compatible track pair size   = " << compSize );
    ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": incompatible track pair size = " << m_incomp.size() );
 
 
    if( not m_doFastMode ) {
 
      ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": incompatibility graph finder mode" );
 
      // clear the container
      workVerticesContainer->clear();
 
      // Graph method: Trk::pgraphm_()
      // used in order to find compatible sub-graphs from the incompatible graph
 
      // List of edgeds between imcompatible nodes
      // This weit is the data model of imcompatible graph used in Trk::pgraphm_().
      std::vector<long int> weit;
 
      for( auto& pair : m_incomp ) {
        weit.emplace_back( pair.first  + 1 ); /* +1 is needed for PGRAPH due to FORTRAN-style counting */
        weit.emplace_back( pair.second + 1 ); /* +1 is needed for PGRAPH due to FORTRAN-style counting */
      }
 
      // Solution of the graph method routine (minimal covering of the graph)
      // The size of the solution is returned by NPTR (see below)
      std::vector<long int> solution( m_selectedTracks.size() );
 
      // Number of edges in the list is the size of incompatibility track pairs.
      long int nEdges = m_incomp.size();
 
      // input number of nodes in the graph.
      long int nTracks = static_cast<long int>( m_selectedTracks.size() );
 
      // Input variable; the threshold. Solutions shorter than nth are not returned (ignored).
      long int nth = 2;    //VK some speed up
 
      // NPTR: I/O variable (Destructive FORTRAN Style!!!)
      // - on input:   =0 for initialization, >0 to get next solution
      // - on output:  >0 : length of the solution stored in set; =0 : no more solutions can be found
      long int solutionSize { 0 };
 
      // This is just a unused strawman needed for m_fitSvc->VKalVrtFit()
      std::vector<const xAOD::TrackParticle*>    baseTracks;
      std::vector<const xAOD::NeutralParticle*>  dummyNeutrals;
 
      std::unique_ptr<Trk::IVKalState> state = m_fitSvc->makeState();
      auto pgraph = std::make_unique<Trk::PGraph>();
      int iterationLimit(2000);
      // Main iteration
      while(true) {
 
        // Find a solution from the given set of incompatible tracks (==weit)
        pgraph->pgraphm_( weit.data(), nEdges, nTracks, solution.data(), &solutionSize, nth);
 
        ATH_MSG_VERBOSE(" > " << __FUNCTION__ << ": Trk::pgraphm_() output: solutionSize = " << solutionSize );
        if (0 == iterationLimit--){
          ATH_MSG_WARNING("Iteration limit (2000) reached in VrtSecInclusive::findNtrackVertices, solution size = "<<solutionSize);
          break;
        }
        if(solutionSize <= 0)  break;      // No more solutions ==> Exit
        if(solutionSize == 1)  continue;   // i.e. single node  ==> Not a good solution
 
        baseTracks.clear();
 
        std::string msg = "solution = [ ";
        for( int i=0; i< solutionSize; i++) {
          msg += Form( "%ld, ", solution[i]-1 );
        }
        msg += " ]";
        ATH_MSG_DEBUG( " > " << __FUNCTION__ << ": " << msg );
 
        // varaible of new vertex
        WrkVrt wrkvrt;
 
        // Try to compose a new vertex using the solution nodes
        // Here the track ID is labelled with array
        wrkvrt.isGood = true;
        wrkvrt.selectedTrackIndices.clear();
 
        for(long int i = 0; i<solutionSize; i++) {
          wrkvrt.selectedTrackIndices.emplace_back(solution[i]-1);
          baseTracks.emplace_back( m_selectedTracks.at(solution[i]-1) );
        }
 
        // Perform vertex fitting
        Amg::Vector3D initVertex;
 
        StatusCode sc = m_fitSvc->VKalVrtFitFast( baseTracks, initVertex, *state );/* Fast crude estimation */
        if(sc.isFailure()) ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": fast crude estimation fails ");
 
        m_fitSvc->setApproximateVertex( initVertex.x(), initVertex.y(), initVertex.z(), *state );
 
        sc = m_fitSvc->VKalVrtFit(baseTracks, dummyNeutrals,
                                  wrkvrt.vertex,
                                  wrkvrt.vertexMom,
                                  wrkvrt.Charge,
                                  wrkvrt.vertexCov,
                                  wrkvrt.Chi2PerTrk,
                                  wrkvrt.TrkAtVrt,
                                  wrkvrt.Chi2,
                                  *state);
 
        ATH_MSG_VERBOSE(" > " << __FUNCTION__ << ": FoundAppVrt=" << solutionSize << ", (r, z) = " << wrkvrt.vertex.perp() << ", " << wrkvrt.vertex.z()  <<  ", chi2/ndof = "  <<  wrkvrt.fitQuality() );
 
        if( sc.isFailure() )  {
 
          if( wrkvrt.selectedTrackIndices.size() <= 2 ) {
            ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": VKalVrtFit failed in 2-trk solution ==> give up.");
            continue;
          }
 
          ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": VKalVrtFit failed ==> retry...");
 
          WrkVrt tmp;
          tmp.isGood = false;
 
          // Create 2-trk vertex combination and find any compatible vertex
          for( auto& itrk: wrkvrt.selectedTrackIndices ) {
            for( auto& jtrk: wrkvrt.selectedTrackIndices ) {
              if( itrk == jtrk ) continue;
              if( tmp.isGood ) continue;
 
              tmp.selectedTrackIndices.clear();
              tmp.selectedTrackIndices.emplace_back( itrk );
              tmp.selectedTrackIndices.emplace_back( jtrk );
 
              baseTracks.clear();
              baseTracks.emplace_back( m_selectedTracks.at( itrk ) );
              baseTracks.emplace_back( m_selectedTracks.at( jtrk ) );
 
              // Perform vertex fitting
              Amg::Vector3D initVertex;
 
              sc = m_fitSvc->VKalVrtFitFast( baseTracks, initVertex, *state );
              if( sc.isFailure() ) ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": fast crude estimation fails ");
 
              m_fitSvc->setApproximateVertex( initVertex.x(), initVertex.y(), initVertex.z(), *state );
 
              sc = m_fitSvc->VKalVrtFit(baseTracks, dummyNeutrals,
                                        tmp.vertex,
                                        tmp.vertexMom,
                                        tmp.Charge,
                                        tmp.vertexCov,
                                        tmp.Chi2PerTrk,
                                        tmp.TrkAtVrt,
                                        tmp.Chi2,
                                        *state);
 
              if( sc.isFailure() ) continue;
 
              tmp.isGood = true;
 
            }
          }
 
          if( !tmp.isGood ) {
            ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": Did not find any viable vertex in all 2-trk combinations. Give up.");
            continue;
          }
 
          // Now, found at least one seed 2-track vertex. ==> attempt to attach other tracks
          for( auto& itrk: wrkvrt.selectedTrackIndices ) {
 
            if( std::find( tmp.selectedTrackIndices.begin(), tmp.selectedTrackIndices.end(), itrk ) != tmp.selectedTrackIndices.end() ) continue;
 
            auto backup = tmp;
 
            tmp.selectedTrackIndices.emplace_back( itrk );
            baseTracks.clear();
            for( auto& jtrk : tmp.selectedTrackIndices ) { baseTracks.emplace_back( m_selectedTracks.at(jtrk) ); }
 
            // Perform vertex fitting
            Amg::Vector3D initVertex;
 
            sc = m_fitSvc->VKalVrtFitFast( baseTracks, initVertex, *state );/* Fast crude estimation */
            if(sc.isFailure()) ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": fast crude estimation fails ");
 
            m_fitSvc->setApproximateVertex( initVertex.x(), initVertex.y(), initVertex.z(), *state );
 
            sc = m_fitSvc->VKalVrtFit(baseTracks, dummyNeutrals,
                                      tmp.vertex,
                                      tmp.vertexMom,
                                      tmp.Charge,
                                      tmp.vertexCov,
                                      tmp.Chi2PerTrk,
                                      tmp.TrkAtVrt,
                                      tmp.Chi2,
                                      *state);
 
            if( sc.isFailure() ) {
              tmp = backup;
              continue;
            }
 
          }
 
          wrkvrt = tmp;
          ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": VKalVrtFit succeeded; register the vertex to the list.");
          wrkvrt.isGood                = true;
          wrkvrt.closestWrkVrtIndex    = AlgConsts::invalidUnsigned;
          wrkvrt.closestWrkVrtValue    = AlgConsts::maxValue;
          workVerticesContainer->emplace_back( wrkvrt );
 
        } else {
 
          ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": VKalVrtFit succeeded; register the vertex to the list.");
          wrkvrt.isGood                = true;
          wrkvrt.closestWrkVrtIndex    = AlgConsts::invalidUnsigned;
          wrkvrt.closestWrkVrtValue    = AlgConsts::maxValue;
          workVerticesContainer->emplace_back( wrkvrt );
 
        }
 
      }
 
 
    } else {
 
      ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": rapid finder mode" );
 
      struct Cluster {
        Amg::Vector3D position;
        std::set<long int> tracks;
      };
 
      std::vector<struct Cluster> clusters;
 
      for( auto& wrkvrt : *workVerticesContainer ) {
 
        bool foundCluster = false;
 
        for( auto& cluster: clusters ) {
          if( (wrkvrt.vertex - cluster.position).norm() < 1.0 ) {
            for( auto& itrk : wrkvrt.selectedTrackIndices ) {
              cluster.tracks.insert( itrk );
            }
            foundCluster = true;
            break;
          }
        }
 
        if( !foundCluster ) {
          Cluster c;
          c.position = wrkvrt.vertex;
          for( auto& itrk : wrkvrt.selectedTrackIndices ) {
            c.tracks.insert( itrk );
          }
          clusters.emplace_back( c );
          ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": added a new cluster" );
        }
 
      }
 
      // This is just a unused strawman needed for m_fitSvc->VKalVrtFit()
      std::vector<const xAOD::TrackParticle*>    baseTracks;
      std::vector<const xAOD::NeutralParticle*>  dummyNeutrals;
 
      workVerticesContainer->clear();
 
      ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": found cluster size =" << clusters.size() );
 
      std::unique_ptr<Trk::IVKalState> state = m_fitSvc->makeState();
      for( auto& cluster : clusters ) {
 
        // varaible of new vertex
        WrkVrt wrkvrt;
 
        // Try to compose a new vertex using the solution nodes
        // Here the track ID is labelled with array
        wrkvrt.isGood = true;
        wrkvrt.selectedTrackIndices.clear();
 
        for(const auto& index: cluster.tracks) {
          wrkvrt.selectedTrackIndices.emplace_back( index );
          baseTracks.emplace_back( m_selectedTracks.at( index ) );
        }
 
        // Perform vertex fitting
        Amg::Vector3D initVertex;
 
        StatusCode sc = m_fitSvc->VKalVrtFitFast( baseTracks, initVertex, *state );/* Fast crude estimation */
        if(sc.isFailure()) ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": fast crude estimation fails ");
 
        m_fitSvc->setApproximateVertex( initVertex.x(), initVertex.y(), initVertex.z(), *state );
 
        sc = m_fitSvc->VKalVrtFit(baseTracks, dummyNeutrals,
                                  wrkvrt.vertex,
                                  wrkvrt.vertexMom,
                                  wrkvrt.Charge,
                                  wrkvrt.vertexCov,
                                  wrkvrt.Chi2PerTrk,
                                  wrkvrt.TrkAtVrt,
                                  wrkvrt.Chi2,
                                  *state);
 
        if( sc.isFailure() ) {
          continue;
        }
 
        workVerticesContainer->emplace_back( wrkvrt );
      }
 
    }
 
    if (m_truncateWrkVertices){
      if (workVerticesContainer->size() > m_maxWrkVertices){
        m_vertexingStatus = 3;
        workVerticesContainer->resize(m_maxWrkVertices);
      }
    }
 
    //-------------------------------------------------------
    // Iterative cleanup algorithm
 
    //-Remove vertices fully contained in other vertices
    ATH_MSG_VERBOSE(" > " << __FUNCTION__ << ": Remove vertices fully contained in other vertices .");
    while( workVerticesContainer->size() > 1 ) {
      size_t tmpN = workVerticesContainer->size();
 
      size_t iv = 0;
      for(; iv<tmpN-1; iv++) {
        size_t jv = iv+1;
        for(; jv<tmpN; jv++) {
          const auto nTCom = nTrkCommon( workVerticesContainer, {iv, jv} );
 
          if(      nTCom == workVerticesContainer->at(iv).selectedTrackIndices.size() ) {  workVerticesContainer->erase(workVerticesContainer->begin()+iv); break; }
          else if( nTCom == workVerticesContainer->at(jv).selectedTrackIndices.size() ) {  workVerticesContainer->erase(workVerticesContainer->begin()+jv); break; }
 
        }
        if(jv!=tmpN)   break;  // One vertex is erased. Restart check
      }
      if(iv==tmpN-1) break;  // No vertex deleted
    }
 
    //-Identify remaining 2-track vertices with very bad Chi2 and mass (b-tagging)
    ATH_MSG_VERBOSE(" > " << __FUNCTION__ << ": Identify remaining 2-track vertices with very bad Chi2 and mass (b-tagging).");
    for( auto& wrkvrt : *workVerticesContainer ) {
 
      if( TMath::Prob( wrkvrt.Chi2, wrkvrt.ndof() ) < m_improveChi2ProbThreshold ) wrkvrt.isGood = false;
      if( wrkvrt.selectedTrackIndices.size() != 2 ) continue;
      if( m_FillHist ) m_hists["NtrkChi2Dist"]->Fill( log10( wrkvrt.fitQuality() ) );
    }
 
    if( m_FillNtuple) m_ntupleVars->get<unsigned int>( "NumInitSecVrt" ) = workVerticesContainer->size();
 
    return StatusCode::SUCCESS;
  }

findWorstChi2ofMaximallySharedTrack()

double VKalVrtAthena::VrtSecInclusive::findWorstChi2ofMaximallySharedTrack ( std::vector< WrkVrt > * workVerticesContainer, std::map< long int, std::vector< long int > > & trackToVertexMap, long int & maxSharedTrack, long int & worstMatchingVertex )

private

Definition at line 807 of file Reconstruction/VKalVrt/VrtSecInclusive/src/Utilities.cxx.

  {
 
    double worstChi2 = AlgConsts::invalidFloat;
 
    // Find the track index that has the largest shared vertices
    auto maxSharedTrackToVertices = std::max_element( trackToVertexMap.begin(), trackToVertexMap.end(), []( auto& p1, auto& p2 ) { return p1.second.size() < p2.second.size(); } );
 
    if( maxSharedTrackToVertices == trackToVertexMap.end() ) return worstChi2;
 
    ATH_MSG_VERBOSE( " > " << __FUNCTION__ << ": max-shared track index = " << maxSharedTrackToVertices->first << ", number of shared vertices = " << maxSharedTrackToVertices->second.size() );
 
    if( maxSharedTrackToVertices->second.size() < 2 ) return worstChi2;
 
    // map of vertex index and the chi2 of the track for the maxSharedTrack
    std::map<long int, double> vrtChi2Map;
 
    // loop over vertices for the largest shared track
    for( auto& iv : maxSharedTrackToVertices->second ) {
      ATH_MSG_VERBOSE( " > " << __FUNCTION__ << ": loop over vertices: vertex index " << iv );
 
      auto& wrkvrt = workVerticesContainer->at( iv );
      auto& trackIndices = wrkvrt.selectedTrackIndices;
 
      // find the index of the track
      auto index = std::find_if( trackIndices.begin(), trackIndices.end(), [&]( auto& index ) { return index == maxSharedTrackToVertices->first; } );
      if( index == trackIndices.end() ) {
        ATH_MSG_WARNING(" >> " << __FUNCTION__ << ": index not found (algorithm inconsistent)" );
        return worstChi2;
      }
 
      auto& chi2 = wrkvrt.Chi2PerTrk.at( index - trackIndices.begin() );
 
      vrtChi2Map.emplace( std::pair<long int, double>(iv, chi2) );
    }
 
    auto worstVrtChi2Pair = std::max_element( vrtChi2Map.begin(), vrtChi2Map.end(), []( auto& p1, auto& p2 ) { return p1.second < p2.second; } );
 
    if( worstVrtChi2Pair == vrtChi2Map.end() ) {
      ATH_MSG_WARNING(" >> " << __FUNCTION__ << ": max_element of vrtChi2Map not found" );
      return worstChi2;
    }
 
    maxSharedTrack      = maxSharedTrackToVertices->first;
    worstMatchingVertex = worstVrtChi2Pair->first;
    worstChi2           = worstVrtChi2Pair->second;
 
    return worstChi2;
  }

getIntersection() [1/2]

template<class Track>

void VKalVrtAthena::VrtSecInclusive::getIntersection ( Track * trk, std::vector< IntersectionPos * > & layers, const Trk::Perigee * per )

private

getIntersection() [2/2]

template<class TrackT>

void VKalVrtAthena::VrtSecInclusive::getIntersection	(	TrackT *	trk,
		vector< IntersectionPos * > &	layers,
		const Trk::Perigee *	per )

Definition at line 18 of file Reconstruction/VKalVrt/VrtSecInclusive/VrtSecInclusive/details/Utilities.h.

                                                                                                                                    {
    //
    // get intersection point of track with various surfaces
    //
 
    //--------------------
    // main loop
    for( auto *layer : layers ) {
 
      ATH_MSG_VERBOSE( " >> getIntersection(): attempt to loop " << layer->name() );
      setIntersection( trk, layer, per );
 
    }
 
 
    ATH_MSG_VERBOSE( " >> getIntersection(): End of getIntersection" );
  }

getSVImpactParameters()

bool VKalVrtAthena::VrtSecInclusive::getSVImpactParameters ( const xAOD::TrackParticle * trk, const Amg::Vector3D & vertex, std::vector< double > & impactParameters, std::vector< double > & impactParErrors )

private

get secondary vertex impact parameters

Definition at line 2324 of file VertexingAlgs.cxx.

                                                                                 {
 
    impactParameters.clear();
    impactParErrors.clear();
 
    if( m_trkExtrapolator==1 ){
      m_fitSvc->VKalGetImpact(trk, vertex, static_cast<int>( trk->charge() ), impactParameters, impactParErrors);
    }
    else if( m_trkExtrapolator==2 ){
      auto sv_perigee = m_trackToVertexTool->perigeeAtVertex(Gaudi::Hive::currentContext(), *trk, vertex );
      if( !sv_perigee ) return false;
      impactParameters.push_back(sv_perigee->parameters() [Trk::d0]);
      impactParameters.push_back(sv_perigee->parameters() [Trk::z0]);
      impactParErrors.push_back((*sv_perigee->covariance())( Trk::d0, Trk::d0 ));
      impactParErrors.push_back((*sv_perigee->covariance())( Trk::z0, Trk::z0 ));
    }
    else{
      ATH_MSG_WARNING( " > " << __FUNCTION__ << ": Unknown track extrapolator " << m_trkExtrapolator   );
      return false;
    }
 
    return true;
 
  } // getSVImpactParameters

getTrkGenParticle()

const xAOD::TruthParticle * VKalVrtAthena::VrtSecInclusive::getTrkGenParticle ( const xAOD::TrackParticle * trkPart )

staticprivate

Definition at line 26 of file TruthAlgs.cxx.

  {
    typedef ElementLink< xAOD::TruthParticleContainer > Link_t;
    constexpr const char* NAME = "truthParticleLink";
    static const SG::ConstAccessor< Link_t > acc (NAME);
    if(  ! acc.isAvailable( *trkPart ) ) {
      return nullptr;
    }
    const Link_t& link = acc( *trkPart );
    if(  ! link.isValid() ) {
      return nullptr;
    }
    return *link;
  }

improveVertexChi2()

double VKalVrtAthena::VrtSecInclusive::improveVertexChi2 ( WrkVrt & vertex )

private

attempt to improve the vertex chi2 by removing the most-outlier track one by one until the vertex chi2 satisfies a certain condition.

Definition at line 265 of file Reconstruction/VKalVrt/VrtSecInclusive/src/Utilities.cxx.

  {
    //
    //  Iterate track removal until vertex get good Chi2
    //
 
    auto fitQuality_begin = vertex.fitQuality();
 
    auto removeCounter = 0;
 
    if( vertex.nTracksTotal() <= 2 ) return 0.;
 
    {
      WrkVrt backup = vertex;
      StatusCode sc = refitVertexWithSuggestion( vertex, vertex.vertex );
      if( sc.isFailure() ) {
        vertex = backup;
        return 0;
      }
    }
 
    double chi2Probability = TMath::Prob( vertex.Chi2, vertex.ndof() );
 
    while (chi2Probability < m_improveChi2ProbThreshold ) {
      if( vertex.nTracksTotal() == 2 ) return chi2Probability;
 
      WrkVrt vertex_backup = vertex;
 
      auto maxChi2 = std::max_element( vertex.Chi2PerTrk.begin(), vertex.Chi2PerTrk.end() );
      size_t index   = maxChi2 - vertex.Chi2PerTrk.begin();
 
 
      ATH_MSG_DEBUG( " >>> " << __FUNCTION__ << ": worst chi2 trk index = " << index << ", #trks = " << vertex.Chi2PerTrk.size() );
 
      if( index < vertex.selectedTrackIndices.size() ) {
        vertex.selectedTrackIndices.erase( vertex.selectedTrackIndices.begin() + index ); //remove track
        removeCounter++;
      } else {
        index -= vertex.selectedTrackIndices.size();
        if( index >= vertex.associatedTrackIndices.size() ) {
          ATH_MSG_WARNING( " >>> " << __FUNCTION__ << ": invalid index" );
          break;
        }
        vertex.associatedTrackIndices.erase( vertex.associatedTrackIndices.begin() + index ); //remove track
        removeCounter++;
      }
 
      StatusCode sc = refitVertexWithSuggestion( vertex, vertex.vertex );
 
      if( sc.isFailure() || vertex_backup.fitQuality() < vertex.fitQuality() ) {
        vertex = vertex_backup;
        chi2Probability = 0;
        break;
      }
 
      chi2Probability = TMath::Prob( vertex.Chi2, vertex.ndof() );
    }
 
    auto fitQuality_end = vertex.fitQuality();
 
    if( 0 == removeCounter ) {
      ATH_MSG_DEBUG( " >>> " << __FUNCTION__ << ": no improvement was found." );
    } else {
      ATH_MSG_DEBUG( " >>> " << __FUNCTION__ << ": Removed " << removeCounter << " tracks; Fit quality improvement: " << fitQuality_begin << " ==> " << fitQuality_end );
    }
 
    return chi2Probability;
  }

initEvent()

StatusCode VKalVrtAthena::VrtSecInclusive::initEvent ( )

virtual

Definition at line 296 of file VrtSecInclusive.cxx.

  {
 
    ATH_MSG_DEBUG("initEvent: begin");
 
    // Clear all variables to be stored to the AANT
    if( m_FillNtuple ) {
      ATH_CHECK( clearNtupleVariables() );
    }
 
 
    ATH_MSG_DEBUG("initEvent: from initEvent ");
    return StatusCode::SUCCESS;
 
  }

initialize()

StatusCode VKalVrtAthena::VrtSecInclusive::initialize ( )

overridevirtual

Definition at line 60 of file VrtSecInclusive.cxx.

  {
    ATH_MSG_INFO("initialize: begin");
    //
    // first instantiate tools
 
    //  VKalVrt vertex fitter
    if (m_fitSvc.retrieve().isFailure()) {
      ATH_MSG_ERROR("initialize: Can't find Trk::TrkVKalVrtFitter");
      return StatusCode::SUCCESS;
    } else {
      ATH_MSG_INFO("initialize: Trk::TrkVKalVrtFitter found");
    }
 
    //
    // retreive tool to get trackParameters of generated Particles
    if(m_truthToTrack.retrieve().isFailure()) {
      ATH_MSG_INFO("initialize: Cannot retrieve Trk::TruthToTrack Tool!");
      return StatusCode::FAILURE;
    }
    else {
      ATH_MSG_INFO("initialize: Retrieved Trk::TruthToTrack Tool" << m_truthToTrack);
 
    }
    // extract TrackToVertex extrapolator tool
    if ( m_trackToVertexTool.retrieve().isFailure() ) {
      ATH_MSG_ERROR("initialize: failed to retrieve trackToVertex tool ");
      return StatusCode::SUCCESS;
    }
    else {
      ATH_MSG_INFO("initialize: Retrieved Reco::TrackToVertex Tool" << m_trackToVertexTool);
    }
    // extract TrackToVertexIPEstimator extrapolator tool
    if ( m_trackToVertexIPEstimatorTool.retrieve().isFailure() ) {
      ATH_MSG_ERROR("initialize: failed to retrieve trackToVertexIPEstimator tool ");
      return StatusCode::SUCCESS;
    }
    else {
      ATH_MSG_INFO("initialize: Retrieved Trk::TrackToVertexIPEstimator Tool" << m_trackToVertexIPEstimatorTool);
    }
 
    if( detStore()->retrieve(m_atlasId, "AtlasID").isFailure() ) return StatusCode::FAILURE;
    if( detStore()->retrieve(m_pixelId, "PixelID").isFailure() ) return StatusCode::FAILURE;
    if( detStore()->retrieve(m_sctId,   "SCT_ID") .isFailure() ) return StatusCode::FAILURE;
 
    if ( m_pixelCondSummaryTool.retrieve().isFailure() ) {
      ATH_MSG_ERROR("initialize: failed to retrieve PixelConditionsSummaryTool");
      return StatusCode::SUCCESS;
    }
    else {
      ATH_MSG_INFO("initialize: Retrieved PixelConditionsSummaryTool" << m_pixelCondSummaryTool);
    }
    if ( m_sctCondSummaryTool.retrieve().isFailure() ) {
      ATH_MSG_ERROR("initialize: failed to retrieve SCTConditionsSummaryTool");
      return StatusCode::SUCCESS;
    }
    else {
      ATH_MSG_INFO("initialize: Retrieved SCTConditionsSummaryTool" << m_sctCondSummaryTool);
    }
 
    ATH_CHECK( m_extrapolator.retrieve() );
 
    // extract VertexMapper
    if( m_doMapToLocal ) {
      ATH_CHECK( m_vertexMapper.retrieve() );
    }
 
    // Track selection algorithm configuration
    if( m_doSelectTracksFromMuons )     { m_trackSelectionAlgs.emplace_back( &VrtSecInclusive::selectTracksFromMuons );     }
    if( m_doSelectTracksFromElectrons ) { m_trackSelectionAlgs.emplace_back( &VrtSecInclusive::selectTracksFromElectrons ); }
    if( m_doSelectIDAndGSFTracks )      { m_trackSelectionAlgs.emplace_back( &VrtSecInclusive::selectInDetAndGSFTracks );   }
 
    // if none of the above two flags are activated, use ID tracks (default)
    if( !m_doSelectTracksFromMuons && !m_doSelectTracksFromElectrons && !m_doSelectIDAndGSFTracks) {
 
      m_trackSelectionAlgs.emplace_back( &VrtSecInclusive::selectTracksInDet );
 
    }
 
 
    // Vertexing algorithm configuration
    m_vertexingAlgorithms.emplace_back( "extractIncompatibleTrackPairs", &VrtSecInclusive::extractIncompatibleTrackPairs     );
    m_vertexingAlgorithms.emplace_back( "findNtrackVertices",            &VrtSecInclusive::findNtrackVertices                );
    m_vertexingAlgorithms.emplace_back( "rearrangeTracks",               &VrtSecInclusive::rearrangeTracks                   );
 
    if( m_doReassembleVertices ) {
      m_vertexingAlgorithms.emplace_back( "reassembleVertices",          &VrtSecInclusive::reassembleVertices                );
    }
 
    if( m_doMergeByShuffling ) {
      m_vertexingAlgorithms.emplace_back( "mergeByShuffling",           &VrtSecInclusive::mergeByShuffling                   );
    }
 
    if ( m_doMergeFinalVerticesDistance ) {
      m_vertexingAlgorithms.emplace_back( "mergeFinalVertices",          &VrtSecInclusive::mergeFinalVertices                );
    }
 
    if( m_doAssociateNonSelectedTracks ) {
      m_vertexingAlgorithms.emplace_back( "associateNonSelectedTracks",  &VrtSecInclusive::associateNonSelectedTracks        );
    }
 
    m_vertexingAlgorithms.emplace_back( "refitAndSelect",                &VrtSecInclusive::refitAndSelectGoodQualityVertices );
 
 
    // now make histograms/ntuples
 
    ServiceHandle<ITHistSvc> hist_root("THistSvc", name());
    ATH_CHECK( hist_root.retrieve() );
 
    if( m_FillHist ) {
 
      std::vector<double> rbins = { 0.1, 0.3, 0.5, 1, 2, 3, 5, 7, 10, 14, 20, 28, 38, 50, 64, 80, 100, 130, 170, 220, 280, 350, 450, 600 };
      std::vector<double> nbins = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 16, 20, 24, 28, 38, 50, 70, 100, 150 };
 
      const size_t& nAlgs = m_vertexingAlgorithms.size();
 
      ATH_MSG_INFO("initialize: Filling Histograms");
      //
      m_hists["trkSelCuts"]        = new TH1F("trkSelCuts",        ";Cut Order;Tracks",                         10, -0.5, 10-0.5                                         );
      m_hists["selTracksDist"]     = new TH1F("selTracksDist",     ";Selected Tracks;Events",                   2000, -0.5, 2000-0.5                                     );
      m_hists["initVertexDispD0"]  = new TH2F("initVertexDispD0",  ";Rough d0 wrt init [mm];r [mm];Vertices",   1000, -100, 100, rbins.size()-1, &(rbins[0])             );
      m_hists["initVertexDispZ0"]  = new TH2F("initVertexDispZ0",  ";Rough z0 wrt init [mm];z [mm];Vertices",   1000, -100, 100, 100, -1000, 1000                        );
      m_hists["incompMonitor"]     = new TH1F("incompMonitor",     ";Setp;Track Pairs",                         10, -0.5, 10-0.5                                         );
      m_hists["2trkVerticesDist"]  = new TH1F("2trkVerticesDist",  ";2-track Vertices;Events",                  1000, -0.5, 1000-0.5                                     );
      m_hists["2trkChi2Dist"]      = new TH1F("2trkChi2Dist",      ";log10(#chi^{2}/N_{dof});Entries",          100, -3, 7                                               );
      m_hists["NtrkChi2Dist"]      = new TH1F("NtrkChi2Dist",      ";log10(#chi^{2}/N_{dof});Entries",          100, -3, 7                                               );
      m_hists["vPosDist"]          = new TH2F("vPosDist",          ";r;#vec{x}*#vec{p}/p_{T} [mm]",             rbins.size()-1, &(rbins[0]), 200, -1000, 1000            );
      m_hists["vPosMomAngTDist"]   = new TH2F("vPosMomAngDistT",   ";r;cos(#vec{r},#vec{p}_{T})",               rbins.size()-1, &(rbins[0]), 200, -1.0, 1.0              );
      m_hists["disabledCount"]     = new TH1F("disabledCount",     ";N_{modules};Tracks",                       20, -0.5, 10-0.5                                         );
      m_hists["vertexYield"]       = new TH1F("vertexYield",       ";Algorithm Step;Vertices",                  nAlgs, -0.5, nAlgs-0.5                                   );
      m_hists["vertexYieldNtrk"]   = new TH2F("vertexYieldNtrk",   ";Ntrk;Algorithm Step;Vertices",             100, 0, 100, nAlgs, -0.5, nAlgs-0.5                      );
      m_hists["vertexYieldChi2"]   = new TH2F("vertexYieldChi2",   ";#chi^{2}/N_{dof};Algorithm Step;Vertices", 100, 0, 100, nAlgs, -0.5, nAlgs-0.5                      );
      m_hists["mergeType"]         = new TH1F("mergeType",         ";Merge Algorithm Type;Entries",             10, -0.5, 10-0.5                                         );
      m_hists["associateMonitor"]  = new TH1F("associateMonitor",  ";Step;Vertices",                            10, -0.5, 10-0.5                                         );
      m_hists["shuffleMinSignif1"] = new TH1F("shuffleMinSignif1", ";Min( log_{10}( Significance ) );Vertices", 100, -3, 5                                               );
      m_hists["shuffleMinSignif2"] = new TH1F("shuffleMinSignif2", ";Min( log_{10}( Significance ) );Vertices", 100, -3, 5                                               );
      m_hists["shuffleMinSignif3"] = new TH1F("shuffleMinSignif3", ";Min( log_{10}( Significance ) );Vertices", 100, -3, 5                                               );
      m_hists["finalCutMonitor"]   = new TH1F("finalCutMonitor",   ";Step;Vertices",                            6, -0.5, 6-0.5                                           );
      m_hists["finalVtxNtrk"]      = new TH1F("finalVtxNtrk",      ";N_{trk};Vertices",                         nbins.size()-1, &(nbins[0])                              );
      m_hists["finalVtxR"]         = new TH1F("finalVtxR",         ";r [mm];Vertices",                          600, 0, 600                                              );
      m_hists["finalVtxNtrkR"]     = new TH2F("finalVtxNtrkR",     ";N_{trk};r [mm];Vertices",                  nbins.size()-1, &(nbins[0]), rbins.size()-1, &(rbins[0]) );
      m_hists["CPUTime"]           = new TH1F("CPUTime",           ";Step;Accum. CPU Time [s]",                 10, -0.5, 10-0.5                                         );
      m_hists["nMatchedTruths"]    = new TH2F("nMatchedTruths",    ";Step;;r [mm];Matched truth vertices",      11, -0.5, 11-0.5, rbins.size()-1, &(rbins[0])            );
      m_hists["vPosMomAngT"]       = new TH1F("vPosMomAngT",       ";cos(#vec{r},#vec{p}_{T}",                  200, -1.0, 1.0                                           );
      m_hists["vPosMomAng3D"]      = new TH1F("vPosMomAng3D",      ";cos(#vec{r},#vec{p})",                     200, -1.0, 1.0                                           );
      m_hists["2trkVtxDistFromPV"] = new TH1F("2trkVtDistFromPV",  ";2tr vertex distance from PV;Events",       100, 0, 3                                                );
 
 
      std::string histDir("/AANT/VrtSecInclusive" + m_augVerString + "/");
 
      for( auto& pair : m_hists ) {
        ATH_CHECK( hist_root->regHist( histDir + pair.first, pair.second ) );
      }
    }
 
 
    if( m_FillNtuple ) {
 
      ATH_CHECK( setupNtupleVariables() );
 
      m_tree_Vert = new TTree("tree_VrtSecInclusive","TTree of VrtSecInclusive");
      ATH_CHECK( hist_root->regTree("/AANT/tree_VrtSecInclusive", m_tree_Vert) );
 
      ATH_CHECK( setupNtuple() );
 
    }
 
    // initialize keys
    ATH_CHECK(m_eventInfoKey.initialize());
 
    // Instantiate and initialize our event info decorator write
    m_vertexingStatusKey = "VrtSecInclusive_" + m_secondaryVerticesContainerName + m_augVerString + "_status";
    ATH_CHECK( m_vertexingStatusKey.initialize() );
    
    m_vertexKey = "VrtSecInclusive_" + m_secondaryVerticesContainerName + m_augVerString;
    m_twoTrksVertexKey = "VrtSecInclusive_" + m_all2trksVerticesContainerName + m_augVerString;
    ATH_CHECK( m_vertexKey.initialize() );
    ATH_CHECK( m_twoTrksVertexKey.initialize(m_FillIntermediateVertices) );
    m_vertexCollectionsDefinitions[m_vertexKey.key()] = false;
    if (m_FillIntermediateVertices) m_vertexCollectionsDefinitions[m_twoTrksVertexKey.key()] = false;
    
    if ( m_FillIntermediateVertices ) {
      for( auto itr = m_vertexingAlgorithms.begin(); itr!=m_vertexingAlgorithms.end(); ++itr ) {
    const std::string& nameAlgo = itr->first;
    std::string fullName = "VrtSecInclusive_IntermediateVertices_" + nameAlgo + m_augVerString;
    m_intermediateVertexKey[nameAlgo] = SG::WriteHandleKey<xAOD::VertexContainer>( this, nameAlgo, fullName );
    ATH_CHECK( m_intermediateVertexKey[nameAlgo].initialize() );
    m_vertexCollectionsDefinitions[m_intermediateVertexKey[nameAlgo].key()] = false;
      }
    }
 
    
    ATH_CHECK( m_TrackLocation.initialize() );
    ATH_CHECK( m_MuonLocation.initialize() );
    ATH_CHECK( m_ElectronLocation.initialize() );
    ATH_CHECK( m_PrimVrtLocation.initialize() );
    
    //
    ATH_MSG_INFO("initialize: Exit VrtSecInclusive::initialize()");
    return StatusCode::SUCCESS;
  }

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Algorithm > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

lockLeptonDecorations()

void VKalVrtAthena::VrtSecInclusive::lockLeptonDecorations ( const SG::AuxVectorData * cont ) const

private

Definition at line 510 of file VrtSecInclusive.cxx.

                                                                                 {
    SG::AuxVectorData* cont_nc ATLAS_THREAD_SAFE =
      const_cast<SG::AuxVectorData*> (cont);
    for (const IPDecoratorType& dec : m_ipDecors) {
      if (dec.isAvailable (*cont)) {
        cont_nc->lockDecoration (dec.auxid());
      }
    }
 
    if (m_decor_svLink) {
      if (m_decor_svLink->isAvailable (*cont)) {
        cont_nc->lockDecoration (m_decor_svLink->auxid());
      }
    }
  }

lockTrackDecorations() [1/2]

StatusCode VKalVrtAthena::VrtSecInclusive::lockTrackDecorations ( bool onlySelection, const EventContext & ctx ) const

private

Definition at line 526 of file VrtSecInclusive.cxx.

  {
    SG::ReadHandle<xAOD::TrackParticleContainer> trackParticleHandle = SG::makeHandle( m_TrackLocation, ctx );
    ATH_CHECK( trackParticleHandle.isValid() );
    const xAOD::TrackParticleContainer* trackParticleContainer = trackParticleHandle.cptr();
    for( const xAOD::TrackParticle* trk : *trackParticleContainer ) {
      lockTrackDecorations( trk, onlySelection );
    }
 
    SG::ReadHandle<xAOD::MuonContainer> muonsHandle = SG::makeHandle( m_MuonLocation, ctx );
    ATH_CHECK( muonsHandle.isValid() );
    const xAOD::MuonContainer* muons = muonsHandle.cptr();
    if (muons->ownPolicy() != SG::VIEW_ELEMENTS) {
      lockLeptonDecorations (muons);
    }
    for( const xAOD::Muon* muon : *muons ) {
      if (muons->ownPolicy() == SG::VIEW_ELEMENTS) {
        lockLeptonDecorations (muon->container());
      }
      if ( const xAOD::TrackParticle* trk = muon->trackParticle( xAOD::Muon::InnerDetectorTrackParticle ) ) {
        lockTrackDecorations( trk, onlySelection );
      }
    }
 
    SG::ReadHandle<xAOD::ElectronContainer> electronsHandle = SG::makeHandle( m_ElectronLocation, ctx);
    ATH_CHECK( electronsHandle.isValid() );
    const xAOD::ElectronContainer *electrons = electronsHandle.cptr();
    if (electrons->ownPolicy() != SG::VIEW_ELEMENTS) {
      lockLeptonDecorations (electrons);
    }
    for( const xAOD::Electron* electron : *electrons ) {
      if (electrons->ownPolicy() == SG::VIEW_ELEMENTS) {
        lockLeptonDecorations (electron->container());
      }
      if( electron->nTrackParticles() > 0 ) {
        if (const xAOD::TrackParticle* trk = electron->trackParticle(0)) {
          lockTrackDecorations( trk, onlySelection );
        }
      }
    }
 
    SG::ReadHandle<xAOD::TrackParticleContainer> IDtracksHandle = SG::makeHandle( m_TrackLocation, ctx );
    ATH_CHECK( IDtracksHandle.isValid() );
    const xAOD::TrackParticleContainer* IDtracks = IDtracksHandle.cptr();
    for( const auto *trk : *IDtracks ) {
      lockTrackDecorations( trk, onlySelection );
    }
 
    return StatusCode::SUCCESS;
  }

lockTrackDecorations() [2/2]

void VKalVrtAthena::VrtSecInclusive::lockTrackDecorations ( const xAOD::TrackParticle * trk, bool onlySelection ) const

private

lock decorations at the end of the algorithm

Definition at line 491 of file VrtSecInclusive.cxx.

                                                                                                     {
    SG::AuxVectorData* cont_nc ATLAS_THREAD_SAFE =
      const_cast<SG::AuxVectorData*> (trk->container());
    cont_nc->lockDecoration (m_decor_isSelected->auxid());
 
    if (onlySelection) return;
 
    if (m_decor_isAssociated && m_decor_isAssociated->isAvailable (*cont_nc)) {
      cont_nc->lockDecoration (m_decor_isAssociated->auxid());
    }
    if (m_decor_is_svtrk_final && m_decor_is_svtrk_final->isAvailable (*cont_nc)) {
      cont_nc->lockDecoration (m_decor_is_svtrk_final->auxid());
    }
 
    for (const auto& p : m_trkDecors) {
      cont_nc->lockDecoration (p.second.auxid());
    }
  }

mergeByShuffling()

StatusCode VKalVrtAthena::VrtSecInclusive::mergeByShuffling ( const EventContext & ctx, std::vector< WrkVrt > * workVerticesContainer )

private

attempt to merge splitted vertices when they are significantly distant due to the long-tail behavior of the vertex reconstruction resolution

Definition at line 1317 of file VertexingAlgs.cxx.

  {
 
    ATH_MSG_DEBUG( " > " << __FUNCTION__ << ": #verticess = " << workVerticesContainer->size() );
 
    unsigned mergeCounter { 0 };
 
    // First, sort WrkVrt by the track multiplicity
    std::sort( workVerticesContainer->begin(), workVerticesContainer->end(), [](WrkVrt& v1, WrkVrt& v2) { return v1.selectedTrackIndices.size() < v2.selectedTrackIndices.size(); } );
 
    // Loop over vertices (small -> large Ntrk order)
    for( auto& wrkvrt : *workVerticesContainer ) {
      if( !wrkvrt.isGood               )             continue;
      if(  wrkvrt.selectedTrackIndices.size() <= 1 ) continue;
 
      // Reverse iteration: large Ntrk -> small Ntrk order
      for( auto ritr = workVerticesContainer->rbegin(); ritr != workVerticesContainer->rend(); ++ritr ) {
        auto& vertexToMerge = *ritr;
 
        if( !vertexToMerge.isGood               )                                             continue;
        if(  vertexToMerge.selectedTrackIndices.size() <= 1 )                                 continue;
        if( &wrkvrt == &vertexToMerge     )                                                   continue;
        if(  vertexToMerge.selectedTrackIndices.size() < wrkvrt.selectedTrackIndices.size() ) continue;
 
        const double& significance = significanceBetweenVertices( wrkvrt, vertexToMerge );
 
        if( significance > m_mergeByShufflingMaxSignificance ) continue;
 
        bool mergeFlag { false };
 
        ATH_MSG_DEBUG(" > " << __FUNCTION__
                      << ": vertex " << &wrkvrt << " #tracks = " << wrkvrt.selectedTrackIndices.size()
                      << " --> to Merge : " << &vertexToMerge << ", #tracks = " << vertexToMerge.selectedTrackIndices.size()
                      << " significance = " << significance );
 
        double min_signif = AlgConsts::maxValue;
 
        // Method 1. Assume that the solution is somewhat wrong, and the solution gets correct if it starts from the other vertex position
        if( m_doSuggestedRefitOnMerging && !mergeFlag ) {
          WrkVrt testVertex = wrkvrt;
          StatusCode sc = refitVertexWithSuggestion( testVertex, vertexToMerge.vertex );
          if( sc.isFailure() ) {
            //ATH_MSG_WARNING(" > " << __FUNCTION__ << ": detected vertex fitting failure!" );
          } else {
 
            const auto signif = significanceBetweenVertices( testVertex, vertexToMerge );
            if( signif < min_signif ) min_signif = signif;
 
            if( signif < m_mergeByShufflingAllowance ) {
              ATH_MSG_DEBUG(" > " << __FUNCTION__ << ":  method1:  vertexToMerge " << &vertexToMerge << ": test signif = " << signif );
              mergeFlag = true;
 
            }
 
            if( m_FillHist && min_signif > 0. ) m_hists["shuffleMinSignif1"]->Fill( log10( min_signif ) );
            if( m_FillHist && mergeFlag ) { m_hists["mergeType"]->Fill( SHUFFLE1 ); }
          }
        }
 
        // Method 2. magnet merging: borrowing another track from the target vertex to merge
        if( m_doMagnetMerging && !mergeFlag ) {
 
          // Loop over tracks in vertexToMerge
          for( auto& index : vertexToMerge.selectedTrackIndices ) {
 
            WrkVrt testVertex = wrkvrt;
            testVertex.selectedTrackIndices.emplace_back( index );
 
            StatusCode sc = refitVertexWithSuggestion( testVertex, vertexToMerge.vertex );
            if( sc.isFailure() ) {
              //ATH_MSG_WARNING(" > " << __FUNCTION__ << ": detected vertex fitting failure!" );
            } else {
 
              const auto signif = significanceBetweenVertices( testVertex, vertexToMerge );
              if( signif < min_signif ) min_signif = signif;
 
              if( signif < m_mergeByShufflingAllowance ) {
                ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": method2:  vertexToMerge " << &vertexToMerge << " track index " << index << ": test signif = " << signif );
                mergeFlag = true;
              }
 
            }
          }
 
          if( m_FillHist && min_signif > 0. ) m_hists["shuffleMinSignif2"]->Fill( log10( min_signif ) );
 
          if( m_FillHist && mergeFlag ) { m_hists["mergeType"]->Fill( SHUFFLE2 ); }
        }
 
        // Method 3. Attempt to force merge
        if( m_doWildMerging && !mergeFlag ) {
 
          WrkVrt testVertex = wrkvrt;
 
          for( auto& index : vertexToMerge.selectedTrackIndices ) {
            testVertex.selectedTrackIndices.emplace_back( index );
          }
 
          StatusCode sc = refitVertexWithSuggestion( testVertex, vertexToMerge.vertex );
          if( sc.isFailure() ) {
            //ATH_MSG_WARNING(" > " << __FUNCTION__ << ": detected vertex fitting failure!" );
          } else {
 
            const auto signif = significanceBetweenVertices( testVertex, vertexToMerge );
            if( signif < min_signif ) min_signif = signif;
 
            if( signif < m_mergeByShufflingAllowance ) {
              ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": method3:  vertexToMerge " << &vertexToMerge << ": test signif = " << signif );
              mergeFlag = true;
            }
 
            if( m_FillHist && min_signif > 0. ) m_hists["shuffleMinSignif3"]->Fill( log10( min_signif ) );
            if( m_FillHist && mergeFlag ) { m_hists["mergeType"]->Fill( SHUFFLE3 ); }
 
          }
        }
 
 
        if( mergeFlag ) {
          ATH_MSG_DEBUG(" > " << __FUNCTION__ << ":   vertexToMerge " << &vertexToMerge << " ==> min signif = " << min_signif << " judged to merge" );
 
          auto vertexToMerge_backup = vertexToMerge;
          auto wrkvrt_backup        = wrkvrt;
 
          StatusCode sc = mergeVertices( vertexToMerge, wrkvrt );
          if( sc.isFailure() ) {
            vertexToMerge = vertexToMerge_backup;
            wrkvrt        = wrkvrt_backup;
            continue;
          }
 
          improveVertexChi2( wrkvrt );
 
          mergeCounter++;
        }
 
      }
 
    }
 
    ATH_MSG_DEBUG(" > " << __FUNCTION__ << "----------------------------------------------" );
    ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": Number of merges = " << mergeCounter );
    ATH_MSG_DEBUG(" > " << __FUNCTION__ << "----------------------------------------------" );
 
    return StatusCode::SUCCESS;
  }

mergeFinalVertices()

StatusCode VKalVrtAthena::VrtSecInclusive::mergeFinalVertices ( const EventContext & ctx, std::vector< WrkVrt > * workVerticesContainer )

private

attempt to merge vertices by lookng at the distance between two vertices

Definition at line 1467 of file VertexingAlgs.cxx.

  {
 
    unsigned mergeCounter { 0 };
 
    while (true) {
      //
      //  Minimal vertex-vertex distance
      //
      for( auto& wrkvrt : *workVerticesContainer) {
        wrkvrt.closestWrkVrtIndex = AlgConsts::invalidUnsigned;
        wrkvrt.closestWrkVrtValue = AlgConsts::maxValue;
      }
 
      std::pair<unsigned, unsigned> indexPair { AlgConsts::invalidUnsigned, AlgConsts::invalidUnsigned };
      auto minDistance = findMinVerticesPair( workVerticesContainer, indexPair, &VrtSecInclusive::distanceBetweenVertices );
 
      if( minDistance      == AlgConsts::maxValue )        break;
      if( indexPair.first  == AlgConsts::invalidUnsigned ) break;
      if( indexPair.second == AlgConsts::invalidUnsigned ) break;
 
      auto& v1 = workVerticesContainer->at(indexPair.first);
      auto& v2 = workVerticesContainer->at(indexPair.second);
 
      const double averageRadius = ( v1.vertex.perp() + v2.vertex.perp() ) / 2.0;
 
      if( minDistance >  m_VertexMergeFinalDistCut + m_VertexMergeFinalDistScaling * averageRadius ) {
        ATH_MSG_DEBUG( "Vertices " << indexPair.first << " and " << indexPair.second
                       <<" are separated by distance " << minDistance );
        break;
      }
 
      ATH_MSG_DEBUG( "Merging FINAL vertices " << indexPair.first << " and " << indexPair.second
                     <<" which are separated by distance "<< minDistance );
 
      StatusCode sc = mergeVertices( v1, v2 );
      if( sc.isFailure() ) {}
      if( m_FillHist ) { m_hists["mergeType"]->Fill( FINAL ); }
 
      improveVertexChi2( v1 );
 
      mergeCounter++;
 
    }
 
    ATH_MSG_DEBUG(" > " << __FUNCTION__ << "----------------------------------------------" );
    ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": Number of merges = " << mergeCounter );
    ATH_MSG_DEBUG(" > " << __FUNCTION__ << "----------------------------------------------" );
 
    return StatusCode::SUCCESS;
 
  } // end of mergeFinalVertices

mergeVertices()

StatusCode VKalVrtAthena::VrtSecInclusive::mergeVertices ( WrkVrt & destination, WrkVrt & source )

private

the 2nd vertex is merged into the 1st vertex.

A destructive operation.

Definition at line 452 of file Reconstruction/VKalVrt/VrtSecInclusive/src/Utilities.cxx.

  {
    //
    //  Merge two close vertices into one (first) and set NTr=0 for second vertex
    //
 
    // firstly, take a backup of the original vertices
    auto v1_bak = v1;
    auto v2_bak = v2;
 
    for( auto& index : v2.selectedTrackIndices ) { v1.selectedTrackIndices.emplace_back( index ); }
 
    // Cleaning
    deque<long int>::iterator TransfEnd;
    sort( v1.selectedTrackIndices.begin(), v1.selectedTrackIndices.end() );
    TransfEnd =  unique(v1.selectedTrackIndices.begin(), v1.selectedTrackIndices.end() );
    v1.selectedTrackIndices.erase( TransfEnd, v1.selectedTrackIndices.end());
    //
    //----------------------------------------------------------
    v2.selectedTrackIndices.clear();             //Clean dropped vertex
    v2.closestWrkVrtValue = AlgConsts::maxValue; //Clean dropped vertex
    v2.closestWrkVrtIndex = 0;                   //Clean dropped vertex
    v2.isGood = false;                           //Clean dropped vertex
 
    v1.closestWrkVrtValue = AlgConsts::maxValue; //Clean new vertex
    v1.closestWrkVrtIndex = 0;                   //Clean new vertex
    v1.isGood = true;                            //Clean new vertex
 
    StatusCode sc = refitVertex( v1 );
    if( sc.isFailure() ) {
      v1 = v1_bak;
      v2 = v2_bak;
 
      ATH_MSG_DEBUG(" >>> " << __FUNCTION__ << ": failure in merging" );
 
      return StatusCode::FAILURE;
    }
 
    return StatusCode::SUCCESS;
  }

monitorVertexingAlgorithmStep()

StatusCode VKalVrtAthena::VrtSecInclusive::monitorVertexingAlgorithmStep ( const EventContext & ctx, std::vector< WrkVrt > * workVerticesContainer, const std::string & name, bool final = false )

private

monitor the intermediate status of vertexing

Definition at line 2218 of file VertexingAlgs.cxx.

                                                                                                               {
    if( m_FillIntermediateVertices ) {
 
      SG::WriteHandle<xAOD::VertexContainer> vertexHandle = SG::makeHandle( m_intermediateVertexKey[name], ctx );
      ATH_CHECK( vertexHandle.record(std::make_unique<xAOD::VertexContainer>(),
                     std::make_unique<xAOD::VertexAuxContainer>()) );
      xAOD::VertexContainer* intermediateVertexContainer = vertexHandle.ptr();
      m_vertexCollectionsDefinitions[ m_intermediateVertexKey.at(name).key() ] = true;
      
      for( auto& wrkvrt : *workVerticesContainer ) {
 
        xAOD::Vertex* vertex = new xAOD::Vertex;
        intermediateVertexContainer->emplace_back( vertex );
 
        // Registering the vertex position to xAOD::Vertex
        vertex->setPosition( wrkvrt.vertex );
 
        // Registering the vertex type: SV
        vertex->setVertexType( xAOD::VxType::SecVtx );
 
        // Registering the vertex chi2 and Ndof
        int ndof = wrkvrt.ndof();
        vertex->setFitQuality( wrkvrt.Chi2, ndof );
 
        // Registering the vertex covariance matrix
        std::vector<float> fCov(wrkvrt.vertexCov.cbegin(), wrkvrt.vertexCov.cend());
        vertex->setCovariance(fCov);
 
        // Registering tracks comprising the vertex to xAOD::Vertex
        // loop over the tracks comprising the vertex
        for( auto trk_id : wrkvrt.selectedTrackIndices ) {
 
          const xAOD::TrackParticle *trk = m_selectedTracks.at( trk_id );
 
          // Acquire link the track to the vertex
          ElementLink<xAOD::TrackParticleContainer> link_trk( *( dynamic_cast<const xAOD::TrackParticleContainer*>( trk->container() ) ), static_cast<long unsigned int>(trk->index()) );
 
          // Register the link to the vertex
          vertex->addTrackAtVertex( link_trk, 1. );
 
        }
 
        for( auto trk_id : wrkvrt.associatedTrackIndices ) {
 
          const xAOD::TrackParticle *trk = m_associatedTracks.at( trk_id );
 
          // Acquire link the track to the vertex
          ElementLink<xAOD::TrackParticleContainer> link_trk( *( dynamic_cast<const xAOD::TrackParticleContainer*>( trk->container() ) ), static_cast<long unsigned int>(trk->index()) );
 
          // Register the link to the vertex
          vertex->addTrackAtVertex( link_trk, 1. );
 
        }
      }
 
    }
 
 
 
    if( !m_FillHist ) return StatusCode::SUCCESS;
 
    printWrkSet( workVerticesContainer, Form("%s (step %u)", name.c_str(), m_vertexingAlgorithmStep) );
 
    unsigned count = std::count_if( workVerticesContainer->begin(), workVerticesContainer->end(),
                                    []( WrkVrt& v ) { return ( v.selectedTrackIndices.size() + v.associatedTrackIndices.size() ) >= 2; } );
 
    if( m_vertexingAlgorithmStep == 0 ) {
 
      const auto compSize = m_selectedTracks.size()*(m_selectedTracks.size() - 1)/2 - m_incomp.size();
      m_hists["vertexYield"]->Fill( m_vertexingAlgorithmStep, compSize );
 
    } else {
 
      m_hists["vertexYield"]->Fill( m_vertexingAlgorithmStep, count );
 
    }
 
    m_hists["vertexYield"]->GetXaxis()->SetBinLabel( m_vertexingAlgorithmStep+1, name.c_str() );
 
    for( auto& vertex : *workVerticesContainer ) {
      auto ntrk = vertex.selectedTrackIndices.size() + vertex.associatedTrackIndices.size();
      if( vertex.isGood && ntrk >= 2 ) {
        dynamic_cast<TH2F*>( m_hists["vertexYieldNtrk"] )->Fill( ntrk, m_vertexingAlgorithmStep );
        dynamic_cast<TH2F*>( m_hists["vertexYieldChi2"] )->Fill( vertex.Chi2/(vertex.ndof() + AlgConsts::infinitesimal), m_vertexingAlgorithmStep );
      }
    }
    m_hists["vertexYieldNtrk"]->GetYaxis()->SetBinLabel( m_vertexingAlgorithmStep+1, name.c_str() );
    m_hists["vertexYieldChi2"]->GetYaxis()->SetBinLabel( m_vertexingAlgorithmStep+1, name.c_str() );
 
 
    if( !final ) return StatusCode::SUCCESS;
 
    for( auto& vertex : *workVerticesContainer ) {
      auto ntrk = vertex.selectedTrackIndices.size() + vertex.associatedTrackIndices.size();
      if( vertex.isGood && ntrk >= 2 ) {
        m_hists["finalVtxNtrk"] ->Fill( ntrk );
        m_hists["finalVtxR"]    ->Fill( vertex.vertex.perp() );
        dynamic_cast<TH2F*>( m_hists["finalVtxNtrkR"] )->Fill( ntrk, vertex.vertex.perp() );
      }
    }
 
    return StatusCode::SUCCESS;
  }

msg()

MsgStream & AthCommonMsg< Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< Algorithm >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

nTrkCommon()

size_t VKalVrtAthena::VrtSecInclusive::nTrkCommon ( std::vector< WrkVrt > * WrkVrtSet, const std::pair< unsigned, unsigned > & pairIndex )

staticprivate

returns the number of tracks commonly present in both vertices

Definition at line 662 of file Reconstruction/VKalVrt/VrtSecInclusive/src/Utilities.cxx.

  {
    //
    //  Number of common tracks for 2 vertices
    //
 
    auto& trackIndices1 = workVerticesContainer->at( pairIndex.first ).selectedTrackIndices;
    auto& trackIndices2 = workVerticesContainer->at( pairIndex.second ).selectedTrackIndices;
 
    if( trackIndices1.size() < 2 ) return 0;
    if( trackIndices2.size() < 2 ) return 0;
 
    size_t nTrkCom = 0;
 
    for( auto& index : trackIndices1 ) {
  if( std::find(trackIndices2.begin(),trackIndices2.end(), index) != trackIndices2.end()) nTrkCom++;
    }
 
    return nTrkCom;
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

passedFakeReject()

bool VKalVrtAthena::VrtSecInclusive::passedFakeReject ( const Amg::Vector3D & FitVertex, const xAOD::TrackParticle * itrk, const xAOD::TrackParticle * jtrk )

private

Flag false if the consistituent tracks are not consistent with the vertex position.

Definition at line 2184 of file Reconstruction/VKalVrt/VrtSecInclusive/src/Utilities.cxx.

  {
 
    const bool& check_itrk = ( this->*m_patternStrategyFuncs[m_checkPatternStrategy] )( itrk, FitVertex );
    const bool& check_jtrk = ( this->*m_patternStrategyFuncs[m_checkPatternStrategy] )( jtrk, FitVertex );
 
    return ( check_itrk && check_jtrk );
 
  }

patternCheck()

bool VKalVrtAthena::VrtSecInclusive::patternCheck ( const uint32_t & pattern, const Amg::Vector3D & vertex )

private

Definition at line 2020 of file Reconstruction/VKalVrt/VrtSecInclusive/src/Utilities.cxx.

                                                                                         {
    bool flag = false;
 
    if( m_geoModel == VKalVrtAthena::GeoModel::Run2 ) {
      flag = patternCheckRun2( pattern, vertex );
    } else if( m_geoModel == VKalVrtAthena::GeoModel::Run1 ) {
      flag = patternCheckRun1( pattern, vertex );
    }
 
    return flag;
  }

patternCheckOuterOnly()

bool VKalVrtAthena::VrtSecInclusive::patternCheckOuterOnly ( const uint32_t & pattern, const Amg::Vector3D & vertex )

private

Definition at line 2033 of file Reconstruction/VKalVrt/VrtSecInclusive/src/Utilities.cxx.

                                                                                                  {
    bool flag = false;
 
    if( m_geoModel == VKalVrtAthena::GeoModel::Run2 ) {
      flag = patternCheckRun2OuterOnly( pattern, vertex );
    } else if( m_geoModel == VKalVrtAthena::GeoModel::Run1 ) {
      flag = patternCheckRun1OuterOnly( pattern, vertex );
    }
 
    return flag;
  }

patternCheckRun1()

bool VKalVrtAthena::VrtSecInclusive::patternCheckRun1 ( const uint32_t & pattern, const Amg::Vector3D & vertex )

staticprivate

Definition at line 1710 of file Reconstruction/VKalVrt/VrtSecInclusive/src/Utilities.cxx.

                                                                                             {
    //
    // rough guesses for active layers:
    // BeamPipe: 25.0
    // Pix0 (BLayer): 47.7-54.4, Pix1: 85.5-92.2, Pix2: 119.3-126.1
    // Sct0: 290-315, Sct1: 360-390, Sct2: 430-460, Sct3:500-530
    //
 
    const double rad  = vertex.perp();
    const double absz = fabs( vertex.z() );
 
    // vertex area classification
    enum vertexArea {
      insideBeamPipe,
 
      insidePixelBarrel1,
      aroundPixelBarrel1,
 
      outsidePixelBarrel1_and_insidePixelBarrel2,
      aroundPixelBarrel2,
 
      outsidePixelBarrel2_and_insidePixelBarrel3,
      aroundPixelBarrel3,
 
      outsidePixelBarrel3_and_insideSctBarrel0,
      aroundSctBarrel0,
 
      outsideSctBarrel0_and_insideSctBarrel1,
      aroundSctBarrel1,
    };
 
    // Mutually exclusive vertex position pattern
    Int_t vertex_pattern = 0;
    if( rad < 25.00 ) {
      vertex_pattern = insideBeamPipe;
 
    } else if( rad < 47.7 && absz < 400.5 ) {
      vertex_pattern = insidePixelBarrel1;
 
    } else if( rad < 54.4 && absz < 400.5 ) {
      vertex_pattern = aroundPixelBarrel1;
 
    } else if( rad < 85.5 && absz < 400.5 ) {
      vertex_pattern = outsidePixelBarrel1_and_insidePixelBarrel2;
 
    } else if( rad < 92.2 && absz < 400.5 ) {
      vertex_pattern = aroundPixelBarrel2;
 
    } else if( rad < 119.3 && absz < 400.5 ) {
      vertex_pattern = outsidePixelBarrel2_and_insidePixelBarrel3;
 
    } else if( rad < 126.1 && absz < 400.5 ) {
      vertex_pattern = aroundPixelBarrel3;
 
    } else if( rad < 290 && absz < 749.0 ) {
      vertex_pattern = outsidePixelBarrel3_and_insideSctBarrel0;
 
    } else if( rad < 315 && absz < 749.0 ) {
      vertex_pattern = aroundSctBarrel0;
 
    } else if( rad < 360 && absz < 749.0 ) {
      vertex_pattern = outsideSctBarrel0_and_insideSctBarrel1;
 
    } else if( rad < 390 && absz < 749.0 ) {
      vertex_pattern = aroundSctBarrel1;
 
    } else {
    }
 

    if( vertex_pattern == insideBeamPipe ) {
 
      if( ! (pattern & (1<<Trk::pixelBarrel1)) ) return false;
 
    }
 
 
    else if( vertex_pattern == insidePixelBarrel1 ) {
 
      if( ! (pattern & (1<<Trk::pixelBarrel1)) ) return false;
    }
 
 
    else if( vertex_pattern == aroundPixelBarrel1 ) {
 
      // require nothing for PixelBarrel1
      if( ! (pattern & (1<<Trk::pixelBarrel2)) ) return false;
    }
 
 
    else if( vertex_pattern == outsidePixelBarrel1_and_insidePixelBarrel2 ) {
 
      if(   (pattern & (1<<Trk::pixelBarrel1)) ) return false;
      if( ! (pattern & (1<<Trk::pixelBarrel2)) ) return false;
    }
 
 
    else if( vertex_pattern == aroundPixelBarrel2 ) {
 
      if(   (pattern & (1<<Trk::pixelBarrel1)) ) return false;
      // require nothing for PixelBarrel2
      if( ! (pattern & (1<<Trk::pixelBarrel3)) ) return false;
    }
 
 
    else if( vertex_pattern == outsidePixelBarrel2_and_insidePixelBarrel3 ) {
 
      if(   (pattern & (1<<Trk::pixelBarrel1)) ) return false;
      if(   (pattern & (1<<Trk::pixelBarrel2)) ) return false;
      if( ! (pattern & (1<<Trk::pixelBarrel3)) ) return false;
    }
 
    else if( vertex_pattern == aroundPixelBarrel3 ) {
 
      if(   (pattern & (1<<Trk::pixelBarrel1)) ) return false;
      if(   (pattern & (1<<Trk::pixelBarrel2)) ) return false;
      // require nothing for PixelBarrel3
      if( ! (pattern & (1<<Trk::sctBarrel0)) ) return false;
    }
 
 
    else if( vertex_pattern == outsidePixelBarrel3_and_insideSctBarrel0 ) {
 
      if(   (pattern & (1<<Trk::pixelBarrel1)) ) return false;
      if(   (pattern & (1<<Trk::pixelBarrel2)) ) return false;
      if(   (pattern & (1<<Trk::pixelBarrel3)) ) return false;
      if( ! (pattern & (1<<Trk::sctBarrel0)) ) return false;
    }
 
 
    else if( vertex_pattern == aroundSctBarrel0 ) {
 
      if(   (pattern & (1<<Trk::pixelBarrel1)) ) return false;
      if(   (pattern & (1<<Trk::pixelBarrel2)) ) return false;
      if(   (pattern & (1<<Trk::pixelBarrel3)) ) return false;
      // require nothing for SctBarrel0
      if( ! (pattern & (1<<Trk::sctBarrel1)) ) return false;
    }
 
 
    else if( vertex_pattern == outsideSctBarrel0_and_insideSctBarrel1 ) {
 
      if(   (pattern & (1<<Trk::pixelBarrel1)) ) return false;
      if(   (pattern & (1<<Trk::pixelBarrel2)) ) return false;
      if(   (pattern & (1<<Trk::pixelBarrel3)) ) return false;
      if(   (pattern & (1<<Trk::sctBarrel0)) ) return false;
      if( ! (pattern & (1<<Trk::sctBarrel1)) ) return false;
    }
 
 
    else if( vertex_pattern == aroundSctBarrel1 ) {
      if(   (pattern & (1<<Trk::pixelBarrel1)) ) return false;
      if(   (pattern & (1<<Trk::pixelBarrel2)) ) return false;
      if(   (pattern & (1<<Trk::pixelBarrel3)) ) return false;
      if(   (pattern & (1<<Trk::sctBarrel0)) ) return false;
      // require nothing for SctBarrel1
      if( ! (pattern & (1<<Trk::sctBarrel2)) ) return false;
    }
 
    return true;
  }

patternCheckRun1OuterOnly()

bool VKalVrtAthena::VrtSecInclusive::patternCheckRun1OuterOnly ( const uint32_t & pattern, const Amg::Vector3D & vertex )

staticprivate

Definition at line 1875 of file Reconstruction/VKalVrt/VrtSecInclusive/src/Utilities.cxx.

                                                                                                      {
    //
    // rough guesses for active layers:
    // BeamPipe: 25.0
    // Pix0 (BLayer): 47.7-54.4, Pix1: 85.5-92.2, Pix2: 119.3-126.1
    // Sct0: 290-315, Sct1: 360-390, Sct2: 430-460, Sct3:500-530
    //
 
    const double rad  = vertex.perp();
    const double absz = fabs( vertex.z() );
 
    // vertex area classification
    enum vertexArea {
      insideBeamPipe,
 
      insidePixelBarrel1,
      aroundPixelBarrel1,
 
      outsidePixelBarrel1_and_insidePixelBarrel2,
      aroundPixelBarrel2,
 
      outsidePixelBarrel2_and_insidePixelBarrel3,
      aroundPixelBarrel3,
 
      outsidePixelBarrel3_and_insideSctBarrel0,
      aroundSctBarrel0,
 
      outsideSctBarrel0_and_insideSctBarrel1,
      aroundSctBarrel1,
    };
 
    // Mutually exclusive vertex position pattern
    Int_t vertex_pattern = 0;
    if( rad < 25.00 ) {
      vertex_pattern = insideBeamPipe;
 
    } else if( rad < 47.7 && absz < 400.5 ) {
      vertex_pattern = insidePixelBarrel1;
 
    } else if( rad < 54.4 && absz < 400.5 ) {
      vertex_pattern = aroundPixelBarrel1;
 
    } else if( rad < 85.5 && absz < 400.5 ) {
      vertex_pattern = outsidePixelBarrel1_and_insidePixelBarrel2;
 
    } else if( rad < 92.2 && absz < 400.5 ) {
      vertex_pattern = aroundPixelBarrel2;
 
    } else if( rad < 119.3 && absz < 400.5 ) {
      vertex_pattern = outsidePixelBarrel2_and_insidePixelBarrel3;
 
    } else if( rad < 126.1 && absz < 400.5 ) {
      vertex_pattern = aroundPixelBarrel3;
 
    } else if( rad < 290 && absz < 749.0 ) {
      vertex_pattern = outsidePixelBarrel3_and_insideSctBarrel0;
 
    } else if( rad < 315 && absz < 749.0 ) {
      vertex_pattern = aroundSctBarrel0;
 
    } else if( rad < 360 && absz < 749.0 ) {
      vertex_pattern = outsideSctBarrel0_and_insideSctBarrel1;
 
    } else if( rad < 390 && absz < 749.0 ) {
      vertex_pattern = aroundSctBarrel1;
 
    } else {
    }
 

    if( vertex_pattern == insideBeamPipe ) {
 
      if( ! (pattern & (1<<Trk::pixelBarrel1)) ) return false;
 
    }
 
 
    else if( vertex_pattern == insidePixelBarrel1 ) {
 
      if( ! (pattern & (1<<Trk::pixelBarrel1)) ) return false;
    }
 
 
    else if( vertex_pattern == aroundPixelBarrel1 ) {
 
      // require nothing for PixelBarrel1
      if( ! (pattern & (1<<Trk::pixelBarrel2)) ) return false;
    }
 
 
    else if( vertex_pattern == outsidePixelBarrel1_and_insidePixelBarrel2 ) {
 
      if( ! (pattern & (1<<Trk::pixelBarrel2)) ) return false;
    }
 
 
    else if( vertex_pattern == aroundPixelBarrel2 ) {
 
      // require nothing for PixelBarrel2
      if( ! (pattern & (1<<Trk::pixelBarrel3)) ) return false;
    }
 
 
    else if( vertex_pattern == outsidePixelBarrel2_and_insidePixelBarrel3 ) {
 
      if( ! (pattern & (1<<Trk::pixelBarrel3)) ) return false;
    }
 
    else if( vertex_pattern == aroundPixelBarrel3 ) {
 
      // require nothing for PixelBarrel3
      if( ! (pattern & (1<<Trk::sctBarrel0)) ) return false;
    }
 
 
    else if( vertex_pattern == outsidePixelBarrel3_and_insideSctBarrel0 ) {
 
      if( ! (pattern & (1<<Trk::sctBarrel0)) ) return false;
    }
 
 
    else if( vertex_pattern == aroundSctBarrel0 ) {
 
      // require nothing for SctBarrel0
      if( ! (pattern & (1<<Trk::sctBarrel1)) ) return false;
    }
 
 
    else if( vertex_pattern == outsideSctBarrel0_and_insideSctBarrel1 ) {
 
      if( ! (pattern & (1<<Trk::sctBarrel1)) ) return false;
    }
 
 
    else if( vertex_pattern == aroundSctBarrel1 ) {
      // require nothing for SctBarrel1
      if( ! (pattern & (1<<Trk::sctBarrel2)) ) return false;
    }
 
    return true;
  }

patternCheckRun2()

bool VKalVrtAthena::VrtSecInclusive::patternCheckRun2 ( const uint32_t & pattern, const Amg::Vector3D & vertex )

staticprivate

Definition at line 1300 of file Reconstruction/VKalVrt/VrtSecInclusive/src/Utilities.cxx.

                                                                                             {
 
    //
    // rough guesses for active layers:
    // BeamPipe: 23.5-24.3
    // IBL: 31.0-38.4
    // Pix0 (BLayer): 47.7-54.4, Pix1: 85.5-92.2, Pix2: 119.3-126.1
    // Sct0: 290-315, Sct1: 360-390, Sct2: 430-460, Sct3:500-530
    //
 
    const double rad  = vertex.perp();
    const double absz = fabs( vertex.z() );
 
    // vertex area classification
    enum vertexArea {
      insideBeamPipe,
 
      insidePixelBarrel0,
      aroundPixelBarrel0,
 
      outsidePixelBarrel0_and_insidePixelBarrel1,
      aroundPixelBarrel1,
 
      outsidePixelBarrel1_and_insidePixelBarrel2,
      aroundPixelBarrel2,
 
      outsidePixelBarrel2_and_insidePixelBarrel3,
      aroundPixelBarrel3,
 
      outsidePixelBarrel3_and_insideSctBarrel0,
      aroundSctBarrel0,
 
      outsideSctBarrel0_and_insideSctBarrel1,
      aroundSctBarrel1,
    };
 
    // Mutually exclusive vertex position pattern
    int vertex_pattern = 0;
    if( rad < 23.50 ) {
      vertex_pattern = insideBeamPipe;
 
    } else if( rad < 31.0 && absz < 331.5 ) {
      vertex_pattern = insidePixelBarrel0;
 
    } else if( rad < 38.4 && absz < 331.5 ) {
      vertex_pattern = aroundPixelBarrel0;
 
    } else if( rad < 47.7 && absz < 400.5 ) {
      vertex_pattern = outsidePixelBarrel0_and_insidePixelBarrel1;
 
    } else if( rad < 54.4 && absz < 400.5 ) {
      vertex_pattern = aroundPixelBarrel1;
 
    } else if( rad < 85.5 && absz < 400.5 ) {
      vertex_pattern = outsidePixelBarrel1_and_insidePixelBarrel2;
 
    } else if( rad < 92.2 && absz < 400.5 ) {
      vertex_pattern = aroundPixelBarrel2;
 
    } else if( rad < 119.3 && absz < 400.5 ) {
      vertex_pattern = outsidePixelBarrel2_and_insidePixelBarrel3;
 
    } else if( rad < 126.1 && absz < 400.5 ) {
      vertex_pattern = aroundPixelBarrel3;
 
    } else if( rad < 290 && absz < 749.0 ) {
      vertex_pattern = outsidePixelBarrel3_and_insideSctBarrel0;
 
    } else if( rad < 315 && absz < 749.0 ) {
      vertex_pattern = aroundSctBarrel0;
 
    } else if( rad < 360 && absz < 749.0 ) {
      vertex_pattern = outsideSctBarrel0_and_insideSctBarrel1;
 
    } else if( rad < 390 && absz < 749.0 ) {
      vertex_pattern = aroundSctBarrel1;
 
    } else {
    }
 
    unsigned nPixelLayers { 0 };
    {
      if ( pattern & (1 << Trk::pixelBarrel0) ) nPixelLayers++;
      if ( pattern & (1 << Trk::pixelBarrel1) ) nPixelLayers++;
      if ( pattern & (1 << Trk::pixelBarrel2) ) nPixelLayers++;
      if ( pattern & (1 << Trk::pixelBarrel3) ) nPixelLayers++;
      if ( pattern & (1 << Trk::pixelEndCap0) ) nPixelLayers++;
      if ( pattern & (1 << Trk::pixelEndCap1) ) nPixelLayers++;
      if ( pattern & (1 << Trk::pixelEndCap2) ) nPixelLayers++;
    }

    if( vertex_pattern == insideBeamPipe ) {
 
      if( ! (pattern & (1<<Trk::pixelBarrel0)) ) return false;
      if( nPixelLayers < 3 )                     return false;
 
 
    } else if( vertex_pattern == insidePixelBarrel0 ) {
 
      if( ! (pattern & (1<<Trk::pixelBarrel0)) ) return false;
      if( nPixelLayers < 3 )                     return false;
    }
 
 
    else if( vertex_pattern == aroundPixelBarrel0 ) {
 
      // require nothing for PixelBarrel0
      if( ! (pattern & (1<<Trk::pixelBarrel1)) ) return false;
      if( nPixelLayers < 2 )                     return false;
    }
 
 
    else if( vertex_pattern == outsidePixelBarrel0_and_insidePixelBarrel1 ) {
 
      if(   (pattern & (1<<Trk::pixelBarrel0)) ) return false;
      if( ! (pattern & (1<<Trk::pixelBarrel1)) ) return false;
      if( nPixelLayers < 2 )                     return false;
    }
 
 
    else if( vertex_pattern == aroundPixelBarrel1 ) {
 
      if(   (pattern & (1<<Trk::pixelBarrel0)) ) return false;
      // require nothing for PixelBarrel
      if( ! (pattern & (1<<Trk::pixelBarrel2)) ) return false;
      if( nPixelLayers < 2 )                     return false;
    }
 
 
    else if( vertex_pattern == outsidePixelBarrel1_and_insidePixelBarrel2 ) {
 
      if(   (pattern & (1<<Trk::pixelBarrel0)) ) return false;
      if(   (pattern & (1<<Trk::pixelBarrel1)) ) return false;
      if( ! (pattern & (1<<Trk::pixelBarrel2)) ) return false;
      if( nPixelLayers < 2 )                     return false;
    }
 
 
    else if( vertex_pattern == aroundPixelBarrel2 ) {
 
      if(   (pattern & (1<<Trk::pixelBarrel0)) ) return false;
      if(   (pattern & (1<<Trk::pixelBarrel1)) ) return false;
      // require nothing for PixelBarrel2
      if( ! (pattern & (1<<Trk::pixelBarrel3)) ) return false;
    }
 
 
    else if( vertex_pattern == outsidePixelBarrel2_and_insidePixelBarrel3 ) {
 
      if(   (pattern & (1<<Trk::pixelBarrel0)) ) return false;
      if(   (pattern & (1<<Trk::pixelBarrel1)) ) return false;
      if(   (pattern & (1<<Trk::pixelBarrel2)) ) return false;
      if( ! (pattern & (1<<Trk::pixelBarrel3)) ) return false;
    }
 
    else if( vertex_pattern == aroundPixelBarrel3 ) {
 
      if(   (pattern & (1<<Trk::pixelBarrel0)) ) return false;
      if(   (pattern & (1<<Trk::pixelBarrel1)) ) return false;
      if(   (pattern & (1<<Trk::pixelBarrel2)) ) return false;
      // require nothing for PixelBarrel3
      if( ! (pattern & (1<<Trk::sctBarrel0)) )   return false;
    }
 
 
    else if( vertex_pattern == outsidePixelBarrel3_and_insideSctBarrel0 ) {
 
      if(   (pattern & (1<<Trk::pixelBarrel0)) ) return false;
      if(   (pattern & (1<<Trk::pixelBarrel1)) ) return false;
      if(   (pattern & (1<<Trk::pixelBarrel2)) ) return false;
      if(   (pattern & (1<<Trk::pixelBarrel3)) ) return false;
      if( ! (pattern & (1<<Trk::sctBarrel0)) ) return false;
    }
 
 
    else if( vertex_pattern == aroundSctBarrel0 ) {
 
      if(   (pattern & (1<<Trk::pixelBarrel0)) ) return false;
      if(   (pattern & (1<<Trk::pixelBarrel1)) ) return false;
      if(   (pattern & (1<<Trk::pixelBarrel2)) ) return false;
      if(   (pattern & (1<<Trk::pixelBarrel3)) ) return false;
      // require nothing for SctBarrel0
      if( ! (pattern & (1<<Trk::sctBarrel1)) ) return false;
    }
 
 
    else if( vertex_pattern == outsideSctBarrel0_and_insideSctBarrel1 ) {
 
      if(   (pattern & (1<<Trk::pixelBarrel0)) ) return false;
      if(   (pattern & (1<<Trk::pixelBarrel1)) ) return false;
      if(   (pattern & (1<<Trk::pixelBarrel2)) ) return false;
      if(   (pattern & (1<<Trk::pixelBarrel3)) ) return false;
      if(   (pattern & (1<<Trk::sctBarrel0)) ) return false;
      if( ! (pattern & (1<<Trk::sctBarrel1)) ) return false;
    }
 
 
    else if( vertex_pattern == aroundSctBarrel1 ) {
      if(   (pattern & (1<<Trk::pixelBarrel0)) ) return false;
      if(   (pattern & (1<<Trk::pixelBarrel1)) ) return false;
      if(   (pattern & (1<<Trk::pixelBarrel2)) ) return false;
      if(   (pattern & (1<<Trk::pixelBarrel3)) ) return false;
      if(   (pattern & (1<<Trk::sctBarrel0)) ) return false;
      // require nothing for SctBarrel1
      if( ! (pattern & (1<<Trk::sctBarrel2)) ) return false;
    }
 
    return true;
 
  }

patternCheckRun2OuterOnly()

bool VKalVrtAthena::VrtSecInclusive::patternCheckRun2OuterOnly ( const uint32_t & pattern, const Amg::Vector3D & vertex )

staticprivate

Definition at line 1514 of file Reconstruction/VKalVrt/VrtSecInclusive/src/Utilities.cxx.

                                                                                                      {
 
    //
    // rough guesses for active layers:
    // BeamPipe: 23.5-24.3
    // IBL: 31.0-38.4
    // Pix0 (BLayer): 47.7-54.4, Pix1: 85.5-92.2, Pix2: 119.3-126.1
    // Sct0: 290-315, Sct1: 360-390, Sct2: 430-460, Sct3:500-530
    //
 
    const double rad  = vertex.perp();
    const double absz = fabs( vertex.z() );
 
    // vertex area classification
    enum vertexArea {
      insideBeamPipe,
 
      insidePixelBarrel0,
      aroundPixelBarrel0,
 
      outsidePixelBarrel0_and_insidePixelBarrel1,
      aroundPixelBarrel1,
 
      outsidePixelBarrel1_and_insidePixelBarrel2,
      aroundPixelBarrel2,
 
      outsidePixelBarrel2_and_insidePixelBarrel3,
      aroundPixelBarrel3,
 
      outsidePixelBarrel3_and_insideSctBarrel0,
      aroundSctBarrel0,
 
      outsideSctBarrel0_and_insideSctBarrel1,
      aroundSctBarrel1,
    };
 
    // Mutually exclusive vertex position pattern
    int vertex_pattern = 0;
    if( rad < 23.50 ) {
      vertex_pattern = insideBeamPipe;
 
    } else if( rad < 31.0 && absz < 331.5 ) {
      vertex_pattern = insidePixelBarrel0;
 
    } else if( rad < 38.4 && absz < 331.5 ) {
      vertex_pattern = aroundPixelBarrel0;
 
    } else if( rad < 47.7 && absz < 400.5 ) {
      vertex_pattern = outsidePixelBarrel0_and_insidePixelBarrel1;
 
    } else if( rad < 54.4 && absz < 400.5 ) {
      vertex_pattern = aroundPixelBarrel1;
 
    } else if( rad < 85.5 && absz < 400.5 ) {
      vertex_pattern = outsidePixelBarrel1_and_insidePixelBarrel2;
 
    } else if( rad < 92.2 && absz < 400.5 ) {
      vertex_pattern = aroundPixelBarrel2;
 
    } else if( rad < 119.3 && absz < 400.5 ) {
      vertex_pattern = outsidePixelBarrel2_and_insidePixelBarrel3;
 
    } else if( rad < 126.1 && absz < 400.5 ) {
      vertex_pattern = aroundPixelBarrel3;
 
    } else if( rad < 290 && absz < 749.0 ) {
      vertex_pattern = outsidePixelBarrel3_and_insideSctBarrel0;
 
    } else if( rad < 315 && absz < 749.0 ) {
      vertex_pattern = aroundSctBarrel0;
 
    } else if( rad < 360 && absz < 749.0 ) {
      vertex_pattern = outsideSctBarrel0_and_insideSctBarrel1;
 
    } else if( rad < 390 && absz < 749.0 ) {
      vertex_pattern = aroundSctBarrel1;
 
    } else {
    }
 
 
    unsigned nPixelLayers { 0 };
    {
      nPixelLayers += ( pattern & (1 << Trk::pixelBarrel0) );
      nPixelLayers += ( pattern & (1 << Trk::pixelBarrel1) );
      nPixelLayers += ( pattern & (1 << Trk::pixelBarrel2) );
      nPixelLayers += ( pattern & (1 << Trk::pixelBarrel3) );
      nPixelLayers += ( pattern & (1 << Trk::pixelEndCap0) );
      nPixelLayers += ( pattern & (1 << Trk::pixelEndCap1) );
      nPixelLayers += ( pattern & (1 << Trk::pixelEndCap2) );
    }

    if( vertex_pattern == insideBeamPipe ) {
 
      if( ! (pattern & (1<<Trk::pixelBarrel0)) ) return false;
      if( ! (pattern & (1<<Trk::pixelBarrel1)) ) return false;
      if( nPixelLayers < 3                     ) return false;
 
    } else if( vertex_pattern == insidePixelBarrel0 ) {
 
      if( ! (pattern & (1<<Trk::pixelBarrel0)) ) return false;
      if( ! (pattern & (1<<Trk::pixelBarrel1)) ) return false;
      if( nPixelLayers < 3                     ) return false;
 
    }
 
 
    else if( vertex_pattern == aroundPixelBarrel0 ) {
 
      // require nothing for PixelBarrel0
      if( ! (pattern & (1<<Trk::pixelBarrel1)) ) return false;
      if( ! (pattern & (1<<Trk::pixelBarrel2)) ) return false;
      if( nPixelLayers < 3                     ) return false;
    }
 
 
    else if( vertex_pattern == outsidePixelBarrel0_and_insidePixelBarrel1 ) {
 
      if( ! (pattern & (1<<Trk::pixelBarrel1)) ) return false;
      if( ! (pattern & (1<<Trk::pixelBarrel2)) ) return false;
      if( nPixelLayers < 3                     ) return false;
    }
 
 
    else if( vertex_pattern == aroundPixelBarrel1 ) {
 
      // require nothing for PixelBarrel1
      if( ! (pattern & (1<<Trk::pixelBarrel2)) ) return false;
      if( ! (pattern & (1<<Trk::pixelBarrel3)) ) return false;
      if( nPixelLayers < 2                     ) return false;
    }
 
 
    else if( vertex_pattern == outsidePixelBarrel1_and_insidePixelBarrel2 ) {
 
      if( ! (pattern & (1<<Trk::pixelBarrel2)) ) return false;
      if( ! (pattern & (1<<Trk::pixelBarrel3)) ) return false;
      if( nPixelLayers < 2                     ) return false;
    }
 
 
    else if( vertex_pattern == aroundPixelBarrel2 ) {
 
      // require nothing for PixelBarrel2
      if( ! (pattern & (1<<Trk::pixelBarrel3)) ) return false;
    }
 
 
    else if( vertex_pattern == outsidePixelBarrel2_and_insidePixelBarrel3 ) {
 
      if( ! (pattern & (1<<Trk::pixelBarrel3)) ) return false;
    }
 
    else if( vertex_pattern == aroundPixelBarrel3 ) {
 
      // require nothing for PixelBarrel3
      if( ! (pattern & (1<<Trk::sctBarrel0)) ) return false;
      if( ! (pattern & (1<<Trk::sctBarrel1)) ) return false;
    }
 
 
    else if( vertex_pattern == outsidePixelBarrel3_and_insideSctBarrel0 ) {
 
      if( ! (pattern & (1<<Trk::sctBarrel0)) ) return false;
      if( ! (pattern & (1<<Trk::sctBarrel1)) ) return false;
    }
 
 
    else if( vertex_pattern == aroundSctBarrel0 ) {
 
      // require nothing for SctBarrel0
      if( ! (pattern & (1<<Trk::sctBarrel1)) ) return false;
      if( ! (pattern & (1<<Trk::sctBarrel2)) ) return false;
    }
 
 
    else if( vertex_pattern == outsideSctBarrel0_and_insideSctBarrel1 ) {
 
      if( ! (pattern & (1<<Trk::sctBarrel1)) ) return false;
      if( ! (pattern & (1<<Trk::sctBarrel2)) ) return false;
    }
 
 
    else if( vertex_pattern == aroundSctBarrel1 ) {
      // require nothing for SctBarrel1
      if( ! (pattern & (1<<Trk::sctBarrel2)) ) return false;
      if( ! (pattern & (1<<Trk::sctBarrel3)) ) return false;
    }
 
    return true;
 
  }

printWrkSet()

void VKalVrtAthena::VrtSecInclusive::printWrkSet ( const std::vector< WrkVrt > * WrkVrtSet, const std::string & name )

private

print the contents of reconstructed vertices

Definition at line 862 of file Reconstruction/VKalVrt/VrtSecInclusive/src/Utilities.cxx.

  {
    ATH_MSG_DEBUG( " >> " << __FUNCTION__ << ": ===============================================================" );
    ATH_MSG_DEBUG( " >> " << __FUNCTION__ << ": " << name << ": #vertices = " << workVerticesContainer->size() );
 
    std::set<const xAOD::TrackParticle*> usedTracks;
 
    auto concatenateIndicesToString = []( auto indices, auto& collection ) -> std::string {
      if( 0 == indices.size() ) return "";
      return std::accumulate( std::next(indices.begin()), indices.end(), std::to_string( indices.at(0) ),
                              [&collection]( const std::string& str, auto& index ) { return str + ", " + std::to_string( collection.at(index)->index() ); } );
    };
 
    std::map<const xAOD::TruthVertex*, bool> previous;
 
    for( auto& pair : m_matchMap ) { previous.emplace( pair.first, pair.second ); }
 
    m_matchMap.clear();
    for( const auto* truthVertex : m_tracingTruthVertices ) { m_matchMap.emplace( truthVertex, false ); }
 
    for(size_t iv=0; iv<workVerticesContainer->size(); iv++) {
      const auto& wrkvrt = workVerticesContainer->at(iv);
 
      if( wrkvrt.nTracksTotal() < 2 ) continue;
 
      std::string sels    = concatenateIndicesToString( wrkvrt.selectedTrackIndices,   m_selectedTracks   );
      std::string assocs  = concatenateIndicesToString( wrkvrt.associatedTrackIndices, m_associatedTracks );
 
      for( const auto& index : wrkvrt.selectedTrackIndices )   { usedTracks.insert( m_selectedTracks.at(index) );   }
      for( const auto& index : wrkvrt.associatedTrackIndices ) { usedTracks.insert( m_associatedTracks.at(index) ); }
 
      ATH_MSG_DEBUG( " >> " << __FUNCTION__ << ": " << name << " vertex [" <<  iv << "]: " << &wrkvrt
                     << ", isGood  = "           << (wrkvrt.isGood? "true" : "false")
                     << ", #ntrks(tot, sel, assoc) = (" << wrkvrt.nTracksTotal() << ", " << wrkvrt.selectedTrackIndices.size() << ", " << wrkvrt.associatedTrackIndices.size() << "), "
                     << ", chi2/ndof = "         << wrkvrt.fitQuality()
                     << ", (r, z) = ("           << wrkvrt.vertex.perp()
                     << ", "                     << wrkvrt.vertex.z() << ")"
                     << ", sels = { "            << sels << " }"
                     << ", assocs = { "          << assocs << " }" );
 
      // Truth match condition
      for( const auto* truthVertex : m_tracingTruthVertices ) {
 
 
        Amg::Vector3D vTruth( truthVertex->x(), truthVertex->y(), truthVertex->z() );
        Amg::Vector3D vReco ( wrkvrt.vertex.x(), wrkvrt.vertex.y(), wrkvrt.vertex.z() );
 
        const auto distance = vReco - vTruth;
 
        AmgSymMatrix(3) cov;
        cov.fillSymmetric( 0, 0, wrkvrt.vertexCov.at(0) );
        cov.fillSymmetric( 1, 0, wrkvrt.vertexCov.at(1) );
        cov.fillSymmetric( 1, 1, wrkvrt.vertexCov.at(2) );
        cov.fillSymmetric( 2, 0, wrkvrt.vertexCov.at(3) );
        cov.fillSymmetric( 2, 1, wrkvrt.vertexCov.at(4) );
        cov.fillSymmetric( 2, 2, wrkvrt.vertexCov.at(5) );
 
        const double s2 = distance.transpose() * cov.inverse() * distance;
 
        if( distance.norm() < 2.0 || s2 < 100. ) m_matchMap.at( truthVertex ) = true;
 
      }
 
    }
 
    ATH_MSG_DEBUG( " >> " << __FUNCTION__ << ": number of used tracks = " << usedTracks.size() );
 
    if( !previous.empty() && previous.size() == m_matchMap.size() ) {
      for( auto& pair : m_matchMap ) {
        if( previous.find( pair.first ) == previous.end() ) continue;
        if( pair.second != previous.at( pair.first ) ) {
          ATH_MSG_DEBUG( " >> " << __FUNCTION__ << ": Match flag has changed: (r, z) = (" << pair.first->perp() << ", " << pair.first->z() << ")" );
        }
      }
    }
 
    if( m_FillHist ) {
      for( auto& pair : m_matchMap ) {
        if( pair.second ) m_hists["nMatchedTruths"]->Fill( m_vertexingAlgorithmStep+2, pair.first->perp() );
      }
    }
 
    std::string msg;
    for( const auto* trk : usedTracks ) { msg += Form("%ld, ", trk->index() ); }
 
    ATH_MSG_DEBUG( " >> " << __FUNCTION__ << ": used tracks = " << msg );
    ATH_MSG_DEBUG( " >> " << __FUNCTION__ << ": ===============================================================" );
 
  }

processPrimaryVertices()

StatusCode VKalVrtAthena::VrtSecInclusive::processPrimaryVertices ( )

private

Definition at line 686 of file Reconstruction/VKalVrt/VrtSecInclusive/src/Utilities.cxx.

                                                     {
 
    //--------------------------------------------------------
    //  Primary vertex extraction from TES
    //
 
    ATH_CHECK( evtStore()->retrieve( m_primaryVertices, "PrimaryVertices") );
 
    if( m_FillNtuple ) m_ntupleVars->get<unsigned int>( "NumPV" ) = 0;
    m_thePV = nullptr;
 
    ATH_MSG_DEBUG( "processPrimaryVertices(): pv_size = " << m_primaryVertices->size() );
 
    // Loop over PV container and get number of tracks of each PV
 
    for( const auto *vertex : *m_primaryVertices ) {
 
      // Hide (2015-04-21): xAOD::Vertex may contain several types of vertices
      // e.g. if VertexType==NoVtx, this is a dummy vertex.
      // We only need to extract primary vertices here, and skip otherwise.
 
      if( xAOD::VxType::PriVtx != vertex->vertexType() ) continue;
 
      // Not considering pile-up; pick-up the first PV
      m_thePV = vertex;
 
      if( m_FillNtuple ) {
 
        if( 0 == m_ntupleVars->get<unsigned int>( "NumPV" ) ) {
 
          m_ntupleVars->get<double>( "PVX" ) = vertex->x();
          m_ntupleVars->get<double>( "PVY" ) = vertex->y();
          m_ntupleVars->get<double>( "PVZ" ) = vertex->z();
          m_ntupleVars->get<unsigned int>( "PVType" ) = vertex->vertexType();
 
          // number of tracks associated to the PV
          m_ntupleVars->get<unsigned int>( "NTrksPV" ) = vertex->nTrackParticles();
        }
 
        m_ntupleVars->get<unsigned int>( "NumPV" )++;
 
        m_ntupleVars->get< vector<int> >   ( "NdofTrksPV" ) .emplace_back( vertex->numberDoF() );
        m_ntupleVars->get< vector<double> >( "PVZpile" )    .emplace_back( vertex->position().z() );
      }
 
      ATH_MSG_DEBUG("PrimVertex x/y/z/nDOF "
        << vertex->x() << ","
        << vertex->y() << ","
        << vertex->z() << ","
        << vertex->numberDoF()     );
 
    }
 
    // Use the dummy PV if no PV is composed
    if( !m_thePV ) {
      ATH_MSG_DEBUG("No Reconstructed PV was found. Using the dummy PV instead.");
      for( const auto *vertex : *m_primaryVertices ) {
  if( xAOD::VxType::NoVtx != vertex->vertexType() ) continue;
 
        if( m_FillNtuple ) {
          // Not considering pile-up; pick-up the first PV
          if( 0 == m_ntupleVars->get<unsigned int>( "NumPV" ) ) {
            m_thePV = vertex;
 
            m_ntupleVars->get<double>( "PVX" ) = vertex->x();
            m_ntupleVars->get<double>( "PVY" ) = vertex->y();
            m_ntupleVars->get<double>( "PVZ" ) = vertex->z();
            m_ntupleVars->get<unsigned int>( "PVType" ) = vertex->vertexType();
 
            // number of tracks associated to the PV
            m_ntupleVars->get<unsigned int>( "NTrksPV" ) = vertex->nTrackParticles();
          }
        }
      }
    }
 
    // if thePV is null, the PV is not found.
    if( !m_thePV ) {
      ATH_MSG_DEBUG("No PV is found in the PV collection!");
      return StatusCode::FAILURE;
    }
 
    ATH_MSG_DEBUG(" Primary vertex successful. thePV = " << m_thePV );
 
    return StatusCode::SUCCESS;
  }

rearrangeTracks()

StatusCode VKalVrtAthena::VrtSecInclusive::rearrangeTracks ( const EventContext & ctx, std::vector< WrkVrt > * workVerticesContainer )

private

Definition at line 758 of file VertexingAlgs.cxx.

  {
    if(m_doDisappearingTrackVertexing){
      ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": skip");
      return StatusCode::SUCCESS;
    }
    //
    //  Rearrangement of solutions
    //
 
    std::vector<long int> processedTracks;
 
    unsigned mergeCounter { 0 };
    unsigned brokenCounter { 0 };
    unsigned removeTrackCounter { 0 };
 
    while( true ) {
 
      // worstChi2: unit in [chi2 per track]
      long int maxSharedTrack;
      long int worstMatchingVertex;
      std::pair<unsigned, unsigned> indexPair { AlgConsts::invalidUnsigned, AlgConsts::invalidUnsigned };
 
 
      // trackToVertexMap has IDs of each track which can contain array of vertices.
      // e.g. TrkInVrt->at( track_id ).size() gives the number of vertices which use the track [track_id].
 
      std::map<long int, std::vector<long int> > trackToVertexMap;
 
      // Fill trackToVertexMap with vertex IDs of each track
      trackClassification( workVerticesContainer, trackToVertexMap );
 
 
      auto worstChi2 = findWorstChi2ofMaximallySharedTrack( workVerticesContainer, trackToVertexMap, maxSharedTrack, worstMatchingVertex );
 
      if( worstChi2 == AlgConsts::invalidFloat ) {
        ATH_MSG_DEBUG( " > " << __FUNCTION__ << ": no shared tracks are found --> exit the while loop." );
        break;
      }
 
      ATH_MSG_DEBUG( " > " << __FUNCTION__ << ": vertex [" << worstMatchingVertex << "]: maximally shared track index = " << maxSharedTrack
                     << ", multiplicity = "   << trackToVertexMap.at( maxSharedTrack ).size()
                     << ", worst chi2_trk = " << worstChi2 );
 
      //Choice of action
      if( worstChi2 < m_TrackDetachCut ) {
 
        // Here, the max-shared track is well-associated and cannot be detached.
        // The closest vertex should be merged.
 
        std::vector< std::pair<unsigned, unsigned> > badPairs;
 
        while( true ) {
 
          // find the closest vertices pair that share the track of interest
          double minSignificance { AlgConsts::maxValue };
          unsigned nShared { 0 };
 
          {
            auto& vrtList = trackToVertexMap.at( maxSharedTrack );
 
            auto nGood = std::count_if( vrtList.begin(), vrtList.end(), [&]( auto& v ) { return workVerticesContainer->at(v).isGood; } );
            ATH_MSG_VERBOSE( " > " << __FUNCTION__ << ": size of good vertices = " << nGood );
 
            std::vector< std::tuple< std::pair<unsigned, unsigned>, double, unsigned> > significanceTuple;
            enum { kIndexPair, kSignificance, kNshared };
 
            for( auto ivrt = vrtList.begin(); ivrt != vrtList.end(); ++ivrt ) {
              for( auto jvrt = std::next( ivrt ); jvrt != vrtList.end(); ++jvrt ) {
                auto pair = std::pair<unsigned, unsigned>( *ivrt, *jvrt );
 
                if( !( workVerticesContainer->at(*ivrt).isGood ) ) continue;
                if( !( workVerticesContainer->at(*jvrt).isGood ) ) continue;
 
                // skip known bad pairs
                if( std::find( badPairs.begin(), badPairs.end(), pair ) != badPairs.end() ) continue;
 
                auto signif = significanceBetweenVertices( workVerticesContainer->at( *ivrt ), workVerticesContainer->at( *jvrt ) );
 
                auto& ivrtTrks = workVerticesContainer->at(*ivrt).selectedTrackIndices;
                auto& jvrtTrks = workVerticesContainer->at(*jvrt).selectedTrackIndices;
 
                auto nSharedTracks = std::count_if( ivrtTrks.begin(), ivrtTrks.end(),
                                                    [&]( auto& index ) {
                                                      return std::find( jvrtTrks.begin(), jvrtTrks.end(), index ) != jvrtTrks.end();
                                                    } );
 
                significanceTuple.emplace_back( pair, signif, nSharedTracks );
              }
            }
 
            if( significanceTuple.empty() ) {
              ATH_MSG_DEBUG( " > " << __FUNCTION__ << ": no vertex pairs are found --> exit the while loop." );
              break;
            }
 
            auto minSignificanceTuple = std::min_element( significanceTuple.begin(), significanceTuple.end(), [&]( auto& t1, auto&t2 ) { return std::get<kSignificance>(t1) < std::get<kSignificance>(t2); } );
 
            indexPair       = std::get<kIndexPair>    ( *minSignificanceTuple );
            minSignificance = std::get<kSignificance> ( *minSignificanceTuple );
            nShared         = std::get<kNshared>      ( *minSignificanceTuple );
          }
 
          ATH_MSG_VERBOSE( " > " << __FUNCTION__ << ": minSignificance = " << minSignificance );
 
          if( minSignificance < m_VertexMergeCut || nShared >= 2 ) {
 
            ATH_MSG_VERBOSE( " > " << __FUNCTION__ << ": attempt to merge vertices " << indexPair.first << " and " << indexPair.second );
 
            WrkVrt vertex_backup1 = workVerticesContainer->at( indexPair.first );
            WrkVrt vertex_backup2 = workVerticesContainer->at( indexPair.second );
 
            StatusCode sc = mergeVertices( workVerticesContainer->at( indexPair.first ), workVerticesContainer->at( indexPair.second ) );
 
            if( m_FillHist ) { m_hists["mergeType"]->Fill( RECONSTRUCT_NTRK ); }
 
            if( sc.isFailure() ) {
              // revert to the original
              workVerticesContainer->at( indexPair.first  ) = vertex_backup1;
              workVerticesContainer->at( indexPair.second ) = vertex_backup2;
              badPairs.emplace_back( indexPair );
            }
 
            // The second vertex is merged to the first.
            // Explicity flag the second vertex is invalid.
            workVerticesContainer->at( indexPair.second ).isGood = false;
 
            // Now the vertex is merged and the bad pair record is outdated.
            badPairs.clear();
 
            mergeCounter++;
 
            ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": Merged vertices " << indexPair.first << " and " << indexPair.second << ". merged vertex multiplicity = " << workVerticesContainer->at( indexPair.first ).selectedTrackIndices.size() );
 
          } else {
 
            // Here, the significance between closest vertices sharing the track is sufficiently distant
            // and cannot be merged, while the track-association chi2 is small as well.
            // In order to resolve the ambiguity anyway, remove the track from the worst-associated vertex.
 
            auto& wrkvrt = workVerticesContainer->at( worstMatchingVertex );
 
            auto end = std::remove_if( wrkvrt.selectedTrackIndices.begin(), wrkvrt.selectedTrackIndices.end(), [&]( auto& index ) { return index == maxSharedTrack; } );
            wrkvrt.selectedTrackIndices.erase( end, wrkvrt.selectedTrackIndices.end() );
 
            removeTrackCounter++;
 
            ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": removed track " << maxSharedTrack << " from vertex " << worstMatchingVertex );
 
            if( wrkvrt.selectedTrackIndices.size() < 2 ) {
              wrkvrt.isGood = false;
              brokenCounter++;
              break;
            }
 
            StatusCode sc = refitVertex( wrkvrt );
            if( sc.isFailure() ) {
              ATH_MSG_WARNING(" > " << __FUNCTION__ << ": detected vertex fitting failure!" );
            }
 
            break;
 
          }
        }
 
      } else {
 
        // Here, a bad track association is detected
        // The track is detached from the worst-associated vertex and refit.
 
        auto& wrkvrt = workVerticesContainer->at( worstMatchingVertex );
 
        auto end = std::remove_if( wrkvrt.selectedTrackIndices.begin(), wrkvrt.selectedTrackIndices.end(), [&]( auto& index ) { return index == maxSharedTrack; } );
        wrkvrt.selectedTrackIndices.erase( end, wrkvrt.selectedTrackIndices.end() );
 
        if( wrkvrt.nTracksTotal() >=2 ) {
 
          auto wrkvrt_backup = wrkvrt;
          StatusCode sc = refitVertex( wrkvrt );
          if( sc.isFailure() ) {
            ATH_MSG_WARNING(" > " << __FUNCTION__ << ": detected vertex fitting failure!" );
            wrkvrt = wrkvrt_backup;
          }
 
        } else {
          wrkvrt.isGood = false;
          brokenCounter++;
        }
 
        removeTrackCounter++;
 
        ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": removed track " << maxSharedTrack << " from vertex " << worstMatchingVertex );
 
      }
 
    }
 
    //
    // Try to improve vertices with big Chi2
    for( auto& wrkvrt : *workVerticesContainer ) {
 
      if(!wrkvrt.isGood )                          continue;  //don't work on wrkvrt which is already bad
      if( wrkvrt.selectedTrackIndices.size() < 3 ) continue;
 
      WrkVrt backup = wrkvrt;
      improveVertexChi2( wrkvrt );
      if( wrkvrt.fitQuality() > backup.fitQuality() ) wrkvrt = backup;
 
      if( wrkvrt.nTracksTotal() < 2 ) wrkvrt.isGood = false;
 
    }
 
    if( m_FillNtuple ) {
      m_ntupleVars->get<unsigned int>( "NumRearrSecVrt" )=workVerticesContainer->size();
      ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": Size of Solution Set: "<< m_ntupleVars->get<unsigned int>( "NumRearrSecVrt" ));
    }
 
    ATH_MSG_DEBUG(" > " << __FUNCTION__ << "----------------------------------------------" );
    ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": Number of merges = " << mergeCounter << ", Number of track removal = " << removeTrackCounter << ", broken vertices = " << brokenCounter );
    ATH_MSG_DEBUG(" > " << __FUNCTION__ << "----------------------------------------------" );
 
    return StatusCode::SUCCESS;
  }

reassembleVertices()

StatusCode VKalVrtAthena::VrtSecInclusive::reassembleVertices ( const EventContext & ctx, std::vector< WrkVrt > * workVerticesContainer )

private

attempt to merge vertices when all tracks of a vertex A is close to vertex B in terms of impact parameter

Definition at line 985 of file VertexingAlgs.cxx.

  {
    // Here, the supposed issue is that, the position of the reconstructed vertex may be significantly
    // displaced from its truth position, even if the constituent tracks are all from that truth.
    // The fundamental reason of this is speculated that the VKalVrt vertex fitting could fall in
    // a local minimum. This function attempts to improve the situation, given that N-track vertices
    // are already reconstructed, by attempting to asociate a track of a small multiplicity vertex
    // to another large multiplicity vertex.
 
    unsigned reassembleCounter { 0 };
 
    // First, sort WrkVrt by the track multiplicity
    std::sort( workVerticesContainer->begin(), workVerticesContainer->end(), [](WrkVrt& v1, WrkVrt& v2) { return v1.selectedTrackIndices.size() < v2.selectedTrackIndices.size(); } );
 
    ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": #vertices = " << workVerticesContainer->size() );
    // Loop over vertices (small -> large Ntrk order)
    for( auto& wrkvrt : *workVerticesContainer ) {
      if( !wrkvrt.isGood               ) continue;
      if(  wrkvrt.selectedTrackIndices.size() <= 1 ) continue;
 
      ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": vertex " << &wrkvrt << " #tracks = " << wrkvrt.selectedTrackIndices.size() );
      ATH_MSG_DEBUG( " > " << __FUNCTION__ << ": candidate vertex: "
                     << " isGood  = "            << (wrkvrt.isGood? "true" : "false")
                     << ", #ntrks = "            << wrkvrt.nTracksTotal()
                     << ", #selectedTracks = "   << wrkvrt.selectedTrackIndices.size()
                     << ", #associatedTracks = " << wrkvrt.associatedTrackIndices.size()
                     << ", chi2/ndof = "         << wrkvrt.fitQuality()
                     << ", (r, z) = ("           << wrkvrt.vertex.perp()
                     <<", "                      << wrkvrt.vertex.z() << ")" );
 
      std::map<unsigned, std::vector<WrkVrt>::reverse_iterator> mergiableVertex;
      std::set<std::vector<WrkVrt>::reverse_iterator> mergiableVerticesSet;
 
      for( auto& index : wrkvrt.selectedTrackIndices ) {
 
        const xAOD::TrackParticle* trk = m_selectedTracks.at( index );
 
        mergiableVertex[index] = workVerticesContainer->rend();
 
        std::vector<double> distances;
 
        // Reverse iteration: large Ntrk -> small Ntrk order
        for( auto ritr = workVerticesContainer->rbegin(); ritr != workVerticesContainer->rend(); ++ritr ) {
          auto& targetVertex = *ritr;
 
          if( &wrkvrt == &targetVertex ) continue;
          if( wrkvrt.selectedTrackIndices.size() >= targetVertex.selectedTrackIndices.size() ) continue;
 
          // Get the closest approach
          std::vector<double> impactParameters;
          std::vector<double> impactParErrors;
 
          if( !getSVImpactParameters(trk,targetVertex.vertex,impactParameters,impactParErrors) ) continue;
 
          const auto& distance = hypot( impactParameters.at(0), impactParameters.at(1) );
          distances.emplace_back( distance );
 
          if( std::abs( impactParameters.at(0) ) > m_reassembleMaxImpactParameterD0 ) continue;
          if( std::abs( impactParameters.at(1) ) > m_reassembleMaxImpactParameterZ0 ) continue;
 
          mergiableVertex[index] = ritr;
          mergiableVerticesSet.emplace( ritr );
 
        }
 
        auto min_distance = !distances.empty() ? *(std::min_element( distances.begin(), distances.end() )) : AlgConsts::invalidFloat;
 
        if( mergiableVertex[index] == workVerticesContainer->rend() ) {
          ATH_MSG_VERBOSE(" > " << __FUNCTION__ << ": track " << trk << " --> none : min distance = " << min_distance );
        } else {
          ATH_MSG_VERBOSE(" > " << __FUNCTION__ << ": track " << trk << " --> " << &( *(mergiableVertex[index]) ) << " --> size = " << mergiableVertex[index]->selectedTrackIndices.size() << ": min distance = " << min_distance );
        }
 
      }
 
      size_t count_mergiable = std::count_if( mergiableVertex.begin(), mergiableVertex.end(),
                                              [&](const std::pair<unsigned, std::vector<WrkVrt>::reverse_iterator>& p ) {
                                                return p.second != workVerticesContainer->rend(); } );
 
      if( mergiableVerticesSet.size() == 1 && count_mergiable == wrkvrt.selectedTrackIndices.size() ) {
 
        ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": identified a unique association destination vertex" );
 
        WrkVrt& destination = *( mergiableVertex.begin()->second );
        ATH_MSG_VERBOSE(" > " << __FUNCTION__ << ": destination #tracks before merging = " << destination.selectedTrackIndices.size() );
 
        StatusCode sc = mergeVertices( destination, wrkvrt );
        if( sc.isFailure() ) {
          ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": failure in vertex merging" );
        }
 
        improveVertexChi2( destination );
 
        ATH_MSG_DEBUG( " > " << __FUNCTION__ << ": merged destination vertex: "
                       << " isGood  = "            << (destination.isGood? "true" : "false")
                       << ", #ntrks = "            << destination.nTracksTotal()
                       << ", #selectedTracks = "   << destination.selectedTrackIndices.size()
                       << ", #associatedTracks = " << destination.associatedTrackIndices.size()
                       << ", chi2/ndof = "         << destination.fitQuality()
                       << ", (r, z) = ("           << destination.vertex.perp()
                       <<", "                      << destination.vertex.z() << ")" );
 
        if( m_FillHist ) { m_hists["mergeType"]->Fill( REASSEMBLE ); }
 
        ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": destination #tracks after merging = " << destination.selectedTrackIndices.size() );
 
        reassembleCounter++;
 
      }
 
    }
 
    ATH_MSG_DEBUG(" > " << __FUNCTION__ << "----------------------------------------------" );
    ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": reassembled vertices = " << reassembleCounter );
    ATH_MSG_DEBUG(" > " << __FUNCTION__ << "----------------------------------------------" );
 
    return StatusCode::SUCCESS;
  }

refitAndSelectGoodQualityVertices()

StatusCode VKalVrtAthena::VrtSecInclusive::refitAndSelectGoodQualityVertices ( const EventContext & ctx, std::vector< WrkVrt > * workVerticesContainer )

private

finalization of the vertex and store to xAOD::VertexContainer

Definition at line 1524 of file VertexingAlgs.cxx.

  {
    // Output SVs as xAOD::Vertex
    // Needs a conversion function from workVerticesContainer to xAOD::Vertex here.
    // The supposed form of the function will be as follows:
 
    try {
      SG::WriteHandle<xAOD::VertexContainer> secVtxHandle = SG::makeHandle( m_vertexKey, ctx );
      ATH_CHECK( secVtxHandle.record( std::make_unique<xAOD::VertexContainer>(),
                      std::make_unique<xAOD::VertexAuxContainer>() ) );
      xAOD::VertexContainer *secondaryVertexContainer = secVtxHandle.ptr();
      m_vertexCollectionsDefinitions[m_vertexKey.key()] = true;
 
      enum { kPt, kEta, kPhi, kD0, kZ0, kErrP, kErrD0, kErrZ0, kChi2SV };
      if( m_trkDecors.empty() ) {
        m_trkDecors.emplace( kPt,     SG::AuxElement::Decorator<float>("pt_wrtSV"    + m_augVerString) );
        m_trkDecors.emplace( kEta,    SG::AuxElement::Decorator<float>("eta_wrtSV"   + m_augVerString) );
        m_trkDecors.emplace( kPhi,    SG::AuxElement::Decorator<float>("phi_wrtSV"   + m_augVerString) );
        m_trkDecors.emplace( kD0,     SG::AuxElement::Decorator<float>("d0_wrtSV"    + m_augVerString) );
        m_trkDecors.emplace( kZ0,     SG::AuxElement::Decorator<float>("z0_wrtSV"    + m_augVerString) );
        m_trkDecors.emplace( kErrP,   SG::AuxElement::Decorator<float>("errP_wrtSV"  + m_augVerString) );
        m_trkDecors.emplace( kErrD0,  SG::AuxElement::Decorator<float>("errd0_wrtSV" + m_augVerString) );
        m_trkDecors.emplace( kErrZ0,  SG::AuxElement::Decorator<float>("errz0_wrtSV" + m_augVerString) );
        m_trkDecors.emplace( kChi2SV, SG::AuxElement::Decorator<float>("chi2_toSV"   + m_augVerString) );
      }
      if( !m_decor_is_svtrk_final ) {
        m_decor_is_svtrk_final.emplace ( "is_svtrk_final" + m_augVerString );
      }
 
      std::map<const WrkVrt*, const xAOD::Vertex*> wrkvrtLinkMap;
 
      //----------------------------------------------------------
 
      ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": input #vertices = " << workVerticesContainer->size() );
 
      // Loop over vertices
      for( auto& wrkvrt : *workVerticesContainer ) {
 
        ATH_MSG_DEBUG( " > " << __FUNCTION__ << ": candidate vertex: "
                       << " isGood  = "            << (wrkvrt.isGood? "true" : "false")
                       << ", #ntrks = "            << wrkvrt.nTracksTotal()
                       << ", #selectedTracks = "   << wrkvrt.selectedTrackIndices.size()
                       << ", #associatedTracks = " << wrkvrt.associatedTrackIndices.size()
                       << ", chi2/ndof = "         << wrkvrt.Chi2 / ( wrkvrt.ndof() + AlgConsts::infinitesimal )
                       << ", (r, z) = ("           << wrkvrt.vertex.perp()
                       <<", "                      << wrkvrt.vertex.z() << ")" );
 
        if( m_FillHist ) m_hists["finalCutMonitor"]->Fill( 0 );
 
        if( m_removeFakeVrt && m_removeFakeVrtLate ) {
          removeInconsistentTracks( wrkvrt );
        }
 
        if( wrkvrt.nTracksTotal() < 2 ) {
          ATH_MSG_DEBUG( " > " << __FUNCTION__ << ": ntrk < 2  --> rejected." );
          continue;               /* Bad vertices */
        }
 
        if( m_FillHist ) m_hists["finalCutMonitor"]->Fill( 1 );
 
 
        // Remove track if the vertex is inner than IBL and the track does not have pixel hits!
        if( wrkvrt.vertex.perp() < 31.0 ) {
 
          // for selected tracks
          wrkvrt.selectedTrackIndices.erase( std::remove_if( wrkvrt.selectedTrackIndices.begin(), wrkvrt.selectedTrackIndices.end(),
                                                             [&]( auto& index ) {
                                                               auto* trk = m_selectedTracks.at( index );
                                                               uint8_t nPixelHits { 0 }; trk->summaryValue( nPixelHits,  xAOD::numberOfPixelHits );
                                                               return ( nPixelHits < 3 );
                                                             } ),
                                             wrkvrt.selectedTrackIndices.end() );
 
          // for associated tracks
          wrkvrt.associatedTrackIndices.erase( std::remove_if( wrkvrt.associatedTrackIndices.begin(), wrkvrt.associatedTrackIndices.end(),
                                                               [&]( auto& index ) {
                                                                 auto* trk = m_associatedTracks.at( index );
                                                                 uint8_t nPixelHits { 0 }; trk->summaryValue( nPixelHits,  xAOD::numberOfPixelHits );
                                                                 return ( nPixelHits < 3 );
                                                               } ),
                                               wrkvrt.associatedTrackIndices.end() );
 
          auto statusCode = refitVertex( wrkvrt );
          if( statusCode.isFailure() ) {}
 
        }
 
 
        if( m_doFinalImproveChi2 ) {
 
          WrkVrt backup = wrkvrt;
 
          improveVertexChi2( wrkvrt );
 
          if( wrkvrt.fitQuality() > backup.fitQuality() ) wrkvrt = backup;
 
        }
 
        // If the number of remaining tracks is less than 2, drop.
        if( wrkvrt.nTracksTotal() < 2 ) continue;
 
        // Select only vertices with keeping more than 2 selectedTracks
        if( wrkvrt.selectedTrackIndices.size() < 2 ) continue;
 
 
        if( m_FillHist ) m_hists["finalCutMonitor"]->Fill( 2 );
 
 
        {
          WrkVrt backup = wrkvrt;
 
          StatusCode sc = refitVertex( wrkvrt );
          if( sc.isFailure() ) {
 
            auto indices = wrkvrt.associatedTrackIndices;
 
            wrkvrt.associatedTrackIndices.clear();
            sc = refitVertex( wrkvrt );
            if( sc.isFailure() ) {
              ATH_MSG_WARNING(" > " << __FUNCTION__ << ": detected vertex fitting failure!" );
              wrkvrt = backup;
            }
            if( wrkvrt.fitQuality() > backup.fitQuality() ) wrkvrt = backup;
 
            for( auto& index : indices ) {
              backup = wrkvrt;
              wrkvrt.associatedTrackIndices.emplace_back( index );
              sc = refitVertex( wrkvrt );
              if( sc.isFailure() || TMath::Prob( wrkvrt.Chi2, wrkvrt.ndof() ) < m_improveChi2ProbThreshold ) {
                ATH_MSG_WARNING(" > " << __FUNCTION__ << ": detected vertex fitting failure!" );
                wrkvrt = backup;
                continue;
              }
            }
 
          } else {
            if( wrkvrt.fitQuality() > backup.fitQuality() ) wrkvrt = backup;
          }
        }
 
        if( m_FillHist ) m_hists["finalCutMonitor"]->Fill( 3 );
 
        //
        //  Store good vertices into StoreGate
        //
        if( m_FillNtuple ) m_ntupleVars->get<unsigned int>( "NumSecVrt" )++;
 
        TLorentzVector sumP4_pion;
        TLorentzVector sumP4_electron;
        TLorentzVector sumP4_proton;
 
        // Pre-check before storing vertex if the SV perigee is available
        bool good_flag = true;
 
        std::map<const std::deque<long int>*, const std::vector<const xAOD::TrackParticle*>&> indicesSet
          = {
          { &(wrkvrt.selectedTrackIndices),   m_selectedTracks   },
          { &(wrkvrt.associatedTrackIndices), m_associatedTracks }
        };
 
        for( auto& pair : indicesSet ) {
 
          const auto* indices = pair.first;
          const auto& tracks  = pair.second;
 
          for( const auto& itrk : *indices ) {
            const auto* trk = tracks.at( itrk );
            auto sv_perigee = m_trackToVertexTool->perigeeAtVertex(ctx, *trk, wrkvrt.vertex );
            if( !sv_perigee ) {
              ATH_MSG_INFO(" > " << __FUNCTION__ << ": > Track index " << trk->index() << ": Failed in obtaining the SV perigee!" );
              good_flag = false;
            }
          }
 
        }
 
        if( !good_flag ) {
          ATH_MSG_DEBUG( " > " << __FUNCTION__ << ": sv perigee could not be obtained --> rejected" );
          continue;
        }
 
        if( m_FillHist ) m_hists["finalCutMonitor"]->Fill( 4 );
 
 
        std::vector<const xAOD::TrackParticle*> tracks;
        std::vector< std::pair<const xAOD::TrackParticle*, double> > trackChi2Pairs;
 
        {
 
          for( auto& pair : indicesSet ) {
            for( const auto& index : *pair.first ) tracks.emplace_back( pair.second.at( index ) );
          }
 
          auto trkitr = tracks.begin();
          auto chi2itr = wrkvrt.Chi2PerTrk.begin();
 
          for( ; ( trkitr!=tracks.end() && chi2itr!=wrkvrt.Chi2PerTrk.end() ); ++trkitr, ++chi2itr ) {
            trackChi2Pairs.emplace_back( *trkitr, *chi2itr );
          }
 
        }
 
 
        TLorentzVector sumP4_selected;
 
        bool badIPflag { false };
 
        // loop over vertex tracks
        ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": Track loop: size = " << tracks.size() );
        for( auto& pair : trackChi2Pairs ) {
 
          const auto* trk      = pair.first;
          const auto& chi2AtSV = pair.second;
 
          ATH_MSG_VERBOSE(" > " << __FUNCTION__ << ": > Track index " << trk->index() << ": start." );
 
          track_summary trk_summary;
          fillTrackSummary( trk_summary, trk );
 
          //
          // calculate mass/pT of tracks and track parameters
          //
 
          double trk_pt  = trk->pt();
          double trk_eta = trk->eta();
          double trk_phi = trk->phi();
 
          ATH_MSG_VERBOSE(" > " << __FUNCTION__ << ": > Track index " << trk->index() << ": in vrt chg/pt/phi/eta = "
                          << trk->charge() <<","
                          <<trk_pt<<","
                          <<trk_phi<<","
                          <<trk_eta);

          // Get the perigee of the track at the vertex
          ATH_MSG_VERBOSE(" > " << __FUNCTION__ << ": > Track index " << trk->index() << ": Get the prigee of the track at the vertex." );
 
          auto sv_perigee = m_trackToVertexTool->perigeeAtVertex(ctx, *trk, wrkvrt.vertex );
          if( !sv_perigee ) {
            ATH_MSG_WARNING(" > " << __FUNCTION__ << ": > Track index " << trk->index() << ": Failed in obtaining the SV perigee!" );
 
            for( auto& pair : m_trkDecors ) {
              pair.second( *trk ) = AlgConsts::invalidFloat;
            }
            (*m_decor_is_svtrk_final)( *trk ) = true;
            continue;
          }
 
          double qOverP_wrtSV    = sv_perigee->parameters() [Trk::qOverP];
          double theta_wrtSV     = sv_perigee->parameters() [Trk::theta];
          double p_wrtSV         = 1.0 / std::abs( qOverP_wrtSV );
          double pt_wrtSV        = p_wrtSV * sin( theta_wrtSV );
          double eta_wrtSV       = -log( tan( theta_wrtSV/2. ) );
          double phi_wrtSV       = sv_perigee->parameters() [Trk::phi];
          double d0_wrtSV        = sv_perigee->parameters() [Trk::d0];
          double z0_wrtSV        = sv_perigee->parameters() [Trk::z0];
          double errd0_wrtSV     = (*sv_perigee->covariance())( Trk::d0, Trk::d0 );
          double errz0_wrtSV     = (*sv_perigee->covariance())( Trk::z0, Trk::z0 );
          double errP_wrtSV      = (*sv_perigee->covariance())( Trk::qOverP, Trk::qOverP );
 
          // xAOD::Track augmentation
          ( m_trkDecors.at(kPt)    )( *trk ) = pt_wrtSV;
          ( m_trkDecors.at(kEta)   )( *trk ) = eta_wrtSV;
          ( m_trkDecors.at(kPhi)   )( *trk ) = phi_wrtSV;
          ( m_trkDecors.at(kD0)    )( *trk ) = d0_wrtSV;
          ( m_trkDecors.at(kZ0)    )( *trk ) = z0_wrtSV;
          ( m_trkDecors.at(kErrP)  )( *trk ) = errP_wrtSV;
          ( m_trkDecors.at(kErrD0) )( *trk ) = errd0_wrtSV;
          ( m_trkDecors.at(kErrZ0) )( *trk ) = errz0_wrtSV;
          ( m_trkDecors.at(kChi2SV))( *trk ) = chi2AtSV;
 
          (*m_decor_is_svtrk_final)( *trk ) = true;
 
          TLorentzVector p4wrtSV_pion;
          TLorentzVector p4wrtSV_electron;
          TLorentzVector p4wrtSV_proton;
 
          p4wrtSV_pion    .SetPtEtaPhiM( pt_wrtSV, eta_wrtSV, phi_wrtSV, PhysConsts::mass_chargedPion );
          p4wrtSV_electron.SetPtEtaPhiM( pt_wrtSV, eta_wrtSV, phi_wrtSV, PhysConsts::mass_electron    );
 
          // for selected tracks only
          static const SG::ConstAccessor<char> is_associatedAcc("is_associated" + m_augVerString);
          if( is_associatedAcc.isAvailable(*trk) ) {
            if( !is_associatedAcc(*trk) ) {
              sumP4_selected += p4wrtSV_pion;
            }
          } else {
            sumP4_selected += p4wrtSV_pion;
          }
 
          sumP4_pion     += p4wrtSV_pion;
          sumP4_electron += p4wrtSV_electron;
          sumP4_proton   += p4wrtSV_proton;
 
          ATH_MSG_VERBOSE(" > " << __FUNCTION__ << ": > Track index " << trk->index() << ": end." );
        } // loop over tracks in vertex
 
        ATH_MSG_VERBOSE(" > " << __FUNCTION__ << ": Track loop end. ");
 
        ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": Final Sec.Vertex=" << wrkvrt.nTracksTotal() <<", "
                      <<wrkvrt.vertex.perp() <<", "<<wrkvrt.vertex.z() <<", "
                      <<wrkvrt.vertex.phi() <<", mass = "<< sumP4_pion.M() << "," << sumP4_electron.M() );
 
        // Save the perigee parameters for the first two tracks
        float perigee_x_trk1 = 0.0;
        float perigee_y_trk1 = 0.0;
        float perigee_z_trk1 = 0.0;
        float perigee_x_trk2 = 0.0;
        float perigee_y_trk2 = 0.0;
        float perigee_z_trk2 = 0.0;
        float perigee_px_trk1 = 0.0;
        float perigee_py_trk1 = 0.0;
        float perigee_pz_trk1 = 0.0;
        float perigee_px_trk2 = 0.0;
        float perigee_py_trk2 = 0.0;
        float perigee_pz_trk2 = 0.0;
        float perigee_cov_xx_trk1 = 0.0;
        float perigee_cov_xy_trk1 = 0.0;
        float perigee_cov_xz_trk1 = 0.0;
        float perigee_cov_yy_trk1 = 0.0;
        float perigee_cov_yz_trk1 = 0.0;
        float perigee_cov_zz_trk1 = 0.0;
        float perigee_cov_xx_trk2 = 0.0;
        float perigee_cov_xy_trk2 = 0.0;
        float perigee_cov_xz_trk2 = 0.0;
        float perigee_cov_yy_trk2 = 0.0;
        float perigee_cov_yz_trk2 = 0.0;
        float perigee_cov_zz_trk2 = 0.0;
        float perigee_d0_trk1 = 0.0;
        float perigee_d0_trk2 = 0.0;
        float perigee_z0_trk1 = 0.0;
        float perigee_z0_trk2 = 0.0;
        float perigee_qOverP_trk1 = 0.0;
        float perigee_qOverP_trk2 = 0.0;
        float perigee_theta_trk1 = 0.0;
        float perigee_theta_trk2 = 0.0;
        float perigee_phi_trk1 = 0.0;
        float perigee_phi_trk2 = 0.0;
        int perigee_charge_trk1 = 0;
        int perigee_charge_trk2 = 0;
        float perigee_distance = 9999.0;
 
        Amg::Vector3D vDist = wrkvrt.vertex - m_thePV->position();
        float vPos = (vDist.x() * wrkvrt.vertexMom.Px() + vDist.y() * wrkvrt.vertexMom.Py() + vDist.z() * wrkvrt.vertexMom.Pz()) / wrkvrt.vertexMom.Rho();
        float vPosMomAngT = (vDist.x() * wrkvrt.vertexMom.Px() + vDist.y() * wrkvrt.vertexMom.Py()) / vDist.perp() / wrkvrt.vertexMom.Pt();
        float vPosMomAng3D = (vDist.x() * wrkvrt.vertexMom.Px() + vDist.y() * wrkvrt.vertexMom.Py() + vDist.z() * wrkvrt.vertexMom.Pz()) / (vDist.norm() * wrkvrt.vertexMom.Rho());
        float dphi_trk1 = 0.0;
        float dphi_trk2 = 0.0;
 
        if (m_doDisappearingTrackVertexing){
          // Process track1
          const auto* track1 = trackChi2Pairs[0].first;
          dphi_trk1 = TVector2::Phi_mpi_pi(vDist.phi() - track1->phi());
          auto sv_perigee1 = m_trackToVertexTool->perigeeAtVertex(ctx, *track1, wrkvrt.vertex);
          if (sv_perigee1) {
            perigee_x_trk1 = sv_perigee1->position().x();
            perigee_y_trk1 = sv_perigee1->position().y();
            perigee_z_trk1 = sv_perigee1->position().z();
            perigee_px_trk1 = sv_perigee1->momentum().x();
            perigee_py_trk1 = sv_perigee1->momentum().y();
            perigee_pz_trk1 = sv_perigee1->momentum().z();
            perigee_cov_xx_trk1 = (*sv_perigee1->covariance())(0, 0);
            perigee_cov_xy_trk1 = (*sv_perigee1->covariance())(0, 1);
            perigee_cov_xz_trk1 = (*sv_perigee1->covariance())(0, 2);
            perigee_cov_yy_trk1 = (*sv_perigee1->covariance())(1, 1);
            perigee_cov_yz_trk1 = (*sv_perigee1->covariance())(1, 2);
            perigee_cov_zz_trk1 = (*sv_perigee1->covariance())(2, 2);
            perigee_d0_trk1 = sv_perigee1->parameters()[Trk::d0];
            perigee_z0_trk1 = sv_perigee1->parameters()[Trk::z0];
            perigee_qOverP_trk1 = sv_perigee1->parameters()[Trk::qOverP];
            perigee_theta_trk1 = sv_perigee1->parameters()[Trk::theta];
            perigee_phi_trk1 = sv_perigee1->parameters()[Trk::phi];
            perigee_charge_trk1 = sv_perigee1->parameters()[Trk::qOverP] > 0 ? 1 : -1;
          }else{
            ATH_MSG_DEBUG("Failed to obtain perigee for track1 at vertex.");
          }
 
          //Process track2
          const auto* track2 = trackChi2Pairs[1].first;
          dphi_trk2 = TVector2::Phi_mpi_pi(vDist.phi() - track2->phi());
          auto sv_perigee2 = m_trackToVertexTool->perigeeAtVertex(ctx, *track2, wrkvrt.vertex);
          if (sv_perigee2) {
            perigee_x_trk2 = sv_perigee2->position().x();
            perigee_y_trk2 = sv_perigee2->position().y();
            perigee_z_trk2 = sv_perigee2->position().z();
            perigee_px_trk2 = sv_perigee2->momentum().x();
            perigee_py_trk2 = sv_perigee2->momentum().y();
            perigee_pz_trk2 = sv_perigee2->momentum().z();
            perigee_cov_xx_trk2 = (*sv_perigee2->covariance())(0, 0);
            perigee_cov_xy_trk2 = (*sv_perigee2->covariance())(0, 1);
            perigee_cov_xz_trk2 = (*sv_perigee2->covariance())(0, 2);
            perigee_cov_yy_trk2 = (*sv_perigee2->covariance())(1, 1);
            perigee_cov_yz_trk2 = (*sv_perigee2->covariance())(1, 2);
            perigee_cov_zz_trk2 = (*sv_perigee2->covariance())(2, 2);
            perigee_d0_trk2 = sv_perigee2->parameters()[Trk::d0];
            perigee_z0_trk2 = sv_perigee2->parameters()[Trk::z0];
            perigee_qOverP_trk2 = sv_perigee2->parameters()[Trk::qOverP];
            perigee_theta_trk2 = sv_perigee2->parameters()[Trk::theta];
            perigee_phi_trk2 = sv_perigee2->parameters()[Trk::phi];
            perigee_charge_trk2 = sv_perigee2->parameters()[Trk::qOverP] > 0 ? 1 : -1;
          }else{
            ATH_MSG_DEBUG("Failed to obtain perigee for track2 at vertex.");
          }
 
          if(sv_perigee1 && sv_perigee2){
            perigee_distance = sqrt(
                                    (perigee_x_trk1 - perigee_x_trk2) * (perigee_x_trk1 - perigee_x_trk2) +
                                    (perigee_y_trk1 - perigee_y_trk2) * (perigee_y_trk1 - perigee_y_trk2) +
                                    (perigee_z_trk1 - perigee_z_trk2) * (perigee_z_trk1 - perigee_z_trk2)
                                    );
          }
          if(perigee_distance > m_twoTrVrtMaxPerigeeDist) continue;
        }
 
        //
        // calculate opening angle between all 2-track pairs, and store the minimum
        //
        double minOpAng = AlgConsts::invalidFloat;
        std::vector<double> opAngles;
 
        for( auto itr1 = tracks.begin(); itr1 != tracks.end(); ++itr1 ) {
          for( auto itr2 = std::next( itr1 ); itr2 != tracks.end(); ++itr2 ) {
            const auto& p1 = (*itr1)->p4().Vect();
            const auto& p2 = (*itr2)->p4().Vect();
            auto cos = p1 * p2 / p1.Mag() / p2.Mag();
            opAngles.emplace_back( cos );
          }
        }
        minOpAng = *( std::max_element( opAngles.begin(), opAngles.end() ) );
        if( m_FillNtuple ) m_ntupleVars->get< vector<double> >( "SecVtx_MinOpAng" ).emplace_back(minOpAng);
 
 
        if( m_FillHist ) m_hists["finalCutMonitor"]->Fill( 5 );
 
        if( badIPflag ) {
          ATH_MSG_DEBUG(" > " << __FUNCTION__ << ": Bad impact parameter signif wrt SV was flagged." );
        }
 
        if (m_doRemoveNonLeptonVertices) {
 
          bool oneLepMatchTrack = false;
          for (const auto *trk: tracks) {
            if ( std::find(m_leptonicTracks.begin(), m_leptonicTracks.end(), trk) != m_leptonicTracks.end() ) {
              oneLepMatchTrack = true;
              break;
            }
          }
 
          // If there are no tracks matched to leptons, do not save the container to the output.
          if (!oneLepMatchTrack) continue;
        }

        // Data filling to xAOD container
 
        wrkvrt.isGood = true;
 
        // Firstly store the new vertex to the container before filling properties.
        // (This is the feature of xAOD.)
        xAOD::Vertex* vertex = new xAOD::Vertex;
        secondaryVertexContainer->emplace_back( vertex );
 
        // Registering the vertex position to xAOD::Vertex
        vertex->setPosition( wrkvrt.vertex );
 
        // Registering the vertex type: SV
        vertex->setVertexType( xAOD::VxType::SecVtx );
 
        // Registering the vertex chi2 and Ndof
        // Here, we register the core chi2 of the core (before track association)
        vertex->setFitQuality( wrkvrt.Chi2_core, wrkvrt.ndof_core() );
 
        // Registering the vertex covariance matrix
        std::vector<float> fCov(wrkvrt.vertexCov.cbegin(), wrkvrt.vertexCov.cend());
        vertex->setCovariance(fCov);
 
        // Registering the vertex momentum and charge
        static const SG::Accessor<float> vtx_pxAcc("vtx_px");
        static const SG::Accessor<float> vtx_pyAcc("vtx_py");
        static const SG::Accessor<float> vtx_pzAcc("vtx_pz");
        static const SG::Accessor<float> vtx_massAcc("vtx_mass");
        static const SG::Accessor<float> vtx_chargeAcc("vtx_charge");
        static const SG::Accessor<float> chi2_coreAcc("chi2_core");
        static const SG::Accessor<float> ndof_coreAcc("ndof_core");
        static const SG::Accessor<float> chi2_assocAcc("chi2_assoc");
        static const SG::Accessor<float> ndof_assocAcc("ndof_assoc");
        static const SG::Accessor<float> massAcc("mass");
        static const SG::Accessor<float> mass_eAcc("mass_e");
        static const SG::Accessor<float> mass_selectedTracksAcc("mass_selectedTracks");
        static const SG::Accessor<float> minOpAngAcc("minOpAng");
        static const SG::Accessor<int> num_trksAcc("num_trks");
        static const SG::Accessor<int> num_selectedTracksAcc("num_selectedTracks");
        static const SG::Accessor<int> num_associatedTracksAcc("num_associatedTracks");
        static const SG::Accessor<float> dCloseVrtAcc("dCloseVrt");
 
        vtx_pxAcc(*vertex)                   = wrkvrt.vertexMom.Px();
        vtx_pyAcc(*vertex)                   = wrkvrt.vertexMom.Py();
        vtx_pzAcc(*vertex)                   = wrkvrt.vertexMom.Pz();
 
        vtx_massAcc(*vertex)                 = wrkvrt.vertexMom.M();
        vtx_chargeAcc(*vertex)               = wrkvrt.Charge;
 
        chi2_coreAcc(*vertex)                = wrkvrt.Chi2_core;
        ndof_coreAcc(*vertex)                = wrkvrt.ndof_core();
        chi2_assocAcc(*vertex)               = wrkvrt.Chi2;
        ndof_assocAcc(*vertex)               = wrkvrt.ndof();
        // Other SV properties
        massAcc(*vertex)                    = sumP4_pion.M();
        mass_eAcc(*vertex)                  = sumP4_electron.M();
        mass_selectedTracksAcc(*vertex)     = sumP4_selected.M();
        minOpAngAcc(*vertex)                = minOpAng;
        num_trksAcc(*vertex)                = wrkvrt.nTracksTotal();
        num_selectedTracksAcc(*vertex)      = wrkvrt.selectedTrackIndices.size();
        num_associatedTracksAcc(*vertex)    = wrkvrt.associatedTrackIndices.size();
        dCloseVrtAcc(*vertex)               = wrkvrt.closestWrkVrtValue;
 
        // Registering the vertex momentum and charge
        if (m_doDisappearingTrackVertexing){
          static const SG::Accessor<float> perigee_x_trk1Acc("perigee_x_trk1");
          static const SG::Accessor<float> perigee_y_trk1Acc("perigee_y_trk1");
          static const SG::Accessor<float> perigee_z_trk1Acc("perigee_z_trk1");
          static const SG::Accessor<float> perigee_x_trk2Acc("perigee_x_trk2");
          static const SG::Accessor<float> perigee_y_trk2Acc("perigee_y_trk2");
          static const SG::Accessor<float> perigee_z_trk2Acc("perigee_z_trk2");
          static const SG::Accessor<float> perigee_px_trk1Acc("perigee_px_trk1");
          static const SG::Accessor<float> perigee_py_trk1Acc("perigee_py_trk1");
          static const SG::Accessor<float> perigee_pz_trk1Acc("perigee_pz_trk1");
          static const SG::Accessor<float> perigee_px_trk2Acc("perigee_px_trk2");
          static const SG::Accessor<float> perigee_py_trk2Acc("perigee_py_trk2");
          static const SG::Accessor<float> perigee_pz_trk2Acc("perigee_pz_trk2");
          static const SG::Accessor<float> perigee_cov_xx_trk1Acc("perigee_cov_xx_trk1");
          static const SG::Accessor<float> perigee_cov_xy_trk1Acc("perigee_cov_xy_trk1");
          static const SG::Accessor<float> perigee_cov_xz_trk1Acc("perigee_cov_xz_trk1");
          static const SG::Accessor<float> perigee_cov_yy_trk1Acc("perigee_cov_yy_trk1");
          static const SG::Accessor<float> perigee_cov_yz_trk1Acc("perigee_cov_yz_trk1");
          static const SG::Accessor<float> perigee_cov_zz_trk1Acc("perigee_cov_zz_trk1");
          static const SG::Accessor<float> perigee_cov_xx_trk2Acc("perigee_cov_xx_trk2");
          static const SG::Accessor<float> perigee_cov_xy_trk2Acc("perigee_cov_xy_trk2");
          static const SG::Accessor<float> perigee_cov_xz_trk2Acc("perigee_cov_xz_trk2");
          static const SG::Accessor<float> perigee_cov_yy_trk2Acc("perigee_cov_yy_trk2");
          static const SG::Accessor<float> perigee_cov_yz_trk2Acc("perigee_cov_yz_trk2");
          static const SG::Accessor<float> perigee_cov_zz_trk2Acc("perigee_cov_zz_trk2");
          static const SG::Accessor<float> perigee_d0_trk1Acc("perigee_d0_trk1");
          static const SG::Accessor<float> perigee_d0_trk2Acc("perigee_d0_trk2");
          static const SG::Accessor<float> perigee_z0_trk1Acc("perigee_z0_trk1");
          static const SG::Accessor<float> perigee_z0_trk2Acc("perigee_z0_trk2");
          static const SG::Accessor<float> perigee_qOverP_trk1Acc("perigee_qOverP_trk1");
          static const SG::Accessor<float> perigee_qOverP_trk2Acc("perigee_qOverP_trk2");
          static const SG::Accessor<float> perigee_theta_trk1Acc("perigee_theta_trk1");
          static const SG::Accessor<float> perigee_theta_trk2Acc("perigee_theta_trk2");
          static const SG::Accessor<float> perigee_phi_trk1Acc("perigee_phi_trk1");
          static const SG::Accessor<float> perigee_phi_trk2Acc("perigee_phi_trk2");
          static const SG::Accessor<int> perigee_charge_trk1Acc("perigee_charge_trk1");
          static const SG::Accessor<int> perigee_charge_trk2Acc("perigee_charge_trk2");
          static const SG::Accessor<float> vPosAcc("vPos");
          static const SG::Accessor<float> vPosMomAngTAcc("vPosMomAngT");
          static const SG::Accessor<float> vPosMomAng3DAcc("vPosMomAng3D");
          static const SG::Accessor<float> dphi_trk1Acc("dphi_trk1");
          static const SG::Accessor<float> dphi_trk2Acc("dphi_trk2");
          perigee_x_trk1Acc(*vertex) = perigee_x_trk1;
          perigee_y_trk1Acc(*vertex) = perigee_y_trk1;
          perigee_z_trk1Acc(*vertex) = perigee_z_trk1;
          perigee_x_trk2Acc(*vertex) = perigee_x_trk2;
          perigee_y_trk2Acc(*vertex) = perigee_y_trk2;
          perigee_z_trk2Acc(*vertex) = perigee_z_trk2;
          perigee_px_trk1Acc(*vertex) = perigee_px_trk1;
          perigee_py_trk1Acc(*vertex) = perigee_py_trk1;
          perigee_pz_trk1Acc(*vertex) = perigee_pz_trk1;
          perigee_px_trk2Acc(*vertex) = perigee_px_trk2;
          perigee_py_trk2Acc(*vertex) = perigee_py_trk2;
          perigee_pz_trk2Acc(*vertex) = perigee_pz_trk2;
          perigee_cov_xx_trk1Acc(*vertex) = perigee_cov_xx_trk1;
          perigee_cov_xy_trk1Acc(*vertex) = perigee_cov_xy_trk1;
          perigee_cov_xz_trk1Acc(*vertex) = perigee_cov_xz_trk1;
          perigee_cov_yy_trk1Acc(*vertex) = perigee_cov_yy_trk1;
          perigee_cov_yz_trk1Acc(*vertex) = perigee_cov_yz_trk1;
          perigee_cov_zz_trk1Acc(*vertex) = perigee_cov_zz_trk1;
          perigee_cov_xx_trk2Acc(*vertex) = perigee_cov_xx_trk2;
          perigee_cov_xy_trk2Acc(*vertex) = perigee_cov_xy_trk2;
          perigee_cov_xz_trk2Acc(*vertex) = perigee_cov_xz_trk2;
          perigee_cov_yy_trk2Acc(*vertex) = perigee_cov_yy_trk2;
          perigee_cov_yz_trk2Acc(*vertex) = perigee_cov_yz_trk2;
          perigee_cov_zz_trk2Acc(*vertex) = perigee_cov_zz_trk2;
          perigee_d0_trk1Acc(*vertex) = perigee_d0_trk1;
          perigee_d0_trk2Acc(*vertex) = perigee_d0_trk2;
          perigee_z0_trk1Acc(*vertex) = perigee_z0_trk1;
          perigee_z0_trk2Acc(*vertex) = perigee_z0_trk2;
          perigee_qOverP_trk1Acc(*vertex) = perigee_qOverP_trk1;
          perigee_qOverP_trk2Acc(*vertex) = perigee_qOverP_trk2;
          perigee_theta_trk1Acc(*vertex) = perigee_theta_trk1;
          perigee_theta_trk2Acc(*vertex) = perigee_theta_trk2;
          perigee_phi_trk1Acc(*vertex) = perigee_phi_trk1;
          perigee_phi_trk2Acc(*vertex) = perigee_phi_trk2;
          perigee_charge_trk1Acc(*vertex) = perigee_charge_trk1;
          perigee_charge_trk2Acc(*vertex) = perigee_charge_trk2;
          vPosAcc(*vertex) = vPos;
          vPosMomAngTAcc(*vertex) = vPosMomAngT;
          vPosMomAng3DAcc(*vertex) = vPosMomAng3D;
          dphi_trk1Acc(*vertex) = dphi_trk1;
          dphi_trk2Acc(*vertex) = dphi_trk2;
        }
 
        // Registering tracks comprising the vertex to xAOD::Vertex
        // loop over the tracks comprising the vertex
        for( auto trk_id : wrkvrt.selectedTrackIndices ) {
 
          const xAOD::TrackParticle *trk = m_selectedTracks.at( trk_id );
 
          // Acquire link the track to the vertex
          ElementLink<xAOD::TrackParticleContainer> link_trk( *( dynamic_cast<const xAOD::TrackParticleContainer*>( trk->container() ) ), static_cast<long unsigned int>(trk->index()) );
 
          // Register the link to the vertex
          vertex->addTrackAtVertex( link_trk, 1. );
 
        }
 
        for( auto trk_id : wrkvrt.associatedTrackIndices ) {
 
          const xAOD::TrackParticle *trk = m_associatedTracks.at( trk_id );
 
          // Acquire link the track to the vertex
          ElementLink<xAOD::TrackParticleContainer> link_trk( *( dynamic_cast<const xAOD::TrackParticleContainer*>( trk->container() ) ), static_cast<long unsigned int>(trk->index()) );
 
          // Register the link to the vertex
          vertex->addTrackAtVertex( link_trk, 1. );
 
        }
 
 
        if( m_doMapToLocal ) {
          // Obtain the local mapping of the reconstructed vertex
          Trk::MappedVertex mappedVtx = m_vertexMapper->mapToLocal( wrkvrt.vertex );
          static const SG::Accessor<int> local_identifierHashAcc("local_identifierHash");
          static const SG::Accessor<int> local_layerIndexAcc("local_layerIndex");
          static const SG::Accessor<float> local_posXAcc("local_posX");
          static const SG::Accessor<float> local_posYAcc("local_posY");
          static const SG::Accessor<float> local_posZAcc("local_posZ");
          if( mappedVtx.valid ) {
            local_identifierHashAcc(*vertex) = mappedVtx.identifierHash;
            local_layerIndexAcc(*vertex)     = mappedVtx.layerIndex;
            local_posXAcc(*vertex)           = mappedVtx.localPosition.x();
            local_posYAcc(*vertex)           = mappedVtx.localPosition.y();
            local_posZAcc(*vertex)           = mappedVtx.localPosition.z();
          } else {
            local_identifierHashAcc(*vertex) = AlgConsts::invalidInt;
            local_layerIndexAcc(*vertex)     = AlgConsts::invalidInt;
            local_posXAcc(*vertex)           = AlgConsts::invalidFloat;
            local_posYAcc(*vertex)           = AlgConsts::invalidFloat;
            local_posZAcc(*vertex)           = AlgConsts::invalidFloat;
          }
        }
 
 
        // For MC, try to trace down to the truth particles,
        // and depending on the topology, categorize the label of the reconstructed vertex.
        if( m_doTruth ) {
          ATH_CHECK( categorizeVertexTruthTopology( vertex ) );
        }
 
        // Keep the link between wrkvrt and vertex for later use
        wrkvrtLinkMap[&wrkvrt] = vertex;
 
 
      } // loop over vertices
 
      if( m_FillNtuple ) {
        ATH_CHECK( fillAANT_SecondaryVertices( secondaryVertexContainer ) );
      }
 
 
      // Post process -- Additional augmentations
      if( m_doAugmentDVimpactParametersToMuons     ) { ATH_CHECK( augmentDVimpactParametersToLeptons<xAOD::Muon>    ( "Muons"     ) ); }
      if( m_doAugmentDVimpactParametersToElectrons ) { ATH_CHECK( augmentDVimpactParametersToLeptons<xAOD::Electron>( "Electrons" ) ); }
 
    } catch (const std::out_of_range& e) {
 
      ATH_MSG_WARNING( " > " << __FUNCTION__ << ": out of range error is detected: " << e.what()  );
 
      return StatusCode::SUCCESS;
 
    } catch( ... ) {
 
      ATH_MSG_WARNING( " > " << __FUNCTION__ << ": some other error is detected."  );
 
      return StatusCode::SUCCESS;
 
    }
 
    return StatusCode::SUCCESS;
  }

refitVertex() [1/2]

StatusCode VKalVrtAthena::VrtSecInclusive::refitVertex ( WrkVrt & workVertex )

private

refit the vertex.

Definition at line 496 of file Reconstruction/VKalVrt/VrtSecInclusive/src/Utilities.cxx.

  {
    std::unique_ptr<Trk::IVKalState> state = m_fitSvc->makeState();
    return refitVertex (workVertex, *state);
  }

refitVertex() [2/2]

StatusCode VKalVrtAthena::VrtSecInclusive::refitVertex ( WrkVrt & workVertex, Trk::IVKalState & istate )

private

Definition at line 505 of file Reconstruction/VKalVrt/VrtSecInclusive/src/Utilities.cxx.

  {
 
    //
    vector<const xAOD::NeutralParticle*> dummyNeutrals;
 
    int nth = workVertex.selectedTrackIndices.size();
 
    if(nth<2) {
      workVertex.isGood = false;
      return StatusCode::SUCCESS;
    }
 
    vector<const xAOD::TrackParticle*>  ListBaseTracks;
 
    workVertex.Chi2PerTrk.clear();
 
    for( const auto& index : workVertex.selectedTrackIndices ) {
      ListBaseTracks.emplace_back( m_selectedTracks.at( index ) );
      workVertex.Chi2PerTrk.emplace_back( AlgConsts::chi2PerTrackInitValue );
    }
 
    for( const auto& index : workVertex.associatedTrackIndices ) {
      ListBaseTracks.emplace_back( m_associatedTracks.at( index ) );
      workVertex.Chi2PerTrk.emplace_back( AlgConsts::chi2PerTrackInitValue );
    }
 
    auto& vertexPos = workVertex.vertex;
 
    m_fitSvc->setApproximateVertex( vertexPos.x(), vertexPos.y(), vertexPos.z(), istate );
 
    ATH_MSG_VERBOSE( " >>> refitVertex: ListBaseTracks.size = " << ListBaseTracks.size()
                   << ", #selectedBaseTracks = " << workVertex.selectedTrackIndices.size()
                   << ", #assocTracks = " << workVertex.associatedTrackIndices.size() );
    for( const auto *trk : ListBaseTracks ) {
      ATH_MSG_VERBOSE( " >>> refitVertex: track index = " << trk->index() );
    }
 
    ATH_MSG_VERBOSE( " >>> refitVertex: m_fitSvc is reset." );
 
    Amg::Vector3D initVertex;
 
    StatusCode sc = m_fitSvc->VKalVrtFitFast( ListBaseTracks, initVertex, istate );/* Fast crude estimation */
    if(sc.isFailure()) ATH_MSG_DEBUG(" >>> refitVertex: fast crude estimation failed.");
    ATH_MSG_VERBOSE( " >>> refitVertex: Fast VKalVrtFit succeeded. vertex (r,z) = (" << initVertex.perp() << ", " << initVertex.z() << ", " << ")" );
 
    if( vtxVtxDistance( initVertex, vertexPos ) > 10. ) {
 
      m_fitSvc->setApproximateVertex( vertexPos.x(), vertexPos.y(), vertexPos.z(), istate );
 
    } else {
 
      m_fitSvc->setApproximateVertex( initVertex.x(), initVertex.y(), initVertex.z(), istate );
 
    }
 
    ATH_MSG_VERBOSE( " >>> refitVertex: approx vertex is set. Now going to perform fitting..." );
 
    StatusCode SC=m_fitSvc->VKalVrtFit(ListBaseTracks,dummyNeutrals,
               workVertex.vertex,
               workVertex.vertexMom,
               workVertex.Charge,
               workVertex.vertexCov,
               workVertex.Chi2PerTrk,
               workVertex.TrkAtVrt,
               workVertex.Chi2,
               istate);
 
    auto& cov = workVertex.vertexCov;
 
    if(SC.isFailure()) ATH_MSG_DEBUG(" >>> refitVertex: SC in refitVertex returned failure ");
    ATH_MSG_VERBOSE(" >>> refitVertex "<<SC<<", "<<ListBaseTracks.size()<<","<<workVertex.Chi2PerTrk.size());
    ATH_MSG_VERBOSE( " >>> refitVertex: succeeded in fitting. New vertex pos (r,z) = (" << vertexPos.perp() << ", " << vertexPos.z() << ")" );
    ATH_MSG_VERBOSE( " >>> refitVertex: New vertex cov = (" << cov.at(0) << ", " << cov.at(1) << ", " << cov.at(2) << ", " << cov.at(3) << ", " << cov.at(4) << ", " << cov.at(5) << ")" );
 
    return SC;
  }

refitVertexWithSuggestion() [1/2]

StatusCode VKalVrtAthena::VrtSecInclusive::refitVertexWithSuggestion ( WrkVrt & workVertex, const Amg::Vector3D & suggestedPosition )

private

refit the vertex with suggestion

Definition at line 585 of file Reconstruction/VKalVrt/VrtSecInclusive/src/Utilities.cxx.

  {
    std::unique_ptr<Trk::IVKalState> state = m_fitSvc->makeState();
    return refitVertexWithSuggestion (workVertex, suggestedPosition, *state);
  }

refitVertexWithSuggestion() [2/2]

StatusCode VKalVrtAthena::VrtSecInclusive::refitVertexWithSuggestion ( WrkVrt & workVertex, const Amg::Vector3D & suggestedPosition, Trk::IVKalState & istate )

private

Definition at line 593 of file Reconstruction/VKalVrt/VrtSecInclusive/src/Utilities.cxx.

  {
 
    //
    vector<const xAOD::NeutralParticle*> dummyNeutrals;
 
    int nth = workVertex.selectedTrackIndices.size();
 
    if(nth<2) {
      workVertex.isGood = false;
      return StatusCode::SUCCESS;
    }
 
    vector<const xAOD::TrackParticle*>  ListBaseTracks;
 
    workVertex.Chi2PerTrk.clear();
 
    for( const auto& index : workVertex.selectedTrackIndices ) {
      ListBaseTracks.emplace_back( m_selectedTracks.at( index ) );
      workVertex.Chi2PerTrk.emplace_back( AlgConsts::chi2PerTrackInitValue );
    }
 
    for( const auto& index : workVertex.associatedTrackIndices ) {
      ListBaseTracks.emplace_back( m_associatedTracks.at( index ) );
      workVertex.Chi2PerTrk.emplace_back( AlgConsts::chi2PerTrackInitValue );
    }
 
    auto& vertexPos = workVertex.vertex;
 
    m_fitSvc->setApproximateVertex( suggestedPosition.x(), suggestedPosition.y(), suggestedPosition.z(), istate );
 
    ATH_MSG_VERBOSE( " >>> " << __FUNCTION__ <<": ListBaseTracks.size = " << ListBaseTracks.size()
                   << ", #selectedBaseTracks = " << workVertex.selectedTrackIndices.size()
                   << ", #assocTracks = " << workVertex.associatedTrackIndices.size() );
    for( const auto *trk : ListBaseTracks ) {
      ATH_MSG_VERBOSE( " >>> " << __FUNCTION__ << ": track index = " << trk->index() );
    }
 
    ATH_MSG_VERBOSE( " >>> " << __FUNCTION__ << ": m_fitSvc is reset." );
 
    ATH_MSG_VERBOSE( " >>> " << __FUNCTION__ << ": approx vertex is set. Now going to perform fitting..." );
 
    StatusCode SC=m_fitSvc->VKalVrtFit(ListBaseTracks,dummyNeutrals,
               workVertex.vertex,
               workVertex.vertexMom,
               workVertex.Charge,
               workVertex.vertexCov,
               workVertex.Chi2PerTrk,
               workVertex.TrkAtVrt,
               workVertex.Chi2,
               istate);
 
    auto& cov = workVertex.vertexCov;
 
    if( SC.isFailure() ) ATH_MSG_VERBOSE(" >>> " << __FUNCTION__ << ": SC in refitVertex returned failure ");
    ATH_MSG_VERBOSE(" >>> " << __FUNCTION__ << ": "<<SC<<", "<<ListBaseTracks.size()<<","<<workVertex.Chi2PerTrk.size());
 
    if( SC.isSuccess() ) {
      ATH_MSG_VERBOSE( " >>> " << __FUNCTION__ << ": succeeded in fitting. New vertex pos = (" << vertexPos.x() << ", " << vertexPos.y() << ", " << vertexPos.z() << ")" );
      ATH_MSG_VERBOSE( " >>> " << __FUNCTION__ << ": New vertex cov = (" << cov.at(0) << ", " << cov.at(1) << ", " << cov.at(2) << ", " << cov.at(3) << ", " << cov.at(4) << ", " << cov.at(5) << ")" );
    }
 
    return SC;
  }

removeInconsistentTracks()

void VKalVrtAthena::VrtSecInclusive::removeInconsistentTracks ( WrkVrt & wrkvrt )

private

Remove inconsistent tracks from vertices.

Definition at line 2198 of file Reconstruction/VKalVrt/VrtSecInclusive/src/Utilities.cxx.

  {
 
    const auto& vertex = wrkvrt.vertex;
 
    std::map< std::deque<long int>*, std::vector<const xAOD::TrackParticle*>& > indexMap
    {
      { &(wrkvrt.selectedTrackIndices), m_selectedTracks }, { &(wrkvrt.associatedTrackIndices), m_associatedTracks }
    };
 
    for( auto& pair : indexMap ) {
 
      auto* indices = pair.first;
      auto& tracks  = pair.second;
 
      auto newEnd = std::remove_if( indices->begin(), indices->end(),
                                    [&]( auto& index ) {
                                      bool isConsistent = (this->*m_patternStrategyFuncs[m_checkPatternStrategy] )( tracks.at(index), vertex );
                                      return !isConsistent;
                                    } );
 
      indices->erase( newEnd, indices->end() );
 
    }
 
  }

removeTrackFromVertex()

void VKalVrtAthena::VrtSecInclusive::removeTrackFromVertex ( std::vector< WrkVrt > * workVerticesContainer, std::vector< std::deque< long int > > * TrkInVrt, const long int & trackIndexToRemove, const long int & SelectedVertex )

staticprivate

Definition at line 337 of file Reconstruction/VKalVrt/VrtSecInclusive/src/Utilities.cxx.

  {
 
    auto& wrkvrt = workVerticesContainer->at(SelectedVertex);
    auto& tracks = wrkvrt.selectedTrackIndices;
 
    {
      auto end = std::remove_if( tracks.begin(), tracks.end(), [&](long int index) { return index == trackIndexToRemove; } );
      tracks.erase( end, tracks.end() );
    }
 
    {
      for( auto& trks : *TrkInVrt ) {
        auto end = std::remove_if( trks.begin(), trks.end(), [&](long int index) { return index == trackIndexToRemove; } );
        trks.erase( end, trks.end() );
      }
    }
 
 
    // Check if track is removed from two-track vertex => then sharing of track left should also be decreased
    if( wrkvrt.selectedTrackIndices.size() == 1 ) {
 
      const auto& leftTrackIndex = *( tracks.begin() );
      auto& list = TrkInVrt->at(leftTrackIndex);
      auto end = std::remove_if( list.begin(), list.end(), [&](long int index) { return index == trackIndexToRemove; } );
      list.erase( end, list.end() );
 
    }
 
  }

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

selectInDetAndGSFTracks()

StatusCode VKalVrtAthena::VrtSecInclusive::selectInDetAndGSFTracks ( const EventContext & ctx )

private

Definition at line 303 of file TrackSelectionAlgs.cxx.

                                                                              {
    ATH_MSG_DEBUG( " > " << __FUNCTION__ << ": begin"  );
 
    //--------------------------------------------------------
    //  Extract tracks from xAOD::TrackParticle container
    //
 
    SG::ReadHandle<xAOD::TrackParticleContainer> IDtracksHandle = SG::makeHandle( m_TrackLocation, ctx );
    ATH_CHECK( IDtracksHandle.isValid() );    
    const xAOD::TrackParticleContainer* IDtracks = IDtracksHandle.cptr();
 
    SG::ReadHandle<xAOD::ElectronContainer> electronsHandle = SG::makeHandle( m_ElectronLocation, ctx );
    ATH_CHECK(electronsHandle.isValid() );
    const xAOD::ElectronContainer *electrons = electronsHandle.cptr();
 
    SG::ReadHandle<xAOD::MuonContainer> muonsHandle = SG::makeHandle( m_MuonLocation, ctx );
    ATH_CHECK( muonsHandle.isValid() );
    const xAOD::MuonContainer* muons = muonsHandle.cptr();
 
    std::vector<const xAOD::TrackParticle*> IDTrksFromEls;
 
    // Loop over electrons to select all GSF tracks
    for( const auto *electron : *electrons ) {
      if( 0 == electron->nTrackParticles() ) { continue; }
      // The first track is the best-matched GSF track
      const auto* el_trk = electron->trackParticle(0);
      selectTrack( el_trk );
      m_leptonicTracks.emplace_back(el_trk);
      IDTrksFromEls.emplace_back(xAOD::EgammaHelpers::getOriginalTrackParticle(electron));
    }
 
    // Loop over ID tracks to select all non-el tracks
    for( const auto *trk : *IDtracks ) {
      // do not select ID track if matched to an electron
      if ( std::find(IDTrksFromEls.begin(), IDTrksFromEls.end(), trk) != IDTrksFromEls.end() ) { continue; }
      selectTrack( trk );
    }
 
    // Loop over muons to book-keep all ID tracks matched to muons
    for (const auto *muon : *muons) {
      if (m_doRemoveCaloTaggedMuons && muon->muonType() == xAOD::Muon::CaloTagged) { continue; }
      const auto* mu_trk = muon->trackParticle( xAOD::Muon::InnerDetectorTrackParticle );
      if(!mu_trk) { continue; }
      m_leptonicTracks.emplace_back(mu_trk);
    }
 
    ATH_MSG_DEBUG( " > " << __FUNCTION__ << ": Number of total ID tracks   = " << IDtracks->size() );
    ATH_MSG_DEBUG( " > " << __FUNCTION__ << ": Number of total electrons   = " << electrons->size() );
    ATH_MSG_DEBUG( " > " << __FUNCTION__ << ": Number of selected tracks   = " << m_selectedTracks.size() );
 
    return StatusCode::SUCCESS;
  }

selectTrack()

void VKalVrtAthena::VrtSecInclusive::selectTrack ( const xAOD::TrackParticle * trk )

private

Vertexing Algorithm Member Functions.

select tracks which become seeds for vertex finding

Definition at line 136 of file TrackSelectionAlgs.cxx.

                                                                  {
 
    if( !m_decor_isSelected ) {
      m_decor_isSelected.emplace( "is_selected" + m_augVerString );
    }
 
    // Setup cut functions
    if( m_trackSelectionFuncs.empty() && !m_passThroughTrackSelection ) {
 
      // These cuts are optional. Specified by JobProperty
      if( m_do_PVvetoCut )             m_trackSelectionFuncs.emplace_back( &VrtSecInclusive::selectTrack_notPVassociated );
      if( m_do_d0Cut )                 m_trackSelectionFuncs.emplace_back( &VrtSecInclusive::selectTrack_d0Cut );
      if( m_do_z0Cut )                 m_trackSelectionFuncs.emplace_back( &VrtSecInclusive::selectTrack_z0Cut );
      if( m_do_d0errCut )              m_trackSelectionFuncs.emplace_back( &VrtSecInclusive::selectTrack_d0errCut );
      if( m_do_z0errCut )              m_trackSelectionFuncs.emplace_back( &VrtSecInclusive::selectTrack_z0errCut );
      if (m_doSelectTracksWithLRTCuts) m_trackSelectionFuncs.emplace_back( &VrtSecInclusive::selectTrack_LRTR3Cut );
      //if( m_do_d0signifCut ) m_trackSelectionFuncs.emplace_back( &VrtSecInclusive::selectTrack_d0signifCut ); // not implemented yet
      //if( m_do_z0signifCut ) m_trackSelectionFuncs.emplace_back( &VrtSecInclusive::selectTrack_z0signifCut ); // not implemented yet
 
      // These cuts are used by default
      m_trackSelectionFuncs.emplace_back( &VrtSecInclusive::selectTrack_hitPattern );
      m_trackSelectionFuncs.emplace_back( &VrtSecInclusive::selectTrack_hitPatternTight );
      m_trackSelectionFuncs.emplace_back( &VrtSecInclusive::selectTrack_chi2Cut );
      m_trackSelectionFuncs.emplace_back( &VrtSecInclusive::selectTrack_pTCut );
 
    }
 
    if(  std::find( m_selectedTracks.begin(), m_selectedTracks.end(), trk ) != m_selectedTracks.end() ) return;
 
    std::vector<bool> cutBits;
 
    cutBits.reserve(m_trackSelectionFuncs.size());
    for( auto func : m_trackSelectionFuncs ) cutBits.emplace_back( (this->*func)( trk ) );
 
    if( m_FillHist ) {
      m_hists["trkSelCuts"]->Fill( 0 );
      for( size_t ibit = 0; ibit < cutBits.size(); ibit++) {
        if( cutBits.at(ibit) ) {
          m_hists["trkSelCuts"]->Fill( ibit+1 );
        } else {
          break;
        }
      }
    }
 
    // Good track should not find any false bit
    bool isGood_standard = ( std::find( cutBits.begin(), cutBits.end(), false ) == cutBits.end() );
 
    if( isGood_standard ) {
 
      // Store the selected track to the new m_selectedTracks
      // Here we firstly need to register the empty pointer to the m_selectedTracks,
      // then need to do deep copy after then. This is the feature of xAOD.
 
      int uniqueID = HepMC::UNDEFINED_ID;
 
      if( m_doTruth ) {
 
        const xAOD::TruthParticle *truth = getTrkGenParticle(trk);
 
        if ( truth ) {
          uniqueID = HepMC::uniqueID(truth);
        }
 
      }
 
      (*m_decor_isSelected)( *trk ) = true;
      if (m_doSelectTracksFromElectrons  || m_doSelectIDAndGSFTracks) {
        const xAOD::TrackParticle *id_tr{};
        id_tr = xAOD::EgammaHelpers::getOriginalTrackParticleFromGSF(trk);
        if (id_tr) { (*m_decor_isSelected)( *id_tr ) = true; }
      }
 
      m_selectedTracks.emplace_back( trk );
 
      if( m_FillNtuple ) m_ntupleVars->get< vector<int> >( "SelTrk_uniqueID" ).emplace_back(uniqueID);
 
      ATH_MSG_VERBOSE( " > " << __FUNCTION__ << ": Track index " << trk->index() << " has been selected." );
      ATH_MSG_VERBOSE( " > " << __FUNCTION__ << ": Track index " << trk->index()
                       << " parameter:"
                       << " pt = "  << trk->pt()
                       << " eta = " << trk->eta()
                       << " d0 = "  << trk->d0()
                       << " z0 = "  << trk->z0() << "." );
 
    }
 
  }

selectTrack_chi2Cut()

bool VKalVrtAthena::VrtSecInclusive::selectTrack_chi2Cut ( const xAOD::TrackParticle * trk ) const

private

Definition at line 35 of file TrackSelectionAlgs.cxx.

{ return trk->chiSquared() / (trk->numberDoF()+AlgConsts::infinitesimal) < m_TrkChi2Cut; }

selectTrack_d0Cut()

bool VKalVrtAthena::VrtSecInclusive::selectTrack_d0Cut ( const xAOD::TrackParticle * trk ) const

private

Definition at line 28 of file TrackSelectionAlgs.cxx.

{ return ( fabs( trk->d0() ) > m_d0TrkPVDstMinCut && fabs( trk->d0() ) < m_d0TrkPVDstMaxCut ); }

selectTrack_d0errCut()

bool VKalVrtAthena::VrtSecInclusive::selectTrack_d0errCut ( const xAOD::TrackParticle * trk ) const

private

Definition at line 30 of file TrackSelectionAlgs.cxx.

{ const double cov11 = trk->definingParametersCovMatrix()(0,0); return cov11 < m_d0TrkErrorCut*m_d0TrkErrorCut; }

selectTrack_d0signifCut()

bool VKalVrtAthena::VrtSecInclusive::selectTrack_d0signifCut ( const xAOD::TrackParticle * )

staticprivate

Definition at line 32 of file TrackSelectionAlgs.cxx.

{ return true; }

selectTrack_hitPattern()

bool VKalVrtAthena::VrtSecInclusive::selectTrack_hitPattern ( const xAOD::TrackParticle * trk ) const

private

Definition at line 38 of file TrackSelectionAlgs.cxx.

                                                                                   {
 
    uint8_t PixelHits = 0;
    uint8_t SCTHits   = 0;
    uint8_t BLayHits  = 0;
    uint8_t PixShare  = 0;
    uint8_t SCTShare  = 0;
    uint8_t TRTHits   = 0;
 
    if( !(trk->summaryValue( PixelHits, xAOD::numberOfPixelHits               ) ) ) PixelHits =0;
    if( !(trk->summaryValue( SCTHits,   xAOD::numberOfSCTHits                 ) ) ) SCTHits   =0;
    if( !(trk->summaryValue( BLayHits,  xAOD::numberOfInnermostPixelLayerHits ) ) ) BLayHits  =0;
    if( !(trk->summaryValue( PixShare,  xAOD::numberOfPixelSharedHits         ) ) ) PixShare  =0;
    if( !(trk->summaryValue( SCTShare,  xAOD::numberOfSCTSharedHits           ) ) ) SCTShare  =0;
    if( !(trk->summaryValue( TRTHits,   xAOD::numberOfTRTHits                 ) ) ) TRTHits   =0;
 
    uint8_t SharedHits = PixShare + SCTShare;
 
    // do Pixel/SCT/SiHits only if we exclude StandAlone TRT hits
    if( !m_SAloneTRT ) {
      if(PixelHits           < m_CutPixelHits)  return false;
      if(SCTHits             < m_CutSctHits)    return false;
      if((PixelHits+SCTHits) < m_CutSiHits)     return false;
      if(BLayHits            < m_CutBLayHits)   return false;
      if(SharedHits          > m_CutSharedHits) return false;
    }
 
    // The folloing part reproduces the track selection in RPVDixpVrt
    if( m_doTRTPixCut ) {
      if(TRTHits == 0 && PixelHits < 2)           return false;
    }
 
    if( PixelHits == 0 && SCTHits < 6 ) return false;
 
    return true;
  }

selectTrack_hitPatternTight()

bool VKalVrtAthena::VrtSecInclusive::selectTrack_hitPatternTight ( const xAOD::TrackParticle * trk ) const

private

Definition at line 76 of file TrackSelectionAlgs.cxx.

                                                                                        {
    uint8_t PixelHits = 0;
    uint8_t SCTHits   = 0;
    uint8_t TRTHits   = 0;
 
    if( !(trk->summaryValue( PixelHits, xAOD::numberOfPixelHits               ) ) ) PixelHits =0;
    if( !(trk->summaryValue( SCTHits,   xAOD::numberOfSCTHits                 ) ) ) SCTHits   =0;
    if( !(trk->summaryValue( TRTHits,   xAOD::numberOfTRTHits                 ) ) ) TRTHits   =0;
 
    if( trk->pt() > 20.e3 ) return true;
 
    if( SCTHits < m_CutTightSCTHits                   ) return false;
 
    if( fabs( trk->eta() ) < 1.7 ) {
      if( TRTHits < m_CutTightTRTHits ) return false;
    }
 
    return true;
  }

selectTrack_LRTR3Cut()

bool VKalVrtAthena::VrtSecInclusive::selectTrack_LRTR3Cut ( const xAOD::TrackParticle * trk ) const

private

Definition at line 102 of file TrackSelectionAlgs.cxx.

                                                                                 {
    uint8_t npix = 0;
    trk->summaryValue(npix, xAOD::numberOfPixelHits);
    uint8_t nsct = 0;
    trk->summaryValue(nsct, xAOD::numberOfSCTHits);
    uint8_t nSiHits = npix + nsct ;
    uint8_t nSCTHoles=0;
    trk->summaryValue(nSCTHoles, xAOD::numberOfSCTHoles);
 
    double dTheta = std::fabs(TMath::ATan2(std::fabs(trk->d0()),trk->z0())-2*std::atan(std::exp(-1*trk->eta())));
    bool geometric_cut = dTheta < 1. || std::fabs(trk->z0()) < 200. ;
 
    bool z0_cut = trk->z0() <= 500. ;
    bool chi2_cut = (trk->chiSquared()/ (trk->numberDoF()+AlgConsts::infinitesimal)) <= 9. ;
    bool NSiHits_cut = nSiHits >=8 ;
    bool NSCTHits_cut = nsct >= 7 ;
    bool NSCTHoles_cut = nSCTHoles <= 1;
 
    ATH_MSG_DEBUG( " > " << __FUNCTION__ << ": z0_cut, chi2_cut, NSiHits_cut, NSCTHits_cut, NSCTHoles_cut  = " <<z0_cut<<", "<<chi2_cut<<", "<<NSiHits_cut<<", "<<NSCTHits_cut<<", "<< NSCTHoles_cut );
    ATH_MSG_DEBUG( " > " << __FUNCTION__ << ": npix, nsct, nSiHits, nSCTHoles, dTheta, z0, d0, chi2  = " <<unsigned(npix)<<", "<<unsigned(nsct)<<", "<<unsigned(nSiHits)<<", "<<unsigned(nSCTHoles)<<", "<< dTheta<<", "<< trk->z0()<<", "<< trk->d0()<<", " <<trk->chiSquared() ) ;
 
    const std::bitset<xAOD::NumberOfTrackRecoInfo> patternReco = trk->patternRecoInfo();
    bool isLRT = patternReco.test(49) ;
    ATH_MSG_DEBUG( " > " << __FUNCTION__ << ": Track is LRT  = " << isLRT ) ;
    if (isLRT) {  // apply all cuts to LRT tracks
      return (z0_cut && chi2_cut && NSiHits_cut && NSCTHits_cut && NSCTHoles_cut && geometric_cut);
    }
    else{ // not LRT track; only apply SiHit cut
      return NSiHits_cut ;
    }
  }

selectTrack_notPVassociated()

bool VKalVrtAthena::VrtSecInclusive::selectTrack_notPVassociated ( const xAOD::TrackParticle * trk ) const

private

track-by-track selection strategies

Definition at line 97 of file TrackSelectionAlgs.cxx.

                                                                                          {
    return !( VKalVrtAthena::isAssociatedToVertices( trk, m_primaryVertices ) );
  }

selectTrack_pTCut()

bool VKalVrtAthena::VrtSecInclusive::selectTrack_pTCut ( const xAOD::TrackParticle * trk ) const

private

Definition at line 34 of file TrackSelectionAlgs.cxx.

{ return trk->pt() > m_TrkPtCut; }

selectTrack_z0Cut()

bool VKalVrtAthena::VrtSecInclusive::selectTrack_z0Cut ( const xAOD::TrackParticle * trk ) const

private

Definition at line 29 of file TrackSelectionAlgs.cxx.

{ return ( fabs( trk->z0() ) > m_z0TrkPVDstMinCut && fabs( trk->z0() ) < m_z0TrkPVDstMaxCut ); }

selectTrack_z0errCut()

bool VKalVrtAthena::VrtSecInclusive::selectTrack_z0errCut ( const xAOD::TrackParticle * trk ) const

private

Definition at line 31 of file TrackSelectionAlgs.cxx.

{ const double cov22 = trk->definingParametersCovMatrix()(1,1); return cov22 < m_z0TrkErrorCut*m_z0TrkErrorCut; }

selectTrack_z0signifCut()

bool VKalVrtAthena::VrtSecInclusive::selectTrack_z0signifCut ( const xAOD::TrackParticle * )

staticprivate

Definition at line 33 of file TrackSelectionAlgs.cxx.

{ return true; }

selectTracksFromElectrons()

StatusCode VKalVrtAthena::VrtSecInclusive::selectTracksFromElectrons ( const EventContext & ctx )

private

Definition at line 280 of file TrackSelectionAlgs.cxx.

                                                                                {
    SG::ReadHandle<xAOD::ElectronContainer> electronsHandle = SG::makeHandle( m_ElectronLocation, ctx );
    ATH_CHECK( electronsHandle.isValid() );
    const xAOD::ElectronContainer *electrons = electronsHandle.cptr();
 
    for( const auto *const electron : *electrons ) {
      if( 0 == electron->nTrackParticles() ) continue;
 
      // The first track is the best-matched track
      const auto* trk = electron->trackParticle(0);
 
      if( !trk ) continue;
      selectTrack( trk );
    }
 
    ATH_MSG_DEBUG( " > " << __FUNCTION__ << ": Number of total electrons   = " << electrons->size() );
    ATH_MSG_DEBUG( " > " << __FUNCTION__ << ": Number of selected tracks   = " << m_selectedTracks.size() );
 
    return StatusCode::SUCCESS;
  }

selectTracksFromMuons()

StatusCode VKalVrtAthena::VrtSecInclusive::selectTracksFromMuons ( const EventContext & ctx )

private

Definition at line 254 of file TrackSelectionAlgs.cxx.

                                                                            {
    SG::ReadHandle<xAOD::MuonContainer> muonHandle = SG::makeHandle( m_MuonLocation, ctx );
    ATH_CHECK( muonHandle.isValid() );    
    const xAOD::MuonContainer* muons = muonHandle.cptr();
 
 
    for( const auto *const muon : *muons ) {
      const auto* trk = muon->trackParticle( xAOD::Muon::InnerDetectorTrackParticle );
 
      if( !trk ) continue;
      // remove calo-tagged muons when selecting muons
      if (m_doRemoveCaloTaggedMuons) {
        if (muon->muonType() == xAOD::Muon::CaloTagged) continue;
      }
      selectTrack( trk );
 
    }
 
    ATH_MSG_DEBUG( " > " << __FUNCTION__ << ": Number of total muons       = " << muons->size() );
    ATH_MSG_DEBUG( " > " << __FUNCTION__ << ": Number of selected tracks   = " << m_selectedTracks.size() );
 
    return StatusCode::SUCCESS;
  }

selectTracksInDet()

StatusCode VKalVrtAthena::VrtSecInclusive::selectTracksInDet ( const EventContext & ctx )

private

Definition at line 226 of file TrackSelectionAlgs.cxx.

                                                                        {
    ATH_MSG_DEBUG( " > " << __FUNCTION__ << ": begin"  );
 
    //--------------------------------------------------------
    //  Extract tracks from xAOD::TrackParticle container
    //
 
    SG::ReadHandle<xAOD::TrackParticleContainer> trackHandle = SG::makeHandle( m_TrackLocation, ctx );
    ATH_CHECK( trackHandle.isValid() );    
    const xAOD::TrackParticleContainer* trackParticleContainer = trackHandle.cptr();
 
    ATH_MSG_DEBUG( " > " << __FUNCTION__ << ": Extracted xAOD::TrackParticle number=" << trackParticleContainer->size() );
 
    if( m_FillNtuple )
      m_ntupleVars->get<unsigned int>( "NumAllTrks" ) = static_cast<int>( trackParticleContainer->size() );
 
 
    // Loop over tracks
    for( const auto *trk : *trackParticleContainer ) { selectTrack( trk ); }
 
    ATH_MSG_DEBUG( " > " << __FUNCTION__ << ": Number of total ID tracks   = " << trackParticleContainer->size() );
    ATH_MSG_DEBUG( " > " << __FUNCTION__ << ": Number of selected tracks   = " << m_selectedTracks.size() );
 
    return StatusCode::SUCCESS;
  }

setIntersection() [1/2]

template<class Track>

void VKalVrtAthena::VrtSecInclusive::setIntersection ( Track * trk, IntersectionPos * bec, const Trk::Perigee * per )

private

setIntersection() [2/2]

template<class TrackT>

void VKalVrtAthena::VrtSecInclusive::setIntersection	(	TrackT *	trk,
		IntersectionPos *	layer,
		const Trk::Perigee *	per )

Definition at line 40 of file Reconstruction/VKalVrt/VrtSecInclusive/VrtSecInclusive/details/Utilities.h.

  {
    const EventContext& ctx = Gaudi::Hive::currentContext();
    std::unique_ptr<Trk::TrackParameters> Output;
 
    if( layer->bec() == IntersectionPos::barrel ) {
 
      IntersectionPos_barrel *barrel = dynamic_cast<IntersectionPos_barrel*>( layer );
 
      ATH_MSG_VERBOSE( " >>> setIntersection: name = " << barrel->name() << ", Radius = " << barrel->radius() );
 
      Amg::Transform3D trnsf;
      trnsf.setIdentity();
      Trk::CylinderSurface surfBorder(trnsf, barrel->radius(), 300000.); //
      Output = m_extrapolator->extrapolateDirectly(ctx, *per,surfBorder,Trk::anyDirection,true,Trk::pion);
 
      barrel->x()->push_back( Output? Output->position().x() : -10000 );
      barrel->y()->push_back( Output? Output->position().y() : -10000 );
      barrel->z()->push_back( Output? Output->position().z() : -10000 );
 
 
    } else if( layer->bec() == IntersectionPos::endcap ) {
 
      IntersectionPos_endcap *endcap = dynamic_cast<IntersectionPos_endcap*>( layer );
 
      ATH_MSG_VERBOSE( " >>> setIntersection: name = " << endcap->name() <<
                       ", zpos = " << endcap->zpos() <<
                       ", Rmin = " << endcap->rmin() <<
                       ", Rmax = " << endcap->rmax()    );
 
      Amg::Transform3D trnsf;
      trnsf.setIdentity();
      trnsf.translate( Amg::Vector3D(0.,0.,endcap->zpos()) );
      Trk::DiscSurface surfBorder(trnsf, endcap->rmin(), endcap->rmax() );
      Output = m_extrapolator->extrapolateDirectly(ctx, *per, surfBorder, Trk::anyDirection, true, Trk::pion);
 
      endcap->x()->push_back( Output? Output->position().x() : -10000 );
      endcap->y()->push_back( Output? Output->position().y() : -10000 );
      endcap->z()->push_back( Output? Output->position().z() : -10000 );
 
    }
 
 
    if( Output ) {
      trk->template auxdecor<float>( Form("intersection_%s_x", layer->name().c_str()) ) = Output->position().x();
      trk->template auxdecor<float>( Form("intersection_%s_y", layer->name().c_str()) ) = Output->position().y();
      trk->template auxdecor<float>( Form("intersection_%s_z", layer->name().c_str()) ) = Output->position().z();
    }
  }

setupNtuple()

StatusCode VKalVrtAthena::VrtSecInclusive::setupNtuple ( )

private

Definition at line 218 of file AANT_Tools.cxx.

                                          {
    
    m_ntupleVars->branchNtuple( m_tree_Vert );
    
    return StatusCode::SUCCESS;
  }

setupNtupleVariables()

StatusCode VKalVrtAthena::VrtSecInclusive::setupNtupleVariables ( )

private

Definition at line 28 of file AANT_Tools.cxx.

                                                   {
    
    m_ntupleVars->addNewVar<unsigned int>     ( "RunNumber"                );
    m_ntupleVars->addNewVar<unsigned int>     ( "Event"                    );
    m_ntupleVars->addNewVar<unsigned int>     ( "Time"                     );
    m_ntupleVars->addNewVar<unsigned int>     ( "LumiBlock"                );
    m_ntupleVars->addNewVar<unsigned int>     ( "BCID"                     );
    m_ntupleVars->addNewVar<unsigned int>     ( "LVL1ID"                   );
    
    m_ntupleVars->addNewVar<unsigned int>     ( "NumAllTrks"               );
    m_ntupleVars->addNewVar<unsigned int>     ( "NumSelTrks"               );
    m_ntupleVars->addNewVar<unsigned int>     ( "SizeIncomp"               );
    
    m_ntupleVars->addNewVar<unsigned int>     ( "NumPV"                    );
    m_ntupleVars->addNewVar<unsigned int>     ( "NTrksPV"                  );
    m_ntupleVars->addNewVar<unsigned int>     ( "PVType"                   );
    m_ntupleVars->addNewVar<double>           ( "PVX"                      );
    m_ntupleVars->addNewVar<double>           ( "PVY"                      );
    m_ntupleVars->addNewVar<double>           ( "PVZ"                      );
    
    m_ntupleVars->addNewVar< vector<int> >    ( "NdofTrksPV"               );
    m_ntupleVars->addNewVar< vector<double> > ( "PVZpile"                  );
    
    m_ntupleVars->addNewVar< vector<int> >    ( "RecoTrk_id"               );
    m_ntupleVars->addNewVar< vector<double> > ( "RecoTrk_pT"               );
    m_ntupleVars->addNewVar< vector<double> > ( "RecoTrk_2dIPPV"           );
    m_ntupleVars->addNewVar< vector<double> > ( "RecoTrk_ZIPPV"            );
    m_ntupleVars->addNewVar< vector<double> > ( "RecoTrk_2dIP"             );
    m_ntupleVars->addNewVar< vector<double> > ( "RecoTrk_ZIP"              );
    m_ntupleVars->addNewVar< vector<double> > ( "RecoTrk_phi"              );
    m_ntupleVars->addNewVar< vector<double> > ( "RecoTrk_eta"              );
    m_ntupleVars->addNewVar< vector<double> > ( "RecoTrk_chi2"             );
    m_ntupleVars->addNewVar< vector<double> > ( "RecoTrk_eta"              );
    m_ntupleVars->addNewVar< vector<int> >    ( "RecoTrk_BLayHits"         );
    m_ntupleVars->addNewVar< vector<int> >    ( "RecoTrk_PixHits"          );
    m_ntupleVars->addNewVar< vector<int> >    ( "RecoTrk_SCTHits"          );
    m_ntupleVars->addNewVar< vector<int> >    ( "RecoTrk_TRTHits"          );
    m_ntupleVars->addNewVar< vector<int> >    ( "RecoTrk_PixBar1"          );
    m_ntupleVars->addNewVar< vector<int> >    ( "RecoTrk_PixBar2"          );
    m_ntupleVars->addNewVar< vector<int> >    ( "RecoTrk_barcode"          ); // FIXME barcode-based
    m_ntupleVars->addNewVar< vector<double> > ( "RecoTrk_matchPr"          );
    m_ntupleVars->addNewVar< vector<double> > ( "RecoTrk_2dIPErr"          );
    m_ntupleVars->addNewVar< vector<double> > ( "RecoTrk_ZIPErr"           );
    m_ntupleVars->addNewVar< vector<int> >    ( "RecoTrk_PixShare"         );
    m_ntupleVars->addNewVar< vector<int> >    ( "RecoTrk_SCTShare"         );
    m_ntupleVars->addNewVar< vector<int> >    ( "RecoTrk_TrkAuth"          );
    m_ntupleVars->addNewVar< vector<int> >    ( "RecoTrk_TrkLowPt"         );
    
    m_ntupleVars->addNewVar< vector<int> >    ( "SelTrk_barcode"           ); // FIXME barcode-based
    
    m_ntupleVars->addNewVar< vector<int> >    ( "SVTrk_id"                 );
    m_ntupleVars->addNewVar< vector<double> > ( "SVTrk_pT"                 );
    m_ntupleVars->addNewVar< vector<double> > ( "SVTrk_p"                  );
    m_ntupleVars->addNewVar< vector<double> > ( "SVTrk_phi"                );
    m_ntupleVars->addNewVar< vector<double> > ( "SVTrk_eta"                );
    m_ntupleVars->addNewVar< vector<double> > ( "SVTrk_2dIP"               );
    m_ntupleVars->addNewVar< vector<double> > ( "SVTrk_ZIP"                );
    m_ntupleVars->addNewVar< vector<double> > ( "SVTrk_delp"               );
    m_ntupleVars->addNewVar< vector<double> > ( "SVTrk_del2dIP"            );
    m_ntupleVars->addNewVar< vector<double> > ( "SVTrk_delzIP"             );
    m_ntupleVars->addNewVar< vector<double> > ( "SVTrk_eta"                );
    m_ntupleVars->addNewVar< vector<int> >    ( "SVTrk_BLayHits"           );
    m_ntupleVars->addNewVar< vector<int> >    ( "SVTrk_PixHits"            );
    m_ntupleVars->addNewVar< vector<int> >    ( "SVTrk_SCTHits"            );
    m_ntupleVars->addNewVar< vector<int> >    ( "SVTrk_TRTHits"            );
    m_ntupleVars->addNewVar< vector<int> >    ( "SVTrk_barcode"            ); // FIXME barcode-based
    m_ntupleVars->addNewVar< vector<double> > ( "SVTrk_matchPr"            );
    m_ntupleVars->addNewVar< vector<int> >    ( "SVTrk_TrkAuth"            );
    m_ntupleVars->addNewVar< vector<int> >    ( "SVTrk_TrkLowPt"           );
    
    m_ntupleVars->addNewVar< unsigned int >   ( "All2TrkVrtNum"            );
    m_ntupleVars->addNewVar< vector<double> > ( "All2TrkVrtMass"           );
    m_ntupleVars->addNewVar< vector<double> > ( "All2TrkVrtPt"             );
    m_ntupleVars->addNewVar< vector<int> >    ( "All2TrkVrtCharge"         );
    m_ntupleVars->addNewVar< vector<int> >    ( "All2TrkSumBLHits"         );
    m_ntupleVars->addNewVar< vector<double> > ( "All2TrkVrtX"              );
    m_ntupleVars->addNewVar< vector<double> > ( "All2TrkVrtY"              );
    m_ntupleVars->addNewVar< vector<double> > ( "All2TrkVrtZ"              );
    m_ntupleVars->addNewVar< vector<double> > ( "All2TrkVrtChiSq"          );
    
    m_ntupleVars->addNewVar< unsigned int >   ( "AfFakVrtNum"              );
    m_ntupleVars->addNewVar< vector<double> > ( "AfFakVrtMass"             );
    m_ntupleVars->addNewVar< vector<double> > ( "AfFakVrtPt"               );
    m_ntupleVars->addNewVar< vector<int> >    ( "AfFakVrtCharge"           );
    m_ntupleVars->addNewVar< vector<double> > ( "AfFakVrtX"                );
    m_ntupleVars->addNewVar< vector<double> > ( "AfFakVrtY"                );
    m_ntupleVars->addNewVar< vector<double> > ( "AfFakVrtZ"                );
    m_ntupleVars->addNewVar< vector<double> > ( "AfFakVrtChiSq"            );
    
    m_ntupleVars->addNewVar< unsigned int >   ( "NumInitSecVrt"            );
    m_ntupleVars->addNewVar< unsigned int >   ( "NumRearrSecVrt"           );
    m_ntupleVars->addNewVar< unsigned int >   ( "NumSecVrt"                );
    m_ntupleVars->addNewVar< vector<double> > ( "SecVtxX"                  );
    m_ntupleVars->addNewVar< vector<double> > ( "SecVtxY"                  );
    m_ntupleVars->addNewVar< vector<double> > ( "SecVtxZ"                  );
    m_ntupleVars->addNewVar< vector<int> >    ( "SecVtx_NumTrks"           );
    m_ntupleVars->addNewVar< vector<double> > ( "SecVtx_Mass"              );
    m_ntupleVars->addNewVar< vector<double> > ( "SecVtx_Mass_electron"     );
    m_ntupleVars->addNewVar< vector<double> > ( "SecVtx_Chi2"              );
    m_ntupleVars->addNewVar< vector<double> > ( "SecVtx_pT"                );
    m_ntupleVars->addNewVar< vector<double> > ( "SecVtx_pZ"                );
    m_ntupleVars->addNewVar< vector<int> >    ( "SecVtx_Charge"            );
    m_ntupleVars->addNewVar< vector<int> >    ( "SecVtx_SumBLayHits"       );
    m_ntupleVars->addNewVar< vector<int> >    ( "SecVtx_AllTrksBLayHits"   );
    m_ntupleVars->addNewVar< vector<double> > ( "SecVtx_MinOpAng"          );
    
    m_ntupleVars->addNewVar< vector<double> > ( "SecVtx_TrkPt"             );
    m_ntupleVars->addNewVar< vector<double> > ( "SecVtx_TrkPhi"            );
    m_ntupleVars->addNewVar< vector<double> > ( "SecVtx_TrkEta"            );
    m_ntupleVars->addNewVar< vector<int> >    ( "SecVtx_TrkBLay"           );
    m_ntupleVars->addNewVar< vector<int> >    ( "SecVtx_TrkPixExclBLay"    );
    m_ntupleVars->addNewVar< vector<int> >    ( "SecVtx_TrkSCT"            );
    m_ntupleVars->addNewVar< vector<double> > ( "SecVtx_Trk2dIP"           );
    m_ntupleVars->addNewVar< vector<double> > ( "SecVtx_TrkZIP"            );
    m_ntupleVars->addNewVar< vector<double> > ( "SecVtx_TrkdelP"           );
    m_ntupleVars->addNewVar< vector<double> > ( "SecVtx_Trkdel2dIP"        );
    m_ntupleVars->addNewVar< vector<double> > ( "SecVtx_TrkdelZIP"         );
    m_ntupleVars->addNewVar< vector<double> > ( "SecVtx_TrkPtWrtSV"        );
    m_ntupleVars->addNewVar< vector<double> > ( "SecVtx_TrkPhiWrtSV"       );
    m_ntupleVars->addNewVar< vector<double> > ( "SecVtx_TrkEtaWrtSV"       );
    m_ntupleVars->addNewVar< vector<double> > ( "SecVtx_Trk2dIPWrtSV"      );
    m_ntupleVars->addNewVar< vector<double> > ( "SecVtx_TrkZIPWrtSV"       );
    m_ntupleVars->addNewVar< vector<double> > ( "SecVtx_TrkdelPWrtSV"      );
    m_ntupleVars->addNewVar< vector<double> > ( "SecVtx_Trkdel2dIPWrtSV"   );
    m_ntupleVars->addNewVar< vector<double> > ( "SecVtx_TrkdelZIPWrtSV"    );
 
    m_ntupleVars->addNewVar<double>           ( "Truth_SV1X"               );
    m_ntupleVars->addNewVar<double>           ( "Truth_SV1Y"               );
    m_ntupleVars->addNewVar<double>           ( "Truth_SV1Z"               );
    m_ntupleVars->addNewVar<double>           ( "Truth_PiEta"              );
    m_ntupleVars->addNewVar<double>           ( "Truth_PiPhi"              );
    m_ntupleVars->addNewVar<double>           ( "Truth_PiPt"               );
    m_ntupleVars->addNewVar<int>              ( "Truth_PiInt"              );
    m_ntupleVars->addNewVar<int>              ( "Truth_nSVHiPt"            );
    m_ntupleVars->addNewVar<int>              ( "Truth_nSVLoPt"            );
    m_ntupleVars->addNewVar<int>              ( "Truth_nSVGe1HiPt"         );
    
    m_ntupleVars->addNewVar< vector<int> >    ( "Truth_AllVtxType"         );
    m_ntupleVars->addNewVar< vector<double> > ( "Truth_AllSVX"             );
    m_ntupleVars->addNewVar< vector<double> > ( "Truth_AllSVY"             );
    m_ntupleVars->addNewVar< vector<double> > ( "Truth_AllSVZ"             );
    m_ntupleVars->addNewVar< vector<double> > ( "Truth_AllSVTrk1Pt"        );
    m_ntupleVars->addNewVar< vector<double> > ( "Truth_AllSVTrk2Pt"        );
    m_ntupleVars->addNewVar< vector<double> > ( "Truth_AllSVTrk3Pt"        );
    m_ntupleVars->addNewVar< vector<double> > ( "Truth_AllSVTrk4Pt"        );
    m_ntupleVars->addNewVar< vector<double> > ( "Truth_AllSVTrk5Pt"        );
    m_ntupleVars->addNewVar< vector<int> >    ( "Truth_AllSVNumTrks"       );
    m_ntupleVars->addNewVar< vector<int> >    ( "Truth_AllSVNumReTrks"     );
    m_ntupleVars->addNewVar< vector<int> >    ( "Truth_AllSVCharge"        );
    m_ntupleVars->addNewVar< vector<double> > ( "Truth_AllSVSumTrksPt"     );
    m_ntupleVars->addNewVar< vector<double> > ( "Truth_AllSVSumTrksPz"     );
    m_ntupleVars->addNewVar< vector<int> >    ( "Truth_AllSVHasLifetime"   );
    m_ntupleVars->addNewVar< vector<int> >    ( "Truth_AllSVStrangeBaryon" );
    m_ntupleVars->addNewVar< vector<int> >    ( "Truth_AllSVIncomingPid"   );
    m_ntupleVars->addNewVar< vector<int> >    ( "Truth_AllSVNumIncident"   );
    m_ntupleVars->addNewVar< vector<double> > ( "Truth_AllSVPtIncident"    );
    m_ntupleVars->addNewVar< vector<double> > ( "Truth_AllSVPzIncident"    );
    m_ntupleVars->addNewVar< vector<double> > ( "Truth_AllSVMinOpAng"      );
    
    m_ntupleVars->addNewVar< vector<double> > ( "Truth_AllTrk2dIP"         );
    m_ntupleVars->addNewVar< vector<double> > ( "Truth_AllTrkZIP"          );
    m_ntupleVars->addNewVar< vector<double> > ( "Truth_AllTrkPt"           );
    m_ntupleVars->addNewVar< vector<double> > ( "Truth_AllTrkEta"          );
    m_ntupleVars->addNewVar< vector<double> > ( "Truth_AllTrkPhi"          );
    m_ntupleVars->addNewVar< vector<double> > ( "Truth_AllTrkR"            );
    m_ntupleVars->addNewVar< vector<double> > ( "Truth_AllTrkZ"            );
    m_ntupleVars->addNewVar< vector<int> >    ( "Truth_AllTrkBC"           );
    
    m_ntupleVars->addNewVar< vector<int> >    ( "Truth_AllRefitSt"         );
    m_ntupleVars->addNewVar< vector<int> >    ( "Truth_AllRefitNTrk"       );
    m_ntupleVars->addNewVar< vector<double> > ( "Truth_AllRefitChi2"       );
    m_ntupleVars->addNewVar< vector<double> > ( "Truth_AllRefitSVX"        );
    m_ntupleVars->addNewVar< vector<double> > ( "Truth_AllRefitSVY"        );
    m_ntupleVars->addNewVar< vector<double> > ( "Truth_AllRefitSVZ"        );
    m_ntupleVars->addNewVar< vector<double> > ( "Truth_AllRefitMass"       );
    
    return StatusCode::SUCCESS;
  }

significanceBetweenVertices()

double VKalVrtAthena::VrtSecInclusive::significanceBetweenVertices ( const WrkVrt & v1, const WrkVrt & v2 ) const

private

calculate the significance (Mahalanobis distance) between two reconstructed vertices

Definition at line 61 of file Reconstruction/VKalVrt/VrtSecInclusive/src/Utilities.cxx.

                                                                                                {
    try {
      const auto distance = v2.vertex - v1.vertex;
      AmgSymMatrix(3) sumCov;
 
      sumCov.fillSymmetric(0, 0, v1.vertexCov.at(0) + v2.vertexCov.at(0));
      sumCov.fillSymmetric(1, 0, v1.vertexCov.at(1) + v2.vertexCov.at(1));
      sumCov.fillSymmetric(1, 1, v1.vertexCov.at(2) + v2.vertexCov.at(2));
      sumCov.fillSymmetric(2, 0, v1.vertexCov.at(3) + v2.vertexCov.at(3));
      sumCov.fillSymmetric(2, 1, v1.vertexCov.at(4) + v2.vertexCov.at(4));
      sumCov.fillSymmetric(2, 2, v1.vertexCov.at(5) + v2.vertexCov.at(5));
 
      const double s2 = distance.transpose() * sumCov.inverse() * distance;
 
      return s2 > 0. ? sqrt( s2 ) : AlgConsts::maxValue;
    } catch(...) {
      ATH_MSG_WARNING( " >>> " << __FUNCTION__ << ": detected covariance matrix broken exception" );
      return AlgConsts::maxValue;
    }
  }

sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, AthHistogramAlgorithm, and PyAthena::Alg.

Definition at line 66 of file AthAlgorithm.cxx.

                                       {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;
}

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

trackClassification()

void VKalVrtAthena::VrtSecInclusive::trackClassification ( std::vector< WrkVrt > * workVerticesContainer, std::map< long int, std::vector< long int > > & trackToVertexMap )

private

Definition at line 775 of file Reconstruction/VKalVrt/VrtSecInclusive/src/Utilities.cxx.

  {
    // Fill TrkInVrt with vertex IDs of each track
 
    trackToVertexMap.clear();
 
    for( size_t iv = 0; iv<workVerticesContainer->size(); iv++ ) {
 
      WrkVrt& vertex = workVerticesContainer->at(iv);
 
      auto& trackIndices = vertex.selectedTrackIndices;
      if( !vertex.isGood ) continue;
      if( trackIndices.size() < 2 ) continue;
 
      for( auto& index : trackIndices ) {
  trackToVertexMap[index].emplace_back( iv );
      }
    }
 
    for( auto& pair: trackToVertexMap ) {
      std::string msg = Form("track index [%ld]: vertices = (", pair.first);
      for( auto& v : pair.second ) {
        msg += Form("%ld, ", v);
      }
      msg += ")";
      if( pair.second.size() >=2 ) ATH_MSG_VERBOSE(" >> " << __FUNCTION__ << ": " << msg );
    }
 
  }

updateVHKA()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_all2trksVerticesContainerName

Gaudi::Property<std::string> VKalVrtAthena::VrtSecInclusive::m_all2trksVerticesContainerName {this, "All2trkVerticesContainerName", "All2TrksVertices"}

private

Definition at line 121 of file VrtSecInclusive.h.

{this, "All2trkVerticesContainerName", "All2TrksVertices"};

m_associateChi2Cut

Gaudi::Property<double> VKalVrtAthena::VrtSecInclusive::m_associateChi2Cut {this, "associateChi2Cut", 20.}

private

Definition at line 214 of file VrtSecInclusive.h.

{this, "associateChi2Cut", 20.};

m_associatedTracks

std::vector<const xAOD::TrackParticle*> VKalVrtAthena::VrtSecInclusive::m_associatedTracks

private

Definition at line 261 of file VrtSecInclusive.h.

m_associateMaxD0Signif

Gaudi::Property<double> VKalVrtAthena::VrtSecInclusive::m_associateMaxD0Signif {this, "associateMaxD0Signif", 5.}

private

Definition at line 211 of file VrtSecInclusive.h.

{this, "associateMaxD0Signif", 5.}; // wrt. DV in unit of sigma

m_associateMaxZ0Signif

Gaudi::Property<double> VKalVrtAthena::VrtSecInclusive::m_associateMaxZ0Signif {this, "associateMaxZ0Signif", 5.}

private

Definition at line 212 of file VrtSecInclusive.h.

{this, "associateMaxZ0Signif", 5.}; // wrt. DV in unit of sigma

m_associateMinDistanceToPV

Gaudi::Property<double> VKalVrtAthena::VrtSecInclusive::m_associateMinDistanceToPV {this, "associateMinDistanceToPV", 0.5}

private

Definition at line 210 of file VrtSecInclusive.h.

{this, "associateMinDistanceToPV", 0.5};

m_associatePtCut

Gaudi::Property<double> VKalVrtAthena::VrtSecInclusive::m_associatePtCut {this, "associatePtCut", 0.}

private

Definition at line 213 of file VrtSecInclusive.h.

{this, "associatePtCut", 0.}; // in [MeV]

m_atlasId

const AtlasDetectorID* VKalVrtAthena::VrtSecInclusive::m_atlasId {}

private

Definition at line 283 of file VrtSecInclusive.h.

{};

m_augVerString

Gaudi::Property<std::string> VKalVrtAthena::VrtSecInclusive::m_augVerString {this, "AugmentingVersionString", "_VSI"}

private

Definition at line 118 of file VrtSecInclusive.h.

{this, "AugmentingVersionString", "_VSI"};

m_BeamPosition

std::vector<double> VKalVrtAthena::VrtSecInclusive::m_BeamPosition

private

Definition at line 263 of file VrtSecInclusive.h.

m_checkPatternStrategy

Gaudi::Property<std::string> VKalVrtAthena::VrtSecInclusive::m_checkPatternStrategy {this, "CheckHitPatternStrategy", "Classical", "Either Classical or Extrapolation"}

private

Definition at line 287 of file VrtSecInclusive.h.

{this, "CheckHitPatternStrategy", "Classical", "Either Classical or Extrapolation"};

m_CutBLayHits

Gaudi::Property<int> VKalVrtAthena::VrtSecInclusive::m_CutBLayHits {this, "CutBLayHits", 0}

private

Definition at line 170 of file VrtSecInclusive.h.

{this, "CutBLayHits", 0};

m_CutPixelHits

Gaudi::Property<int> VKalVrtAthena::VrtSecInclusive::m_CutPixelHits {this, "CutPixelHits", 0}

private

Definition at line 168 of file VrtSecInclusive.h.

{this, "CutPixelHits", 0};

m_CutSctHits

Gaudi::Property<int> VKalVrtAthena::VrtSecInclusive::m_CutSctHits {this, "CutSctHits", 0}

private

Definition at line 167 of file VrtSecInclusive.h.

{this, "CutSctHits", 0};

m_CutSharedHits

Gaudi::Property<int> VKalVrtAthena::VrtSecInclusive::m_CutSharedHits {this, "CutSharedHits", 0}

private

Definition at line 171 of file VrtSecInclusive.h.

{this, "CutSharedHits", 0};

m_CutSiHits

Gaudi::Property<int> VKalVrtAthena::VrtSecInclusive::m_CutSiHits {this, "CutSiHits", 0}

private

Definition at line 169 of file VrtSecInclusive.h.

{this, "CutSiHits", 0};

m_CutTightSCTHits

Gaudi::Property<int> VKalVrtAthena::VrtSecInclusive::m_CutTightSCTHits {this, "CutTightSCTHits", 7}

private

Definition at line 173 of file VrtSecInclusive.h.

{this, "CutTightSCTHits", 7};

m_CutTightTRTHits

Gaudi::Property<int> VKalVrtAthena::VrtSecInclusive::m_CutTightTRTHits {this, "CutTightTRTHits", 20}

private

Definition at line 174 of file VrtSecInclusive.h.

{this, "CutTightTRTHits", 20};

m_CutTRTHits

Gaudi::Property<int> VKalVrtAthena::VrtSecInclusive::m_CutTRTHits {this, "CutTRTHits", 0}

private

Definition at line 172 of file VrtSecInclusive.h.

{this, "CutTRTHits", 0}; // Kazuki

m_d0TrkErrorCut

Gaudi::Property<double> VKalVrtAthena::VrtSecInclusive::m_d0TrkErrorCut {this, "TrkA0ErrCut", 10000}

private

Definition at line 157 of file VrtSecInclusive.h.

{this, "TrkA0ErrCut", 10000}; // in [mm]

m_d0TrkPVDstMaxCut

Gaudi::Property<double> VKalVrtAthena::VrtSecInclusive::m_d0TrkPVDstMaxCut {this, "a0TrkPVDstMaxCut", 1000.}

private

Definition at line 152 of file VrtSecInclusive.h.

{this, "a0TrkPVDstMaxCut", 1000.}; // in [mm]

m_d0TrkPVDstMinCut

Gaudi::Property<double> VKalVrtAthena::VrtSecInclusive::m_d0TrkPVDstMinCut {this, "a0TrkPVDstMinCut", 0. }

private

Definition at line 151 of file VrtSecInclusive.h.

{this, "a0TrkPVDstMinCut", 0. }; // in [mm]

m_d0TrkPVSignifCut

Gaudi::Property<double> VKalVrtAthena::VrtSecInclusive::m_d0TrkPVSignifCut {this, "a0TrkPVSignifCut", 0.}

private

Definition at line 153 of file VrtSecInclusive.h.

{this, "a0TrkPVSignifCut", 0.}; // in [mm]

m_decor_is_svtrk_final

std::optional< SG::Decorator< char > > VKalVrtAthena::VrtSecInclusive::m_decor_is_svtrk_final

private

Definition at line 294 of file VrtSecInclusive.h.

m_decor_isAssociated

std::optional< SG::Decorator< char > > VKalVrtAthena::VrtSecInclusive::m_decor_isAssociated

private

Definition at line 293 of file VrtSecInclusive.h.

m_decor_isSelected

std::optional< SG::Decorator< char > > VKalVrtAthena::VrtSecInclusive::m_decor_isSelected

private

Definition at line 292 of file VrtSecInclusive.h.

m_decor_svLink

std::optional< VertexELType > VKalVrtAthena::VrtSecInclusive::m_decor_svLink

private

Definition at line 309 of file VrtSecInclusive.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_do_d0Cut

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_do_d0Cut {this, "do_d0Cut", true}

private

Definition at line 143 of file VrtSecInclusive.h.

{this, "do_d0Cut", true};

m_do_d0errCut

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_do_d0errCut {this, "do_d0errCut", false}

private

Definition at line 145 of file VrtSecInclusive.h.

{this, "do_d0errCut", false};

m_do_d0signifCut

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_do_d0signifCut {this, "do_d0signifCut", false}

private

Definition at line 147 of file VrtSecInclusive.h.

{this, "do_d0signifCut", false};

m_do_PVvetoCut

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_do_PVvetoCut {this, "do_PVvetoCut", true}

private

Definition at line 142 of file VrtSecInclusive.h.

{this, "do_PVvetoCut", true};

m_do_z0Cut

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_do_z0Cut {this, "do_z0Cut", true}

private

Definition at line 144 of file VrtSecInclusive.h.

{this, "do_z0Cut", true};

m_do_z0errCut

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_do_z0errCut {this, "do_z0errCut", false}

private

Definition at line 146 of file VrtSecInclusive.h.

{this, "do_z0errCut", false};

m_do_z0signifCut

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_do_z0signifCut {this, "do_z0signifCut", false}

private

Definition at line 148 of file VrtSecInclusive.h.

{this, "do_z0signifCut", false};

m_doAssociateNonSelectedTracks

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_doAssociateNonSelectedTracks {this, "doAssociateNonSelectedTracks", false}

private

Definition at line 190 of file VrtSecInclusive.h.

{this, "doAssociateNonSelectedTracks", false};

m_doAugmentDVimpactParametersToElectrons

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_doAugmentDVimpactParametersToElectrons {this, "doAugmentDVimpactParametersToElectrons", false}

private

Definition at line 243 of file VrtSecInclusive.h.

{this, "doAugmentDVimpactParametersToElectrons", false}; // potentially useful for analyses involving electrons

m_doAugmentDVimpactParametersToMuons

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_doAugmentDVimpactParametersToMuons {this, "doAugmentDVimpactParametersToMuons", false}

private

Definition at line 242 of file VrtSecInclusive.h.

{this, "doAugmentDVimpactParametersToMuons", false};     // potentially useful for DV + muon search

m_doDisappearingTrackVertexing

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_doDisappearingTrackVertexing {this, "doDisappearingTrackVertexing", false}

private

Definition at line 231 of file VrtSecInclusive.h.

{this, "doDisappearingTrackVertexing", false};

m_doFastMode

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_doFastMode {this, "DoFastMode", false}

private

Definition at line 135 of file VrtSecInclusive.h.

{this, "DoFastMode", false}; // flag for running in rapid finder mode instead of using graph

m_doFinalImproveChi2

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_doFinalImproveChi2 {this, "doFinalImproveChi2", false}

private

Definition at line 191 of file VrtSecInclusive.h.

{this, "doFinalImproveChi2", false};

m_doIntersectionPos

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_doIntersectionPos {this, "DoIntersectionPos", false}

private

Definition at line 129 of file VrtSecInclusive.h.

{this, "DoIntersectionPos", false};

m_doMagnetMerging

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_doMagnetMerging {this, "doMagnetMerging", true}

private

Definition at line 187 of file VrtSecInclusive.h.

{this, "doMagnetMerging", true}; // sub-option of doMergeByShuffling-2

m_doMapToLocal

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_doMapToLocal {this, "DoMapToLocal", false}

private

Definition at line 130 of file VrtSecInclusive.h.

{this, "DoMapToLocal", false};

m_doMergeByShuffling

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_doMergeByShuffling {this, "doMergeByShuffling", false}

private

Definition at line 185 of file VrtSecInclusive.h.

{this, "doMergeByShuffling", false};

m_doMergeFinalVerticesDistance

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_doMergeFinalVerticesDistance {this, "doMergeFinalVerticesDistance", false}

private

Definition at line 189 of file VrtSecInclusive.h.

{this, "doMergeFinalVerticesDistance", false}; // Kazuki

m_doPVcompatibilityCut

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_doPVcompatibilityCut {this, "DoPVcompatibility", true}

private

Definition at line 180 of file VrtSecInclusive.h.

{this, "DoPVcompatibility", true};

m_doReassembleVertices

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_doReassembleVertices {this, "doReassembleVertices", false}

private

Definition at line 184 of file VrtSecInclusive.h.

{this, "doReassembleVertices", false};

m_doRemoveCaloTaggedMuons

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_doRemoveCaloTaggedMuons {this, "doRemoveCaloTaggedMuons", false}

private

Definition at line 225 of file VrtSecInclusive.h.

{this, "doRemoveCaloTaggedMuons", false};

m_doRemoveNonLeptonVertices

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_doRemoveNonLeptonVertices {this, "doRemoveNonLeptonVertices", false}

private

Definition at line 228 of file VrtSecInclusive.h.

{this, "doRemoveNonLeptonVertices", false};

m_doSelectIDAndGSFTracks

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_doSelectIDAndGSFTracks {this, "doSelectIDAndGSFTracks", false}

private

Definition at line 227 of file VrtSecInclusive.h.

{this, "doSelectIDAndGSFTracks", false};

m_doSelectTracksFromElectrons

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_doSelectTracksFromElectrons {this, "doSelectTracksFromElectrons", false}

private

Definition at line 226 of file VrtSecInclusive.h.

{this, "doSelectTracksFromElectrons", false};

m_doSelectTracksFromMuons

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_doSelectTracksFromMuons {this, "doSelectTracksFromMuons", false}

private

Definition at line 224 of file VrtSecInclusive.h.

{this, "doSelectTracksFromMuons", false};

m_doSelectTracksWithLRTCuts

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_doSelectTracksWithLRTCuts {this, "doSelectTracksWithLRTCuts", false}

private

Definition at line 239 of file VrtSecInclusive.h.

{this, "doSelectTracksWithLRTCuts", false};

m_doSuggestedRefitOnMerging

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_doSuggestedRefitOnMerging {this, "doSuggestedRefitOnMerging", true}

private

Definition at line 186 of file VrtSecInclusive.h.

{this, "doSuggestedRefitOnMerging", true};

m_doTightPVcompatibilityCut

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_doTightPVcompatibilityCut {this, "DoTightPVcompatibility", false}

private

Definition at line 181 of file VrtSecInclusive.h.

{this, "DoTightPVcompatibility", false};

m_doTRTPixCut

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_doTRTPixCut {this, "doTRTPixCut", false, "mode for R-hadron displaced vertex"}

private

Definition at line 166 of file VrtSecInclusive.h.

{this, "doTRTPixCut", false, "mode for R-hadron displaced vertex"}; // Kazuki

m_doTruth

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_doTruth {this, "DoTruth", false}

private

Definition at line 125 of file VrtSecInclusive.h.

{this, "DoTruth", false};

m_doTwoTrSoftBtag

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_doTwoTrSoftBtag {this, "DoTwoTrSoftBtag", false}

private

Definition at line 199 of file VrtSecInclusive.h.

{this, "DoTwoTrSoftBtag", false};

m_doWildMerging

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_doWildMerging {this, "doWildMerging", true}

private

Definition at line 188 of file VrtSecInclusive.h.

{this, "doWildMerging", true}; // sub-option of doMergeByShuffling-3

m_ElectronLocation

SG::ReadHandleKey<xAOD::ElectronContainer> VKalVrtAthena::VrtSecInclusive::m_ElectronLocation {this, "ElectronLocation", "Electrons"}

private

Definition at line 114 of file VrtSecInclusive.h.

{this, "ElectronLocation", "Electrons"};

m_eventInfoKey

SG::ReadHandleKey<xAOD::EventInfo> VKalVrtAthena::VrtSecInclusive::m_eventInfoKey {this,"EventInfoKey", "EventInfo", "EventInfo name"}

private

Read/Write Handle Keys.

Definition at line 298 of file VrtSecInclusive.h.

{this,"EventInfoKey", "EventInfo", "EventInfo name"};

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects

privateinherited

Definition at line 79 of file AthAlgorithm.h.

m_extrapolatedPatternBank

PatternBank VKalVrtAthena::VrtSecInclusive::m_extrapolatedPatternBank

private

Definition at line 372 of file VrtSecInclusive.h.

m_extrapolator

PublicToolHandle<Trk::IExtrapolator> VKalVrtAthena::VrtSecInclusive::m_extrapolator {this, "Extrapolator", "Trk::Extrapolator/AtlasExtrapolator"}

private

Definition at line 276 of file VrtSecInclusive.h.

{this, "Extrapolator", "Trk::Extrapolator/AtlasExtrapolator"};

m_extrapPV

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_extrapPV {this, "ExtrapPV", false}

private

Definition at line 131 of file VrtSecInclusive.h.

{this, "ExtrapPV", false}; //extrapolate reco and prim truth trks to PV (for testing only)

m_FillHist

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_FillHist {this, "FillHist", false}

private

Definition at line 126 of file VrtSecInclusive.h.

{this, "FillHist", false};

m_FillIntermediateVertices

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_FillIntermediateVertices {this, "FillIntermediateVertices", false}

private

Definition at line 128 of file VrtSecInclusive.h.

{this, "FillIntermediateVertices", false};

m_FillNtuple

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_FillNtuple {this, "FillNtuple", false}

private

Definition at line 127 of file VrtSecInclusive.h.

{this, "FillNtuple", false};

m_fitSvc

ToolHandle<Trk::ITrkVKalVrtFitter> VKalVrtAthena::VrtSecInclusive::m_fitSvc {this, "VertexFitterTool", "Trk::TrkVKalVrtFitter", " Private TrkVKalVrtFitter"}

private

Definition at line 270 of file VrtSecInclusive.h.

{this, "VertexFitterTool", "Trk::TrkVKalVrtFitter", " Private TrkVKalVrtFitter"};       // VKalVrtFitter tool

m_geoModel

Gaudi::Property<int> VKalVrtAthena::VrtSecInclusive::m_geoModel {this, "GeoModel", VKalVrtAthena::GeoModel::Run2}

private

Definition at line 110 of file VrtSecInclusive.h.

{this, "GeoModel", VKalVrtAthena::GeoModel::Run2};

m_hists

std::map<std::string, TH1*> VKalVrtAthena::VrtSecInclusive::m_hists

private

Definition at line 321 of file VrtSecInclusive.h.

m_ImpactWrtBL

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_ImpactWrtBL {this, "ImpactWrtBL", true}

private

Definition at line 150 of file VrtSecInclusive.h.

{this, "ImpactWrtBL", true}; // false option is going to be deprecated

m_improveChi2ProbThreshold

Gaudi::Property<double> VKalVrtAthena::VrtSecInclusive::m_improveChi2ProbThreshold {this, "improveChi2ProbThreshold", 1.e-4}

private

Definition at line 221 of file VrtSecInclusive.h.

{this, "improveChi2ProbThreshold", 1.e-4};

m_incomp

std::vector< std::pair<int, int> > VKalVrtAthena::VrtSecInclusive::m_incomp

private

Definition at line 374 of file VrtSecInclusive.h.

m_intermediateVertexKey

std::map<std::string, SG::WriteHandleKey<xAOD::VertexContainer> > VKalVrtAthena::VrtSecInclusive::m_intermediateVertexKey

private

Definition at line 301 of file VrtSecInclusive.h.

m_ipDecors

std::vector< IPDecoratorType > VKalVrtAthena::VrtSecInclusive::m_ipDecors

private

Definition at line 306 of file VrtSecInclusive.h.

m_leptonicTracks

std::vector<const xAOD::TrackParticle*> VKalVrtAthena::VrtSecInclusive::m_leptonicTracks

private

Definition at line 262 of file VrtSecInclusive.h.

m_matchMap

std::map<const xAOD::TruthVertex*, bool> VKalVrtAthena::VrtSecInclusive::m_matchMap

private

Definition at line 377 of file VrtSecInclusive.h.

m_maxWrkVertices

Gaudi::Property<size_t> VKalVrtAthena::VrtSecInclusive::m_maxWrkVertices {this, "MaxNumberOfWorkingVertices", 1500}

private

Definition at line 208 of file VrtSecInclusive.h.

{this, "MaxNumberOfWorkingVertices", 1500};

m_mcEventContainerName

Gaudi::Property<std::string> VKalVrtAthena::VrtSecInclusive::m_mcEventContainerName {this, "MCEventContainer", "TruthEvents"}

private

Definition at line 117 of file VrtSecInclusive.h.

{this, "MCEventContainer", "TruthEvents"};

m_mcTrkResolution

Gaudi::Property<double> VKalVrtAthena::VrtSecInclusive::m_mcTrkResolution {this, "MCTrackResolution", 0.06}

private

Definition at line 246 of file VrtSecInclusive.h.

{this, "MCTrackResolution", 0.06}; // see getTruth for explanation

m_mergeByShufflingAllowance

Gaudi::Property<double> VKalVrtAthena::VrtSecInclusive::m_mergeByShufflingAllowance {this, "mergeByShufflingAllowance", 4.}

private

Definition at line 219 of file VrtSecInclusive.h.

{this, "mergeByShufflingAllowance", 4.}; // in unit of sigma

m_mergeByShufflingMaxSignificance

Gaudi::Property<double> VKalVrtAthena::VrtSecInclusive::m_mergeByShufflingMaxSignificance {this, "mergeByShufflingMaxSignificance", 100.}

private

Definition at line 218 of file VrtSecInclusive.h.

{this, "mergeByShufflingMaxSignificance", 100.}; // in unit of sigma

m_MuonLocation

SG::ReadHandleKey<xAOD::MuonContainer> VKalVrtAthena::VrtSecInclusive::m_MuonLocation {this, "MuonLocation", "Muons"}

private

Definition at line 113 of file VrtSecInclusive.h.

{this, "MuonLocation",  "Muons"};

m_ntupleVars

std::unique_ptr<NtupleVars> VKalVrtAthena::VrtSecInclusive::m_ntupleVars

private

Definition at line 318 of file VrtSecInclusive.h.

m_passThroughTrackSelection

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_passThroughTrackSelection {this, "PassThroughTrackSelection", false }

private

Definition at line 133 of file VrtSecInclusive.h.

{this, "PassThroughTrackSelection", false };

m_patternStrategyFuncs

std::map<std::string, PatternStrategyFunc> VKalVrtAthena::VrtSecInclusive::m_patternStrategyFuncs

private

Definition at line 289 of file VrtSecInclusive.h.

m_pixelCondSummaryTool

ToolHandle<IInDetConditionsTool> VKalVrtAthena::VrtSecInclusive::m_pixelCondSummaryTool {this, "PixelConditionsSummaryTool", "PixelConditionsSummaryTool", "Tool to retrieve Pixel Conditions summary"}

private

Condition service.

Definition at line 280 of file VrtSecInclusive.h.

{this, "PixelConditionsSummaryTool", "PixelConditionsSummaryTool", "Tool to retrieve Pixel Conditions summary"};

m_pixelId

const PixelID* VKalVrtAthena::VrtSecInclusive::m_pixelId {}

private

Definition at line 284 of file VrtSecInclusive.h.

{};

m_primaryVertices

const xAOD::VertexContainer* VKalVrtAthena::VrtSecInclusive::m_primaryVertices {}

private

Definition at line 258 of file VrtSecInclusive.h.

{};

m_PrimVrtLocation

SG::ReadHandleKey<xAOD::VertexContainer> VKalVrtAthena::VrtSecInclusive::m_PrimVrtLocation {this, "PrimVrtLocation", "PrimaryVertices"}

private

Definition at line 115 of file VrtSecInclusive.h.

{this, "PrimVrtLocation", "PrimaryVertices"};

m_pvCompatibilityCut

Gaudi::Property<double> VKalVrtAthena::VrtSecInclusive::m_pvCompatibilityCut {this, "PVcompatibilityCut", -20.}

private

Definition at line 192 of file VrtSecInclusive.h.

{this, "PVcompatibilityCut", -20.}; // in [mm]

m_reassembleMaxImpactParameterD0

Gaudi::Property<double> VKalVrtAthena::VrtSecInclusive::m_reassembleMaxImpactParameterD0 {this, "reassembleMaxImpactParameterD0", 1.}

private

Definition at line 216 of file VrtSecInclusive.h.

{this, "reassembleMaxImpactParameterD0",  1.}; // wrt. DV in [mm]

m_reassembleMaxImpactParameterZ0

Gaudi::Property<double> VKalVrtAthena::VrtSecInclusive::m_reassembleMaxImpactParameterZ0 {this, "reassembleMaxImpactParameterZ0", 5.}

private

Definition at line 217 of file VrtSecInclusive.h.

{this, "reassembleMaxImpactParameterZ0",  5.}; // wrt. DV in [mm]

m_removeFakeVrt

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_removeFakeVrt {this, "RemoveFake2TrkVrt", true}

private

Definition at line 182 of file VrtSecInclusive.h.

{this, "RemoveFake2TrkVrt", true};

m_removeFakeVrtLate

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_removeFakeVrtLate {this, "DoDelayedFakeReject", false}

private

Definition at line 183 of file VrtSecInclusive.h.

{this, "DoDelayedFakeReject", false};

m_SAloneTRT

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_SAloneTRT {this, "DoSAloneTRT", false}

private

Definition at line 139 of file VrtSecInclusive.h.

{this, "DoSAloneTRT", false}; // SAlone = "standalone"

m_sctCondSummaryTool

ToolHandle<IInDetConditionsTool> VKalVrtAthena::VrtSecInclusive::m_sctCondSummaryTool {this, "InDetSCT_ConditionsSummaryTool", "SCT_ConditionsSummaryTool/InDetSCT_ConditionsSummaryTool", "Tool to retrieve SCT conditions summary"}

private

Definition at line 281 of file VrtSecInclusive.h.

{this, "InDetSCT_ConditionsSummaryTool", "SCT_ConditionsSummaryTool/InDetSCT_ConditionsSummaryTool", "Tool to retrieve SCT conditions summary"};

m_sctId

const SCT_ID* VKalVrtAthena::VrtSecInclusive::m_sctId {}

private

Definition at line 285 of file VrtSecInclusive.h.

{};

m_secondaryVerticesContainerName

Gaudi::Property<std::string> VKalVrtAthena::VrtSecInclusive::m_secondaryVerticesContainerName {this, "SecondaryVerticesContainerName", "SecondaryVertices"}

private

Definition at line 122 of file VrtSecInclusive.h.

{this, "SecondaryVerticesContainerName", "SecondaryVertices"};

m_selectedTracks

std::vector<const xAOD::TrackParticle*> VKalVrtAthena::VrtSecInclusive::m_selectedTracks

private

Definition at line 260 of file VrtSecInclusive.h.

m_SelTrkMaxCutoff

Gaudi::Property<unsigned int> VKalVrtAthena::VrtSecInclusive::m_SelTrkMaxCutoff {this, "SelTrkMaxCutoff", 50}

private

Definition at line 138 of file VrtSecInclusive.h.

{this, "SelTrkMaxCutoff", 50}; // max number of tracks

m_SelVrtChi2Cut

Gaudi::Property<double> VKalVrtAthena::VrtSecInclusive::m_SelVrtChi2Cut {this, "SelVrtChi2Cut", 4.5}

private

Definition at line 193 of file VrtSecInclusive.h.

{this, "SelVrtChi2Cut", 4.5}; // in terms of chi2 / ndof

m_thePV

const xAOD::Vertex* VKalVrtAthena::VrtSecInclusive::m_thePV {}

private

Definition at line 259 of file VrtSecInclusive.h.

{};

m_tracingTruthVertices

std::vector<const xAOD::TruthVertex*> VKalVrtAthena::VrtSecInclusive::m_tracingTruthVertices

private

Definition at line 567 of file VrtSecInclusive.h.

m_TrackDetachCut

Gaudi::Property<double> VKalVrtAthena::VrtSecInclusive::m_TrackDetachCut {this, "TrackDetachCut", 6}

private

Definition at line 197 of file VrtSecInclusive.h.

{this, "TrackDetachCut", 6};

m_TrackLocation

SG::ReadHandleKey<xAOD::TrackParticleContainer> VKalVrtAthena::VrtSecInclusive::m_TrackLocation {this, "TrackLocation", "InDetTrackParticles"}

private

Definition at line 112 of file VrtSecInclusive.h.

{this, "TrackLocation", "InDetTrackParticles"};

m_trackSelectionAlgs

std::vector<TrackSelectionAlg> VKalVrtAthena::VrtSecInclusive::m_trackSelectionAlgs

private

Definition at line 392 of file VrtSecInclusive.h.

m_trackSelectionFuncs

std::vector<CutFunc> VKalVrtAthena::VrtSecInclusive::m_trackSelectionFuncs

private

Definition at line 396 of file VrtSecInclusive.h.

m_trackToVertexIPEstimatorTool

PublicToolHandle<Trk::ITrackToVertexIPEstimator> VKalVrtAthena::VrtSecInclusive::m_trackToVertexIPEstimatorTool {this, "TrackToVertexIPEstimatorTool", "Trk::TrackToVertexIPEstimator/TrackToVertexIPEstimator"}

private

Definition at line 275 of file VrtSecInclusive.h.

{this, "TrackToVertexIPEstimatorTool", "Trk::TrackToVertexIPEstimator/TrackToVertexIPEstimator"};

m_trackToVertexTool

PublicToolHandle< Reco::ITrackToVertex > VKalVrtAthena::VrtSecInclusive::m_trackToVertexTool {this, "TrackToVertexTool", "Reco::TrackToVertex"}

private

get a handle on the Track to Vertex tool

Definition at line 274 of file VrtSecInclusive.h.

{this, "TrackToVertexTool", "Reco::TrackToVertex"};

m_tree_Vert

TTree* VKalVrtAthena::VrtSecInclusive::m_tree_Vert {}

private

Definition at line 317 of file VrtSecInclusive.h.

{};

m_TrkChi2Cut

Gaudi::Property<double> VKalVrtAthena::VrtSecInclusive::m_TrkChi2Cut {this, "TrkChi2Cut", 3.}

private

Definition at line 162 of file VrtSecInclusive.h.

{this, "TrkChi2Cut", 3.}; // in terms of chi2 / ndof

m_trkDecors

std::map< unsigned, SG::Decorator<float> > VKalVrtAthena::VrtSecInclusive::m_trkDecors

private

Definition at line 295 of file VrtSecInclusive.h.

m_trkExtrapolator

Gaudi::Property<int> VKalVrtAthena::VrtSecInclusive::m_trkExtrapolator {this, "TrkExtrapolator", 2}

private

Definition at line 177 of file VrtSecInclusive.h.

{this, "TrkExtrapolator", 2};

m_TrkPtCut

Gaudi::Property<double> VKalVrtAthena::VrtSecInclusive::m_TrkPtCut {this, "TrkPtCut", 1000.}

private

Definition at line 163 of file VrtSecInclusive.h.

{this, "TrkPtCut", 1000.}; // low pT threshold. in [MeV]

m_truncateWrkVertices

Gaudi::Property<bool> VKalVrtAthena::VrtSecInclusive::m_truncateWrkVertices {this, "TruncateListOfWorkingVertices", true}

private

Definition at line 207 of file VrtSecInclusive.h.

{this, "TruncateListOfWorkingVertices", true};

m_truthParticleContainerName

Gaudi::Property<std::string> VKalVrtAthena::VrtSecInclusive::m_truthParticleContainerName {this, "McParticleContainer", "TruthParticles"}

private

Definition at line 116 of file VrtSecInclusive.h.

{this, "McParticleContainer", "TruthParticles"};

m_truthParticleFilter

Gaudi::Property<std::string> VKalVrtAthena::VrtSecInclusive::m_truthParticleFilter {this, "TruthParticleFilter", "Rhadron"}

private

Definition at line 119 of file VrtSecInclusive.h.

{this, "TruthParticleFilter", "Rhadron"};// Either "", "Kshort", "Rhadron", "HNL", "HadInt", "Bhadron"

m_truthToTrack

PublicToolHandle<Trk::ITruthToTrack> VKalVrtAthena::VrtSecInclusive::m_truthToTrack {this, "TruthToTrack", "Trk::TruthToTrack/InDetTruthToTrack"}

private

Definition at line 271 of file VrtSecInclusive.h.

{this, "TruthToTrack", "Trk::TruthToTrack/InDetTruthToTrack"}; // tool to create trkParam from genPart

m_TruthTrkLen

Gaudi::Property<double> VKalVrtAthena::VrtSecInclusive::m_TruthTrkLen {this, "TruthTrkLen", 1000}

private

Definition at line 247 of file VrtSecInclusive.h.

{this, "TruthTrkLen", 1000}; // in [mm]

m_twoTrksVertexKey

SG::WriteHandleKey<xAOD::VertexContainer> VKalVrtAthena::VrtSecInclusive::m_twoTrksVertexKey {this, "TwoTracksVertexKey", "", "Two Tracks Vertex key"}

private

Definition at line 300 of file VrtSecInclusive.h.

{this, "TwoTracksVertexKey", "", "Two Tracks Vertex key"};

m_twoTrkVtxFormingD0Cut

Gaudi::Property<double> VKalVrtAthena::VrtSecInclusive::m_twoTrkVtxFormingD0Cut {this, "twoTrkVtxFormingD0Cut", 1.}

private

Definition at line 159 of file VrtSecInclusive.h.

{this, "twoTrkVtxFormingD0Cut", 1.}; // in [mm]

m_twoTrVrtAngleCut

Gaudi::Property<double> VKalVrtAthena::VrtSecInclusive::m_twoTrVrtAngleCut {this, "TwoTrVrtAngleCut", -10}

private

Definition at line 200 of file VrtSecInclusive.h.

{this, "TwoTrVrtAngleCut", -10};

m_twoTrVrtMaxPerigeeDist

Gaudi::Property<double> VKalVrtAthena::VrtSecInclusive::m_twoTrVrtMaxPerigeeDist {this, "twoTrVrtMaxPerigeeDist", 50}

private

Definition at line 232 of file VrtSecInclusive.h.

{this, "twoTrVrtMaxPerigeeDist", 50}; // in [mm]

m_twoTrVrtMinDistFromPV

Gaudi::Property<double> VKalVrtAthena::VrtSecInclusive::m_twoTrVrtMinDistFromPV {this, "TwoTrVrtMinDistFromPVCut", 0.}

private

Definition at line 201 of file VrtSecInclusive.h.

{this, "TwoTrVrtMinDistFromPVCut", 0.};

m_twoTrVrtMinRadius

Gaudi::Property<double> VKalVrtAthena::VrtSecInclusive::m_twoTrVrtMinRadius {this, "twoTrVrtMinRadius", 50}

private

Definition at line 233 of file VrtSecInclusive.h.

{this, "twoTrVrtMinRadius", 50}; // in [mm]

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vertexCollectionsDefinitions

std::unordered_map<std::string, bool> VKalVrtAthena::VrtSecInclusive::m_vertexCollectionsDefinitions

private

Definition at line 583 of file VrtSecInclusive.h.

m_vertexingAlgorithms

std::vector< std::pair<std::string, vertexingAlg> > VKalVrtAthena::VrtSecInclusive::m_vertexingAlgorithms

private

Definition at line 440 of file VrtSecInclusive.h.

m_vertexingAlgorithmStep

unsigned VKalVrtAthena::VrtSecInclusive::m_vertexingAlgorithmStep = 0U

private

Definition at line 441 of file VrtSecInclusive.h.

m_vertexingStatus

int VKalVrtAthena::VrtSecInclusive::m_vertexingStatus = 0

private

Definition at line 255 of file VrtSecInclusive.h.

m_vertexingStatusKey

SG::WriteDecorHandleKey<xAOD::EventInfo> VKalVrtAthena::VrtSecInclusive::m_vertexingStatusKey {this, "VertexingStatusKey", m_eventInfoKey, ""}

private

Definition at line 303 of file VrtSecInclusive.h.

{this, "VertexingStatusKey", m_eventInfoKey, ""};

m_vertexKey

SG::WriteHandleKey<xAOD::VertexContainer> VKalVrtAthena::VrtSecInclusive::m_vertexKey {this, "VertexKey", "", "Vertex key"}

private

Definition at line 299 of file VrtSecInclusive.h.

{this, "VertexKey", "", "Vertex key"};

m_vertexMapper

PublicToolHandle<Trk::IVertexMapper> VKalVrtAthena::VrtSecInclusive::m_vertexMapper {this, "VertexMapper", ""}

private

Definition at line 277 of file VrtSecInclusive.h.

{this, "VertexMapper", ""};

m_VertexMergeCut

Gaudi::Property<double> VKalVrtAthena::VrtSecInclusive::m_VertexMergeCut {this, "VertexMergeCut", 3}

private

Definition at line 196 of file VrtSecInclusive.h.

{this, "VertexMergeCut", 3};

m_VertexMergeFinalDistCut

Gaudi::Property<double> VKalVrtAthena::VrtSecInclusive::m_VertexMergeFinalDistCut {this, "VertexMergeFinalDistCut", 1.}

private

Definition at line 194 of file VrtSecInclusive.h.

{this, "VertexMergeFinalDistCut", 1.}; // in [mm] // Kazuki

m_VertexMergeFinalDistScaling

Gaudi::Property<double> VKalVrtAthena::VrtSecInclusive::m_VertexMergeFinalDistScaling {this, "VertexMergeFinalDistScaling", 0.}

private

Definition at line 195 of file VrtSecInclusive.h.

{this, "VertexMergeFinalDistScaling", 0.}; // in [1/mm]

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_z0TrkErrorCut

Gaudi::Property<double> VKalVrtAthena::VrtSecInclusive::m_z0TrkErrorCut {this, "TrkZErrCut", 20000}

private

Definition at line 158 of file VrtSecInclusive.h.

{this, "TrkZErrCut", 20000}; // in [mm]

m_z0TrkPVDstMaxCut

Gaudi::Property<double> VKalVrtAthena::VrtSecInclusive::m_z0TrkPVDstMaxCut {this, "zTrkPVDstMaxCut", 1000.}

private

Definition at line 155 of file VrtSecInclusive.h.

{this, "zTrkPVDstMaxCut", 1000.}; // in [mm]

m_z0TrkPVDstMinCut

Gaudi::Property<double> VKalVrtAthena::VrtSecInclusive::m_z0TrkPVDstMinCut {this, "zTrkPVDstMinCut", 0.}

private

Definition at line 154 of file VrtSecInclusive.h.

{this, "zTrkPVDstMinCut", 0.}; // in [mm]

m_z0TrkPVSignifCut

Gaudi::Property<double> VKalVrtAthena::VrtSecInclusive::m_z0TrkPVSignifCut {this, "zTrkPVSignifCut", 0.}

private

Definition at line 156 of file VrtSecInclusive.h.

{this, "zTrkPVSignifCut", 0.}; // in unit of sigma

---

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

• VrtSecInclusive.h
• AANT_Tools.cxx
• TrackSelectionAlgs.cxx
• TruthAlgs.cxx
• Reconstruction/VKalVrt/VrtSecInclusive/src/Utilities.cxx
• VertexingAlgs.cxx
• VrtSecInclusive.cxx
• Reconstruction/VKalVrt/VrtSecInclusive/VrtSecInclusive/details/Utilities.h