Rec::NewVrtSecInclusiveTool Class Reference

#include <NewVrtSecInclusiveTool.h>

Inheritance diagram for Rec::NewVrtSecInclusiveTool:

Collaboration diagram for Rec::NewVrtSecInclusiveTool:

Classes
struct	DevTuple
struct	Hists
struct	Vrt2Tr
struct	WrkVrt

Public Member Functions
	NewVrtSecInclusiveTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~NewVrtSecInclusiveTool ()
StatusCode	initialize ()
StatusCode	finalize ()
std::unique_ptr< Trk::VxSecVertexInfo >	findAllVertices (const std::vector< const xAOD::TrackParticle * > &inputTracks, const xAOD::Vertex &primaryVertex) const final
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	sysInitialize () override
	Perform system initialization for an algorithm.
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

Static Public Member Functions
static const InterfaceID &	interfaceID ()

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
using	compatibilityGraph_t = boost::adjacency_list<boost::listS, boost::vecS, boost::undirectedS>
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
void	lockDecorations (const std::vector< const xAOD::TrackParticle * > &inpTrk) const
int	getIdHF (const xAOD::TrackParticle *TP) const
std::vector< xAOD::Vertex * >	getVrtSecMulti (workVectorArrxAOD *inpParticlesxAOD, const xAOD::Vertex &primVrt, compatibilityGraph_t &compatibilityGraph) const
void	printWrkSet (const std::vector< WrkVrt > *WrkSet, const std::string &name) const
ROOT::Math::PxPyPzEVector	momAtVrt (const std::vector< double > &inpTrk) const
double	minVrtVrtDist (std::vector< WrkVrt > *WrkVrtSet, int &indexV1, int &indexV2, std::vector< double > &check) const
double	distToMatLayerSignificance (Vrt2Tr &Vrt) const
double	refitVertex (WrkVrt &Vrt, std::vector< const xAOD::TrackParticle * > &SelectedTracks, Trk::IVKalState &istate, bool ifCovV0) const
double	refineVerticesWithCommonTracks (WrkVrt &v1, WrkVrt &v2, std::vector< const xAOD::TrackParticle * > &allTrackList, Trk::IVKalState &istate) const
double	mergeAndRefitVertices (WrkVrt &v1, WrkVrt &v2, WrkVrt &newvrt, std::vector< const xAOD::TrackParticle * > &AllTrackList, Trk::IVKalState &istate, int robKey=0) const
double	improveVertexChi2 (WrkVrt &vertex, std::vector< const xAOD::TrackParticle * > &allTracks, Trk::IVKalState &istate, bool ifCovV0) const
void	selGoodTrkParticle (workVectorArrxAOD *xAODwrk, const xAOD::Vertex &primVrt) const
void	select2TrVrt (std::vector< const xAOD::TrackParticle * > &SelectedTracks, const xAOD::Vertex &primVrt, std::map< long int, std::vector< double > > &vrt, compatibilityGraph_t &compatibilityGraph) const
Hists &	getHists () 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 const xAOD::TruthParticle *	getPreviousParent (const xAOD::TruthParticle *child)
static bool	isExcitedHadron (const xAOD::TruthParticle *tp)
static bool	isDisplaced (const xAOD::TrackParticle *tp)
static int	getG4Inter (const xAOD::TrackParticle *TP)
static int	getMCPileup (const xAOD::TrackParticle *TP)
static int	getProdVrtBarcode (const xAOD::TrackParticle *TP, float resolLimit=0.1)
static bool	checkTrue2TrVrt (const xAOD::TrackParticle *TP1, const xAOD::TrackParticle *TP2, float nearCut=0.1)
static double	massV0 (const std::vector< std::vector< double > > &TrkAtVrt, double massP, double massPi)
static double	vrtRadiusError (const Amg::Vector3D &secVrt, const std::vector< double > &vrtErr)
static int	nTrkCommon (std::vector< WrkVrt > *WrkVrtSet, int indexV1, int indexV2)
static bool	isPart (const std::deque< long int > &test, std::deque< long int > base)
static std::vector< double >	estimVrtPos (int nTrk, std::deque< long int > &selTrk, std::map< long int, std::vector< double > > &vrt)
static double	vrtVrtDist (const xAOD::Vertex &primVrt, const Amg::Vector3D &secVrt, const std::vector< double > &vrtErr, double &signif)
static double	vrtVrtDist2D (const xAOD::Vertex &primVrt, const Amg::Vector3D &secVrt, const std::vector< double > &vrtErr, double &signif)
static double	vrtVrtDist (const Amg::Vector3D &vrt1, const std::vector< double > &vrtErr1, const Amg::Vector3D &vrt2, const std::vector< double > &vrtErr2)
static double	PntPntDist (const Amg::Vector3D &Vrt1, const Amg::Vector3D &Vrt2)
static double	projSV_PV (const Amg::Vector3D &SV, const xAOD::Vertex &PV, const TLorentzVector &Direction)
static double	MomProjDist (const Amg::Vector3D &SV, const xAOD::Vertex &PV, const TLorentzVector &Direction)
static int	mostHeavyTrk (WrkVrt V, std::vector< const xAOD::TrackParticle * > AllTracks)
static void	getPixelDiscs (const xAOD::TrackParticle *Part, int &d0Hit, int &d1Hit, int &d2Hit)
static int	getIBLHit (const xAOD::TrackParticle *Part)
static int	getBLHit (const xAOD::TrackParticle *Part)

Private Attributes
double	m_w_1 {}
std::unique_ptr< Hists >	m_h
Gaudi::Property< bool >	m_fillHist {this, "FillHist", false, "Fill debugging and development histograms+ntuple" }
Gaudi::Property< int >	m_cutSctHits {this, "CutSctHits", 4, "Remove track if it has less SCT hits" }
Gaudi::Property< int >	m_cutPixelHits {this, "CutPixelHits", 2, "Remove track if it has less Pixel hits"}
Gaudi::Property< int >	m_cutTRTHits {this, "CutTRTHits", 10, "Remove track if it has less TRT hits"}
Gaudi::Property< int >	m_cutSiHits {this, "CutSiHits", 8, "Remove track if it has less Pixel+SCT hits" }
Gaudi::Property< int >	m_cutBLayHits {this, "CutBLayHits", 0, "Remove track if it has less B-layer hits" }
Gaudi::Property< int >	m_cutSharedHits {this,"CutSharedHits",1, "Reject final 2tr vertices if tracks have shared hits" }
Gaudi::Property< float >	m_cutPt {this, "CutPt", 500., "Track Pt selection cut" }
Gaudi::Property< float >	m_cutD0Min {this, "CutD0Min", 0., "Track minimal D0 selection cut" }
Gaudi::Property< float >	m_cutD0Max {this, "CutD0Max", 10., "Track maximal D0 selection cut" }
Gaudi::Property< float >	m_maxZVrt {this, "MaxZVrt", 15., "Track Z impact selection max"}
Gaudi::Property< float >	m_minZVrt {this, "MinZVrt", 0., "Track Z impact selection min"}
Gaudi::Property< float >	m_cutChi2 {this, "CutChi2", 5., "Track Chi2 selection cut" }
Gaudi::Property< float >	m_antiPileupSigRCut {this, "AntiPileupSigRCut", 2.0, "Upper cut on significance of 2D distance between beam and perigee" }
Gaudi::Property< float >	m_trkSigCut {this, "TrkSigCut", 2.0, "Track 3D impact significance w/r primary vertex. Should be >=AntiPileupSigRCut" }
Gaudi::Property< float >	m_dRdZRatioCut {this, "dRdZRatioCut", 0.25, "Cut on dR/dZ ratio to remove pileup tracks" }
Gaudi::Property< float >	m_fastZSVCut {this, "FastZSVCut", 10., "Cut to remove SV candidates based on fast SV estimation. To save full fit CPU." }
Gaudi::Property< float >	m_removeTrkMatSignif {this, "removeTrkMatSignif", 0., "Significance of Vertex-TrackingMaterial distance for removal. No removal if <=0." }
Gaudi::Property< float >	m_beampipeR {this, "BeampipeR", 24.3, "Radius of the beampipe material for aggressive material rejection" }
Gaudi::Property< float >	m_vrtMassLimit {this, "VrtMassLimit", 5500., "Maximal allowed mass for found vertices" }
Gaudi::Property< float >	m_globVrtProbCut {this, "GlobVrtProbCut", 0.005, "Cut on probability of any vertex for final selection" }
Gaudi::Property< float >	m_maxSVRadiusCut {this, "MaxSVRadiusCut", 140., "Cut on maximal radius of SV (def = Pixel detector size)" }
Gaudi::Property< float >	m_selVrtSigCut {this, "SelVrtSigCut", 3.0, "Cut on significance of 3D distance between vertex and PV" }
Gaudi::Property< float >	m_vertexMergeCut {this, "VertexMergeCut", 4., "To allow vertex merging for MultiVertex Finder" }
Gaudi::Property< bool >	m_multiWithOneTrkVrt {this, "MultiWithOneTrkVrt", true, "Allow one-track-vertex addition to already found secondary vertices"}
SG::ReadCondHandleKey< InDet::BeamSpotData >	m_beamSpotKey { this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" }
ToolHandle< Trk::IExtrapolator >	m_extrapolator {this,"ExtrapolatorName","Trk::Extrapolator/Extrapolator", "Name of the extrapolator tool"}
ToolHandle< Trk::TrkVKalVrtFitter >	m_fitSvc {this, "VertexFitterTool", "Trk::TrkVKalVrtFitter/VertexFitterTool", "Name of the Vertex Fitter tool"}
ToolHandle< Reco::ITrackToVertex >	m_trackToVertexTool {this, "TrackToVertexTool", "Reco::TrackToVertex/TrackToVertex", "Name of the TrackToVertex tool"}
ToolHandle< Rec::ITwoTrackVertexSelector >	m_ini_v2trselector
ToolHandle< Rec::ITwoTrackVertexSelector >	m_fin_v2trselector
Gaudi::Property< std::string >	m_augString {this, "AugmentingVersionString", "_NVSI", "Augmentation version string"}
double	m_massPi {}
double	m_massP {}
double	m_massE {}
double	m_massK0 {}
double	m_massLam {}
std::string	m_instanceName
SG::AuxElement::Decorator< char >	m_is_selected
SG::AuxElement::Decorator< char >	m_is_svtrk_final
SG::AuxElement::Decorator< float >	m_pt_wrtSV
SG::AuxElement::Decorator< float >	m_eta_wrtSV
SG::AuxElement::Decorator< float >	m_phi_wrtSV
SG::AuxElement::Decorator< float >	m_d0_wrtSV
SG::AuxElement::Decorator< float >	m_z0_wrtSV
SG::AuxElement::Decorator< float >	m_errP_wrtSV
SG::AuxElement::Decorator< float >	m_errd0_wrtSV
SG::AuxElement::Decorator< float >	m_errz0_wrtSV
SG::AuxElement::Decorator< float >	m_chi2_toSV
float	m_chiScale [11] {}
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 81 of file NewVrtSecInclusiveTool.h.

Member Typedef Documentation

compatibilityGraph_t

using Rec::NewVrtSecInclusiveTool::compatibilityGraph_t = boost::adjacency_list<boost::listS, boost::vecS, boost::undirectedS>

private

Definition at line 311 of file NewVrtSecInclusiveTool.h.

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

NewVrtSecInclusiveTool()

Rec::NewVrtSecInclusiveTool::NewVrtSecInclusiveTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Definition at line 30 of file NewVrtSecInclusiveTool.cxx.

                                                                    :
    AthAlgTool(type,name,parent),
    m_instanceName(name),
    m_is_selected("is_selected"),
    m_is_svtrk_final("is_svtrk_final"),
    m_pt_wrtSV("pt_wrtSV"),
    m_eta_wrtSV("eta_wrtSV"),
    m_phi_wrtSV("phi_wrtSV"),
    m_d0_wrtSV("d0_wrtSV"),
    m_z0_wrtSV("z0_wrtSV"),
    m_errP_wrtSV("errP_wrtSV"),
    m_errd0_wrtSV("errd0_wrtSV"),
    m_errz0_wrtSV("errz0_wrtSV"),
    m_chi2_toSV("chi2_toSV")
   {
//
// Declare additional interface
//
    declareInterface< IVrtInclusive >(this);
//
    m_massPi  =  Trk::ParticleMasses::mass[Trk::pion];
    m_massP   =  Trk::ParticleMasses::mass[Trk::proton];
    m_massE   =  Trk::ParticleMasses::mass[Trk::electron];
    m_massK0  =  Trk::ParticleMasses::mass[Trk::k0];
    m_massLam =  ParticleConstants::lambdaMassInMeV  ;
 
   }

~NewVrtSecInclusiveTool()

Rec::NewVrtSecInclusiveTool::~NewVrtSecInclusiveTool ( )

virtual

Definition at line 61 of file NewVrtSecInclusiveTool.cxx.

                                                   {
     ATH_MSG_DEBUG("NewVrtSecInclusiveTool destructor called");
   }

Member Function Documentation

checkTrue2TrVrt()

bool Rec::NewVrtSecInclusiveTool::checkTrue2TrVrt ( const xAOD::TrackParticle * TP1, const xAOD::TrackParticle * TP2, float nearCut = 0.1 )

staticprivate

Definition at line 365 of file Reconstruction/VKalVrt/NewVrtSecInclusiveTool/src/Utilities.cxx.

  {
     if( !TP1 || !TP2 )return false;
     static const SG::ConstAccessor<ElementLink<xAOD::TruthParticleContainer>> truthParticleLinkAcc( "truthParticleLink");
     if( !truthParticleLinkAcc.isAvailable(*TP1) ) return false;
     if( !truthParticleLinkAcc.isAvailable(*TP2) ) return false;
     const ElementLink<xAOD::TruthParticleContainer>& tplink1 = truthParticleLinkAcc( *TP1 );
     if( !tplink1.isValid() ) return false;
     const ElementLink<xAOD::TruthParticleContainer>& tplink2 = truthParticleLinkAcc( *TP2 );
     if( !tplink2.isValid() ) return false;
     const xAOD::TruthParticle *tpart1 = (*tplink1);        // truth particle for TrackPartile1
     const xAOD::TruthParticle *tpart2 = (*tplink2);        // truth particle for TrackPartile2
     //-----
     if(!tpart1->hasProdVtx()) return false;
     if(!tpart2->hasProdVtx()) return false;
     if(tpart1->prodVtx()->nOutgoingParticles()<2) return false;
     if(tpart2->prodVtx()->nOutgoingParticles()<2) return false;
     //-----
     Amg::Vector3D vpos1(tpart1->prodVtx()->x(),tpart1->prodVtx()->y(),tpart1->prodVtx()->z());
     Amg::Vector3D vpos2(tpart2->prodVtx()->x(),tpart2->prodVtx()->y(),tpart2->prodVtx()->z());
     return Amg::distance(vpos1,vpos2)<nearCut ? true : false;
  }

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::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());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::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());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::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; }

distToMatLayerSignificance()

double Rec::NewVrtSecInclusiveTool::distToMatLayerSignificance ( Vrt2Tr & Vrt ) const

private

Definition at line 389 of file Reconstruction/VKalVrt/NewVrtSecInclusiveTool/src/Utilities.cxx.

  { 
     const EventContext& ctx = Gaudi::Hive::currentContext();
     if(Vrt.fitVertex.perp()<20.) return 1.e9;
     double normP=1./Vrt.momentum.P();
     Amg::Vector3D momentumP(Vrt.momentum.Px()*normP,Vrt.momentum.Py()*normP,Vrt.momentum.Pz()*normP);
     Amg::Vector3D momentumN=-momentumP;
     
     const Trk::Layer * someLayer  = nullptr;
     const Trk::Layer * nextLayerP = nullptr;
     const Trk::Layer * nextLayerN = nullptr;
     const auto *volume = m_extrapolator->trackingGeometry()->lowestTrackingVolume(Vrt.fitVertex);
     someLayer = volume->associatedLayer(Vrt.fitVertex);
     const auto *material =  someLayer->layerMaterialProperties();
     if(material){
       nextLayerP=someLayer;
     } else {
       nextLayerP = someLayer->nextLayer(Vrt.fitVertex,momentumP);
       if(nextLayerP){ if(!nextLayerP->layerMaterialProperties())nextLayerP=nullptr; }
       nextLayerN = someLayer->nextLayer(Vrt.fitVertex,momentumN);
       if(nextLayerN){ if(!nextLayerN->layerMaterialProperties())nextLayerN=nullptr; }
     }
     momentumP *= 1.e5;   //100GeV to have straight trajectory
     double charge = 1.;
     const Trk::Perigee pseudoVrtPart(Vrt.fitVertex, momentumP, charge, Vrt.fitVertex);
 
     const Trk::TrackParameters * extrapParP=nullptr; //along momentum
     const Trk::TrackParameters * extrapParN=nullptr; //backward
     if(nextLayerP){ extrapParP = m_extrapolator->extrapolate(ctx, pseudoVrtPart,
                     nextLayerP->surfaceRepresentation(), Trk::anyDirection, false, Trk::nonInteractingMuon).release();}
     if(nextLayerN){ extrapParN = m_extrapolator->extrapolate(ctx, pseudoVrtPart,
                     nextLayerN->surfaceRepresentation(), Trk::anyDirection, false, Trk::nonInteractingMuon).release();}
 
     float distanceP=1.e9, distanceN=1.e9;
     if(extrapParP)distanceP=PntPntDist(extrapParP->position(), Vrt.fitVertex);
     if(extrapParN)distanceN=PntPntDist(extrapParN->position(), Vrt.fitVertex);
     if(distanceP==1.e9 && distanceN==1.e9) return 1.e9;
 
     //std::pair<const Trk::TrackParameters*,const Trk::Layer*> next= 
     //         m_extrapolator->extrapolateToNextActiveLayer(pseudoVrtPart,Trk::anyDirection,true,Trk::pion) ;
 
     double signif=1.e9;
     std::vector<double> pntCovar={1.e-2,0.,1.e-2,0.,0.,4.e-2};
     if(distanceP<distanceN)signif=vrtVrtDist(Vrt.fitVertex, Vrt.errorMatrix, extrapParP->position(), pntCovar);
     else                   signif=vrtVrtDist(Vrt.fitVertex, Vrt.errorMatrix, extrapParN->position(), pntCovar);
     delete extrapParP;
     delete extrapParN;
     return signif;
  }

estimVrtPos()

std::vector< double > Rec::NewVrtSecInclusiveTool::estimVrtPos ( int nTrk, std::deque< long int > & selTrk, std::map< long int, std::vector< double > > & vrt )

staticprivate

Definition at line 439 of file Reconstruction/VKalVrt/NewVrtSecInclusiveTool/src/Utilities.cxx.

  {
    std::vector<double> estimation(3,0.);
    int ntsel=selTrk.size();
    for( int i=0; i<ntsel-1; i++){
       for( int j=i+1; j<ntsel; j++){
          int k = selTrk[i]<selTrk[j] ? selTrk[i]*nTrk+selTrk[j] : selTrk[j]*nTrk+selTrk[i];
          estimation[0]+=vrt.at(k)[0];
          estimation[1]+=vrt[k][1];
          estimation[2]+=vrt[k][2];
    }  }
    estimation[0] /= ntsel*(ntsel-1)/2;
    estimation[1] /= ntsel*(ntsel-1)/2;
    estimation[2] /= ntsel*(ntsel-1)/2;
    return estimation;
  }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::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; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::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

finalize()

StatusCode Rec::NewVrtSecInclusiveTool::finalize

(

)

Definition at line 245 of file NewVrtSecInclusiveTool.cxx.

  {
    ATH_MSG_DEBUG("NewVrtSecInclusiveTool finalize()");
    return StatusCode::SUCCESS; 
  }

findAllVertices()

std::unique_ptr< Trk::VxSecVertexInfo > Rec::NewVrtSecInclusiveTool::findAllVertices ( const std::vector< const xAOD::TrackParticle * > & inputTracks, const xAOD::Vertex & primaryVertex ) const

finalvirtual

Implements Rec::IVrtInclusive.

Definition at line 253 of file NewVrtSecInclusiveTool.cxx.

  {
    std::vector<xAOD::Vertex*> listVrtSec(0);
 
    if(m_fillHist) {
      Hists& h = getHists();
      h.m_curTup->nTrk=0;
      h.m_curTup->n2Vrt=0;
      h.m_curTup->nNVrt=0;
    };
 
    workVectorArrxAOD * tmpVectxAOD=new workVectorArrxAOD();
    tmpVectxAOD->inpTrk.resize(inpTrk.size());
    std::copy(inpTrk.begin(),inpTrk.end(), tmpVectxAOD->inpTrk.begin());
    SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey };
    tmpVectxAOD->beamX=beamSpotHandle->beamPos().x();
    tmpVectxAOD->beamY=beamSpotHandle->beamPos().y();
    tmpVectxAOD->beamZ=beamSpotHandle->beamPos().z();
    tmpVectxAOD->tanBeamTiltX=tan(beamSpotHandle->beamTilt(0));
    tmpVectxAOD->tanBeamTiltY=tan(beamSpotHandle->beamTilt(1));
 
    compatibilityGraph_t compatibilityGraph;
    listVrtSec = getVrtSecMulti(tmpVectxAOD,primVrt,compatibilityGraph);
 
    for (const auto trk : tmpVectxAOD->listSelTracks) {
      // Mark the track as selected
      m_is_selected(*trk) = true;
      if (trk->trackFitter() == xAOD::GaussianSumFilter) m_is_selected(*xAOD::EgammaHelpers::getOriginalTrackParticleFromGSF(trk)) = true;
    }
    delete tmpVectxAOD;
 
    for (const auto &vrt : listVrtSec) {
      for (const auto &trk : vrt->trackParticleLinks()) {
 
        // Mark the track as a final track
        m_is_svtrk_final(**trk) = true;
 
        // Get the perigee of the track at the vertex
        ATH_MSG_VERBOSE(" > " << __FUNCTION__ << ": > Track index " << (*trk)->index() << ": Get the perigee of the track at the vertex." );
        auto sv_perigee = m_trackToVertexTool->perigeeAtVertex(Gaudi::Hive::currentContext(), **trk, vrt->position() );
        if( !sv_perigee ) {
          ATH_MSG_WARNING(" > " << __FUNCTION__ << ": > Track index " << (*trk)->index() << ": Failed in obtaining the SV perigee!" );
        }
 
        float qOverP_wrtSV    = sv_perigee ? sv_perigee->parameters() [Trk::qOverP] : -FLT_MAX;
        float theta_wrtSV     = sv_perigee ? sv_perigee->parameters() [Trk::theta] : -FLT_MAX;
        float p_wrtSV         = sv_perigee ? 1.0 / std::abs( qOverP_wrtSV ) : -FLT_MAX;
        float pt_wrtSV        = sv_perigee ? p_wrtSV * sin( theta_wrtSV ) : -FLT_MAX;
        float eta_wrtSV       = sv_perigee ? -log( tan( theta_wrtSV/2. ) ) : -FLT_MAX;
        float phi_wrtSV       = sv_perigee ? sv_perigee->parameters() [Trk::phi] : -FLT_MAX;
        float d0_wrtSV        = sv_perigee ? sv_perigee->parameters() [Trk::d0] : -FLT_MAX;
        float z0_wrtSV        = sv_perigee ? sv_perigee->parameters() [Trk::z0] : -FLT_MAX;
        float errd0_wrtSV     = sv_perigee ? std::sqrt((*sv_perigee->covariance())( Trk::d0, Trk::d0 )) : -FLT_MAX;
        float errz0_wrtSV     = sv_perigee ? std::sqrt((*sv_perigee->covariance())( Trk::z0, Trk::z0 )) : -FLT_MAX;
        float errP_wrtSV      = sv_perigee ? std::sqrt((*sv_perigee->covariance())( Trk::qOverP, Trk::qOverP )) : -FLT_MAX;
 
        m_pt_wrtSV(**trk) = pt_wrtSV;
        m_eta_wrtSV(**trk) = eta_wrtSV;
        m_phi_wrtSV(**trk) = phi_wrtSV;
        m_d0_wrtSV(**trk) = d0_wrtSV;
        m_z0_wrtSV(**trk) = z0_wrtSV;
        m_errP_wrtSV(**trk) = errP_wrtSV;
        m_errd0_wrtSV(**trk) = errd0_wrtSV;
        m_errz0_wrtSV(**trk) = errz0_wrtSV;
      }
    }
 
    std::unique_ptr<Trk::VxSecVertexInfo> res = std::make_unique<Trk::VxSecVertexInfo>(Trk::VxSecVertexInfo(listVrtSec));
 
    if(m_fillHist){
      Hists& h = getHists();
      h.m_tuple->Fill();
    };
 
    lockDecorations (inpTrk);
 
    return res;
 }

getBLHit()

int Rec::NewVrtSecInclusiveTool::getBLHit ( const xAOD::TrackParticle * Part )

staticprivate

Definition at line 223 of file Reconstruction/VKalVrt/NewVrtSecInclusiveTool/src/Utilities.cxx.

  {
        uint8_t BLhit,BLexp;
        if(!Part->summaryValue( BLexp,  xAOD::expectNextToInnermostPixelLayerHit) )           BLexp = 0;
        if( BLexp==0 ) return -1;
        if(!Part->summaryValue( BLhit,  xAOD::numberOfNextToInnermostPixelLayerHits) )        BLhit = 0;
        if(BLhit) return 1;
        else      return 0;
  }

getG4Inter()

int Rec::NewVrtSecInclusiveTool::getG4Inter ( const xAOD::TrackParticle * TP )

staticprivate

Definition at line 296 of file Reconstruction/VKalVrt/NewVrtSecInclusiveTool/src/Utilities.cxx.

                                                                     {
      static const SG::ConstAccessor< ElementLink< xAOD::TruthParticleContainer> >
        truthParticleLinkAcc ( "truthParticleLink");
      if( truthParticleLinkAcc.isAvailable( *TP ) ) {
        const ElementLink<xAOD::TruthParticleContainer>& tplink = 
          truthParticleLinkAcc( *TP );
        if( tplink.isValid() && HepMC::is_simulation_particle((*tplink))) return 1;
      }
      return 0;
  }

getHists()

NewVrtSecInclusiveTool::Hists & Rec::NewVrtSecInclusiveTool::getHists ( ) const

private

Definition at line 367 of file NewVrtSecInclusiveTool.cxx.

  {
    // We earlier checked that no more than one thread is being used.
    Hists* h ATLAS_THREAD_SAFE = m_h.get();
    return *h;
  }

getIBLHit()

int Rec::NewVrtSecInclusiveTool::getIBLHit ( const xAOD::TrackParticle * Part )

staticprivate

Definition at line 214 of file Reconstruction/VKalVrt/NewVrtSecInclusiveTool/src/Utilities.cxx.

  {
        uint8_t IBLhit,IBLexp;
        if(!Part->summaryValue( IBLexp,  xAOD::expectInnermostPixelLayerHit) )           IBLexp = 0;
        if( IBLexp==0 ) return -1;
        if(!Part->summaryValue( IBLhit,  xAOD::numberOfInnermostPixelLayerHits) )        IBLhit = 0;
        if(IBLhit) return 1;
        else       return 0;
  }

getIdHF()

int Rec::NewVrtSecInclusiveTool::getIdHF ( const xAOD::TrackParticle * TP ) const

private

Definition at line 242 of file Reconstruction/VKalVrt/NewVrtSecInclusiveTool/src/Utilities.cxx.

                                                                        {
    static const SG::ConstAccessor< ElementLink< xAOD::TruthParticleContainer> >
      truthParticleLinkAcc ( "truthParticleLink");
    if( truthParticleLinkAcc.isAvailable(*TP) ) {
       const ElementLink<xAOD::TruthParticleContainer>& tplink = truthParticleLinkAcc(*TP);
       if( !tplink.isValid() ) return 0;
       static const SG::ConstAccessor< float >truthMatchProbabilityAcc ( "truthMatchProbability" );
       if( truthMatchProbabilityAcc( *TP ) < 0.75 ) return 0;
       if( HepMC::is_simulation_particle((*tplink))) return 0;
       //-------------
       const xAOD::TruthParticle * parent1=getPreviousParent(*tplink);
       if(!parent1 || !parent1->isHadron()) return 0;
       if(parent1->isBottomHadron()) return isExcitedHadron(parent1) ? 0 : 1;  //Ground state B-hadron
       if(parent1->isCharmHadron() && !isExcitedHadron(parent1))return 1;      //Ground state C-hadron
       //--------------
       const xAOD::TruthParticle * parent2=getPreviousParent(parent1);
       if(!parent2 || !parent2->isHadron()) return 0;
       if(parent2->isBottomHadron()) return isExcitedHadron(parent2) ? 0 : 1;  //Ground state B-hadron
       if(parent2->isCharmHadron() && !isExcitedHadron(parent2))return 1;      //Ground state C-hadron
       //--------------
       const xAOD::TruthParticle * parent3=getPreviousParent(parent2);
       if(!parent3 || !parent3->isHadron()) return 0;
       if(parent3->isBottomHadron()) return isExcitedHadron(parent3) ? 0 : 1;  //Ground state B-hadron
       if(parent3->isCharmHadron() && !isExcitedHadron(parent3))return 1;      //Ground state C-hadron
    }
    return 0;
  }

getMCPileup()

int Rec::NewVrtSecInclusiveTool::getMCPileup ( const xAOD::TrackParticle * TP )

staticprivate

Definition at line 306 of file Reconstruction/VKalVrt/NewVrtSecInclusiveTool/src/Utilities.cxx.

                                                                      {
      static const SG::ConstAccessor< ElementLink< xAOD::TruthParticleContainer> >
        truthParticleLinkAcc ( "truthParticleLink");
      if( truthParticleLinkAcc.isAvailable( *TP ) ) {
        const ElementLink<xAOD::TruthParticleContainer>& tplink = 
          truthParticleLinkAcc( *TP );
        if( !tplink.isValid() ) return 1;
      } else { return 1; }
      return 0;
  }

getPixelDiscs()

void Rec::NewVrtSecInclusiveTool::getPixelDiscs ( const xAOD::TrackParticle * Part, int & d0Hit, int & d1Hit, int & d2Hit )

staticprivate

Definition at line 233 of file Reconstruction/VKalVrt/NewVrtSecInclusiveTool/src/Utilities.cxx.

  {
        uint32_t HitPattern=Part->hitPattern();
        d0Hit=0; if( HitPattern&((1<<Trk::pixelEndCap0)) ) d0Hit=1;
        d1Hit=0; if( HitPattern&((1<<Trk::pixelEndCap1)) ) d1Hit=1;
        d2Hit=0; if( HitPattern&((1<<Trk::pixelEndCap2)) ) d2Hit=1;
  }

getPreviousParent()

const xAOD::TruthParticle * Rec::NewVrtSecInclusiveTool::getPreviousParent ( const xAOD::TruthParticle * child )

staticprivate

Definition at line 269 of file Reconstruction/VKalVrt/NewVrtSecInclusiveTool/src/Utilities.cxx.

                                                                                                     {
    if( child->hasProdVtx() ){
       if( child->prodVtx()->nIncomingParticles()==1 ){
            return *(child->prodVtx()->incomingParticleLinks())[0];
       }
    }
    return nullptr;
  }

getProdVrtBarcode()

int Rec::NewVrtSecInclusiveTool::getProdVrtBarcode ( const xAOD::TrackParticle * TP, float resolLimit = 0.1 )

staticprivate

Definition at line 317 of file Reconstruction/VKalVrt/NewVrtSecInclusiveTool/src/Utilities.cxx.

  {
     int barVrt{HepMC::UNDEFINED_ID};
     if(!TP)return barVrt;
     static const SG::ConstAccessor<ElementLink<xAOD::TruthParticleContainer>> truthParticleLinkAcc( "truthParticleLink");
     if( truthParticleLinkAcc.isAvailable( *TP ) ) {
       barVrt=-1;
       const ElementLink<xAOD::TruthParticleContainer>& tplink = truthParticleLinkAcc( *TP );
       if( !tplink.isValid() ) return barVrt;
       const xAOD::TruthParticle *tparticle = (*tplink);         // truth particle for TrackPartile
       if(tparticle->hasProdVtx()){                              // truth particle has production vertex
          barVrt = HepMC::uniqueID(tparticle->prodVtx());
          if(HepMC::is_simulation_vertex(tparticle->prodVtx()))      return barVrt;          // Geant4 vertex
      if(tparticle->prodVtx()->nIncomingParticles()!=1) return barVrt;           // Safety!
      const xAOD::TruthParticle *parent = *(tparticle->prodVtx()->incomingParticleLinks())[0];
      Amg::Vector3D vpos0(tparticle->prodVtx()->x(),tparticle->prodVtx()->y(),tparticle->prodVtx()->z()); //Truth vertex position
          //
      //--  Now check parent
      if(!parent->isHadron()) return barVrt;    // Parent is parton not particle! Stop.
          if(!parent->hasProdVtx())         return barVrt;    // Parent particle doesn't have production vertex
      Amg::Vector3D vpos1(parent->prodVtx()->x(),parent->prodVtx()->y(),parent->prodVtx()->z()); //Truth vertex position
          if( Amg::distance(vpos0,vpos1) > resolLimit) return barVrt;    // Parent vertex is far
          barVrt = HepMC::uniqueID(parent->prodVtx());                         // Else use parent vertex as reference
          if(HepMC::is_simulation_vertex(parent->prodVtx()))   return barVrt;     // Geant4 vertex
      if(parent->prodVtx()->nIncomingParticles()!=1)       return barVrt;     // Not a decay vertex
      const xAOD::TruthParticle *grandparent = *(parent->prodVtx()->incomingParticleLinks())[0];
          //
      //--  Now check grandparent
      if(!grandparent->isHadron()) return barVrt;    // Grandparent is parton not particle! Stop.
          if(!grandparent->hasProdVtx())         return barVrt;    // Parent particle doesn't have production vertex
      Amg::Vector3D vpos2(grandparent->prodVtx()->x(),grandparent->prodVtx()->y(),grandparent->prodVtx()->z()); //Truth vertex position
          if( Amg::distance(vpos0,vpos2) > resolLimit) return barVrt;    // Grandparent vertex is far
          barVrt = HepMC::uniqueID(grandparent->prodVtx());                    // Use grandparent vertex as reference
          if(HepMC::is_simulation_vertex(grandparent->prodVtx()))      return barVrt;          // Geant4 vertex
      if(grandparent->prodVtx()->nIncomingParticles()!=1) return barVrt;           // Not a decay vertex
      const xAOD::TruthParticle *biggrandparent = *(grandparent->prodVtx()->incomingParticleLinks())[0];
          //
      //--  Now check biggrandparent
      if(!biggrandparent->isHadron()) return barVrt;    // BigGrandparent is parton not particle! Stop.
          if(!biggrandparent->hasProdVtx())         return barVrt;    // Parent particle doesn't have production vertex
      Amg::Vector3D vpos3(biggrandparent->prodVtx()->x(),biggrandparent->prodVtx()->y(),biggrandparent->prodVtx()->z());
          if( Amg::distance(vpos0,vpos3) > resolLimit) return barVrt;    // Grandparent vertex is far
          barVrt = HepMC::uniqueID(biggrandparent->prodVtx());               // Use grandparent vertex as reference
       }
     }
     return barVrt;
  }

getVrtSecMulti()

std::vector< xAOD::Vertex * > Rec::NewVrtSecInclusiveTool::getVrtSecMulti ( workVectorArrxAOD * inpParticlesxAOD, const xAOD::Vertex & primVrt, compatibilityGraph_t & compatibilityGraph ) const

private

Definition at line 29 of file VrtSecMulti.cxx.

   {
 
      const double probVrtMergeLimit=0.01;
 
      int i,j;
      int inpNPart=xAODwrk->inpTrk.size();
      std::vector<const xAOD::NeutralParticle*> neutralPartDummy(0);
      ATH_MSG_DEBUG( "getVrtSecMulti() called with NPart=" << inpNPart);
 
      std::vector<xAOD::Vertex*>  finalVertices(0); 
 
      if( inpNPart < 2 ) { return finalVertices;}   // 0,1 track => nothing to do!
 
      selGoodTrkParticle( xAODwrk, primVrt);
      int nTracks = xAODwrk->listSelTracks.size();
 
      if( nTracks < 2 ) { return finalVertices;} // 0,1 selected track => nothing to do!
 
      ATH_MSG_DEBUG( "Number of selected tracks = " <<nTracks);
      
      if(m_fillHist){
        Hists& h = getHists();
        h.m_hb_ntrksel->Fill( (double) nTracks, m_w_1);
      }
 
//
//  inpTrk[]           - input track list
//  listSelTracks[]    - list of good tracks in jet for vertex search
//------------------------------------------------------------   
//                     Initial track list ready
//                     Find 2track vertices
//
 
      std::map<long int,std::vector<double>> foundVrt2t;
      select2TrVrt(xAODwrk->listSelTracks, primVrt, foundVrt2t, compatibilityGraph);
 
//---
      ATH_MSG_DEBUG(" Defined edges in the graph="<< num_edges(compatibilityGraph));
      if(num_edges(compatibilityGraph)==0){ return finalVertices;} //No vertices!
 
//
//  m_Incomp[]           -  main vector of pointers for multivertex search
//-----------------------------------------------------------------------------------------------------
//            Secondary track list is ready
//            Creation of initial vertex set
//
 
 
      std::unique_ptr<std::vector<WrkVrt>> wrkVrtSet = std::make_unique<std::vector<WrkVrt>>();
      WrkVrt newvrt; newvrt.Good=true;
      std::unique_ptr<Trk::IVKalState> state = m_fitSvc->makeState();
      StatusCode sc;
      long int NPTR=0, nth=2; // VK nth=2 to speed up PGRAPH when it's used
 
 
      std::vector< std::vector<int> > allCliques;
      bron_kerbosch_all_cliques(compatibilityGraph, clique_visitor(allCliques));
      for(int cq=0; cq<(int)allCliques.size();cq++){
          newvrt.selTrk.clear();
          NPTR=allCliques[cq].size();
          for(i=0;i<NPTR;i++){ newvrt.selTrk.push_back(allCliques[cq][i]);}
//==================================================
          xAODwrk->tmpListTracks.clear();
          TLorentzVector vpsum;
          for(i=0;i<NPTR;i++) {
             xAODwrk->tmpListTracks.push_back( xAODwrk->listSelTracks.at(newvrt.selTrk[i]) );
             vpsum += xAODwrk->listSelTracks.at(newvrt.selTrk[i])->p4();
          }
          std::vector<double> iniVrtPos=estimVrtPos(nTracks,newvrt.selTrk,foundVrt2t);
          m_fitSvc->setApproximateVertex(iniVrtPos[0], iniVrtPos[1], iniVrtPos[2], *state); /*Use as starting point*/
          sc=m_fitSvc->VKalVrtFit(xAODwrk->tmpListTracks, neutralPartDummy,
                                             newvrt.vertex,     newvrt.vertexMom, newvrt.vertexCharge, newvrt.vertexCov,
                                             newvrt.chi2PerTrk, newvrt.trkAtVrt,  newvrt.chi2,
                                             *state, false);
          if( sc.isFailure() )           continue;   /* Bad fit - goto next solution */
          ATH_MSG_VERBOSE("Found IniVertex="<<newvrt.vertex[0]<<", "<<newvrt.vertex[1]<<", "<<newvrt.vertex[2]);
          ATH_MSG_VERBOSE("with Chi2="<<newvrt.chi2<<" Ntrk="<<NPTR<<" trk1,2="<<newvrt.selTrk[0]<<", "<<newvrt.selTrk[1]); 
          if(NPTR==2 && newvrt.chi2>10.) continue;   /* Bad 2track vertex */
          if(newvrt.chi2PerTrk.size()==2) newvrt.chi2PerTrk[0]=newvrt.chi2PerTrk[1]=newvrt.chi2/2.;
          newvrt.Good         = true;
          newvrt.projectedVrt=MomProjDist(newvrt.vertex, primVrt, newvrt.vertexMom); //3D SV-PV distance
          wrkVrtSet->push_back(newvrt);
    } 
    std::sort(wrkVrtSet->begin(),wrkVrtSet->end(),[](const WrkVrt& a, const WrkVrt& b){return a.selTrk.size()>b.selTrk.size();});
//==================================================================================
// boost::adjacency_list<boost::listS, boost::vecS, boost::undirectedS>::vertex_iterator vertexIt, vertexEnd;
// boost::adjacency_list<boost::listS, boost::vecS, boost::undirectedS>::adjacency_iterator neighbourIt, neighbourEnd;
// tie(vertexIt, vertexEnd) = vertices(compatibilityGraph);
// for (; vertexIt != vertexEnd; ++vertexIt) { std::cout << *vertexIt << " is connected with "; 
//    tie(neighbourIt, neighbourEnd) = adjacent_vertices(*vertexIt, compatibilityGraph); 
//    for (; neighbourIt != neighbourEnd; ++neighbourIt) std::cout << *neighbourIt << " ";   std::cout << "\n"; }
//==================================================================================
    if((*wrkVrtSet).empty())return finalVertices;
    if(msgLvl(MSG::DEBUG))printWrkSet(wrkVrtSet.get(),"Initial Vertices");
    //
    //--Count track participation in different vertices
    std::vector<int> trkNPairs(nTracks,0);
    for(auto &vrt : (*wrkVrtSet)){
       int ntInV=vrt.selTrk.size()-1;
       for(auto &trk : vrt.selTrk)trkNPairs.at(trk) +=  ntInV;
    }
//
//- Resolve all overlapped vertices
//
    state = m_fitSvc->makeState();
    std::multimap<double,std::pair<int,int>> vrtWithCommonTrk;
    while(true){
      int nSoluI=(*wrkVrtSet).size();
      vrtWithCommonTrk.clear();
      unsigned int nTComMax=0;
      for(int iv=0; iv<nSoluI-1; iv++ ){  
        if(!(*wrkVrtSet)[iv].Good)                      continue;
        if( (*wrkVrtSet)[iv].selTrk.size()<nTComMax)    continue;  // Optimisation. Only biggest overlap matters
        for(int jv=iv+1; jv<nSoluI; jv++){
          if(!(*wrkVrtSet)[jv].Good)                    continue;
          if( (*wrkVrtSet)[jv].selTrk.size()<nTComMax)  continue;  // Optimisation. Only biggest overlap matters
          unsigned int nTCom=nTrkCommon( wrkVrtSet.get(), iv, jv);
          if(!nTCom)         continue;
          if(nTCom<nTComMax) continue;
          double sumChi2=(*wrkVrtSet)[iv].chi2+(*wrkVrtSet)[jv].chi2;
          sumChi2=std::min(sumChi2,999.)*1.e-3;
          vrtWithCommonTrk.emplace(nTCom+sumChi2,std::make_pair(iv,jv));
          nTComMax=std::max(nTComMax,nTCom);
      } }
      if(vrtWithCommonTrk.empty())break;
      //============================== DEBUG output
      //for(auto ku : vrtWithCommonTrk)std::cout<<" nCom="<<ku.first<<" v1="<<ku.second.first<<" v2="<<ku.second.second<<'\n';
      //if(msgLvl(MSG::DEBUG))printWrkSet(wrkVrtSet.get(),"Overlapped  Vertex Cleaning");
      //===========================================
      for( const auto& ov : std::ranges::reverse_view(vrtWithCommonTrk)) {
         WrkVrt  & v1 = (*wrkVrtSet)[ov.second.first];
         WrkVrt  & v2 = (*wrkVrtSet)[ov.second.second];
         if(!v1.Good)continue;   //----One of the vertices is already preocessed
         if(!v2.Good)continue;
         //--Recheck amount of common tracks
         unsigned int nTCom=nTrkCommon( wrkVrtSet.get(), ov.second.first, ov.second.second);
         if(nTCom<nTComMax)continue;    //----One of the vertices is already preocessed
         //--First check if one vertex is fully contained in another
         if( nTCom==v1.selTrk.size() || nTCom==v2.selTrk.size() ){
           if(nTCom==v1.selTrk.size()){v1.Good = false; continue;}
           if(nTCom==v2.selTrk.size()){v2.Good = false; continue;}
         }
         //--Then check if 2 vertices with common tracks can be simply merged
         if( nTCom>1 && TMath::Prob( v1.chi2, 2*v1.selTrk.size()-3) > probVrtMergeLimit
                  && TMath::Prob( v2.chi2, 2*v2.selTrk.size()-3) > probVrtMergeLimit){
           double prbV=mergeAndRefitVertices( v1, v2, newvrt, xAODwrk->listSelTracks, *state);
           if(prbV>probVrtMergeLimit){
             v1.Good = false;  v2.Good = false;
             newvrt.Good         = true;
             newvrt.projectedVrt=MomProjDist(newvrt.vertex, primVrt, newvrt.vertexMom); //3D SV-PV distance
             std::swap(v1,newvrt); //Replace v1 by new vertex
             continue;
          }  }
          //--If not mergeable - refine them
          refineVerticesWithCommonTracks( v1, v2, xAODwrk->listSelTracks, *state);
      }
    }
    if(m_fillHist){
      int cvgood=0; for(const auto& vrt:(*wrkVrtSet)) if(vrt.Good)cvgood++;
      Hists& h = getHists();
      h.m_hb_rawVrtN->Fill( (float)cvgood, m_w_1);
    }
//
//-Clean duplicated 1track vertices if they exist
//
    if(m_multiWithOneTrkVrt){
      for(auto &v1t : (*wrkVrtSet)){
        if(v1t.selTrk.size()!=1 || !v1t.Good)continue;
        int ind_t=v1t.selTrk[0];
        if(trkNPairs[ind_t]<2){ v1t.Good=false; continue; } //Remove 1tr-vertex if track crosses only one other track
        if( xAODwrk->listSelTracks[ind_t]->pt()<m_cutPt*2){ v1t.Good=false; continue; }; //Tighten track_pt cut for 1-track vertex
        for(auto &vrt :(*wrkVrtSet)){   // Check if the track is present in another vertex, including other 1-track ones
          if(!vrt.Good || &v1t==&vrt)continue;
          if(std::find(vrt.selTrk.begin(),vrt.selTrk.end(),ind_t) != vrt.selTrk.end()){ v1t.Good=false; break; }
      } }
    }
//
//-Remove all bad vertices from the working set
//
    int tmpV=0; while( tmpV<(int)(*wrkVrtSet).size() )if( !(*wrkVrtSet)[tmpV].Good ) { (*wrkVrtSet).erase((*wrkVrtSet).begin()+tmpV);} else {tmpV++;}
    if((*wrkVrtSet).empty())return finalVertices;
    if(msgLvl(MSG::DEBUG))printWrkSet(wrkVrtSet.get(),"Intermediate Vertices");
    for( auto &tmpV : (*wrkVrtSet) ) tmpV.projectedVrt=MomProjDist(tmpV.vertex, primVrt, tmpV.vertexMom );  //Setup ProjectedVrt
//----------------------------------------------------------------------------
 
//----------------------------------------------------------------------------
//
// Final check/merge for close vertices
//
    int foundV1=-1, foundV2=-1;
    std::vector<double> checkedDst(0);
    double minDistVV=minVrtVrtDist( wrkVrtSet.get(), foundV1, foundV2, checkedDst); //recalculate VV distances
    if(m_fillHist){
      Hists& h = getHists();
      h.m_hb_distVV->Fill( minDistVV, m_w_1);
    }
    while ( minDistVV < m_vertexMergeCut) {
        if(foundV1<foundV2) { int tmp=foundV1; foundV1=foundV2; foundV2=tmp;}
        double probV=mergeAndRefitVertices( (*wrkVrtSet)[foundV1], (*wrkVrtSet)[foundV2], newvrt, xAODwrk->listSelTracks, *state, 0);
        ATH_MSG_DEBUG( "Merged vertex prob=" << probV<<" Vrt1="<<foundV1<<" Vrt2="<<foundV2<<" dst="<<minDistVV);
        if(probV<probVrtMergeLimit){ //--- If merged vertex is bad - try to remove the worst track
           int pos=std::max_element(newvrt.chi2PerTrk.begin(),newvrt.chi2PerTrk.end())-newvrt.chi2PerTrk.begin();
           newvrt.detachedTrack=newvrt.selTrk[pos];
           newvrt.selTrk.erase(newvrt.selTrk.begin()+pos);
           probV = refitVertex( newvrt, xAODwrk->listSelTracks, *state, false);
           ATH_MSG_DEBUG( "Attempt to improve prob=" << probV);
        }
        if(probV>probVrtMergeLimit && newvrt.vertexMom.M()<m_vrtMassLimit){        //  Good merged vertex found
           newvrt.projectedVrt=MomProjDist(newvrt.vertex, primVrt, newvrt.vertexMom);
           std::swap((*wrkVrtSet)[foundV1],newvrt);
           (*wrkVrtSet)[foundV2].Good=false;         //Drop vertex
           (*wrkVrtSet)[foundV2].selTrk.clear();     //Clean dropped vertex
        } else checkedDst.push_back(minDistVV);
        minDistVV=minVrtVrtDist( wrkVrtSet.get(), foundV1, foundV2, checkedDst);
    }
//
// Try to improve vertices with big Chi2 if something went wrong. Just precaution.
    for(int iv=0; iv<(int)wrkVrtSet->size(); iv++) {
       if(!(*wrkVrtSet)[iv].Good )                 continue;  //don't work on vertex which is already bad
       if( (*wrkVrtSet)[iv].selTrk.size()<3 )      continue;
       double tmpProb=TMath::Prob( (*wrkVrtSet)[iv].chi2, 2*(*wrkVrtSet)[iv].selTrk.size()-3 ); //Chi2 of the original vertex
       if(tmpProb<m_globVrtProbCut){
         ATH_MSG_DEBUG( "BAD vertex found prob=" << tmpProb);
         tmpProb=improveVertexChi2( (*wrkVrtSet)[iv], xAODwrk->listSelTracks, *state, false);
         (*wrkVrtSet)[iv].projectedVrt=MomProjDist((*wrkVrtSet)[iv].vertex, primVrt, (*wrkVrtSet)[iv].vertexMom);
       }
    }
//
//-Modify too heavy vertices 
    for(auto & iv : (*wrkVrtSet)){
      if( iv.vertexMom.M()>m_vrtMassLimit ) {
        ATH_MSG_DEBUG( "Heavy vertex found Mass=" << iv.vertexMom.M());
        int it_bad=mostHeavyTrk(iv,xAODwrk->listSelTracks);
        if(it_bad>-1){
        iv.selTrk.erase( iv.selTrk.begin() + it_bad );
        refitVertex(iv, xAODwrk->listSelTracks, *state, false);
        iv.projectedVrt=MomProjDist(iv.vertex, primVrt, iv.vertexMom);
     } } }
//--------------------------------------------------------------------------------------------------------
// Final vertex selection/cleaning
//
    double signif3D=0., signif2D=0.;
 
//-----  Vertices with >1 tracks
    for(int iv=0; iv<(int)wrkVrtSet->size(); iv++) {
          WrkVrt & curVrt=(*wrkVrtSet)[iv];
          nth=(*wrkVrtSet)[iv].selTrk.size(); 
          if(nth == 1)                          continue;  // 1track vertices for later...
          if(!curVrt.Good )                     continue;  //don't work on vertex which is already bad
          (*wrkVrtSet)[iv].Good = false;                                     /* Make all vertices bad for futher selection */
          if(nth < 1)                           continue;                    /* Definitely bad vertices */
          if((*wrkVrtSet)[iv].projectedVrt<0.)  continue;                    /* Remove vertices behind primary one */ 
          if( TMath::Prob( curVrt.chi2, 2*nth-3)<m_globVrtProbCut) continue;           /* Bad Chi2 of refitted vertex  */
//-----------------------------------------------------------------------------------------
          vrtVrtDist(primVrt,curVrt.vertex, curVrt.vertexCov, signif3D); 
          if(m_fillHist){ 
             Hists& h = getHists();
             if(nth==2 && curVrt.vertexCharge==0) h.m_hb_massPiPi1->Fill(curVrt.vertexMom.M(), m_w_1);
             h.m_hb_sig3DTot->Fill( signif3D, m_w_1);
             if(nth==2)h.m_hb_sig3D2tr->Fill( signif3D, m_w_1);
             if(nth >2)h.m_hb_sig3DNtr->Fill( signif3D, m_w_1);
          }
//
//---  Check V0s and conversions. Necessity must be checked in physics applications
#if 0
          if(nth==2 && curVrt.vertexCharge==0 && curVrt.detachedTrack<0){
             double mass_PiPi =  curVrt.vertexMom.M();  
             double mass_PPi  =  massV0(curVrt.trkAtVrt,m_massP,m_massPi);
             double mass_EE   =  massV0(curVrt.trkAtVrt,m_massE,m_massE);
             if(m_fillHist){
               Hists& h = getHists();
               h.m_hb_massPiPi->Fill( mass_PiPi, m_w_1);
               h.m_hb_massPPi ->Fill( mass_PPi,  m_w_1); 
               if( curVrt.vertex.perp()>20.)h.m_hb_massEE  ->Fill( mass_EE,   m_w_1);
             } 
             if( std::abs(mass_PiPi-m_massK0) < 22.)     continue;
             if( std::abs(mass_PPi-m_massLam) <  8.)     continue;
             if( mass_EE < 60. && curVrt.vertex.perp() > 20.) continue;
          }
#endif
//---
          if(signif3D<m_selVrtSigCut)                 continue;      //Main PV-SV distance quality cut 
          if(curVrt.vertex.perp() > m_maxSVRadiusCut) continue;      // Too far from interaction point
          curVrt.Good = true;  /* Vertex is absolutely good */
    }
    if(msgLvl(MSG::DEBUG))printWrkSet(wrkVrtSet.get(),"Final Vertices");
//-------------------------------------------
// Debug ntuple filling and BDT application
//
    std::vector<double> impact,impactError;
    for(int iv=0; iv<(int)wrkVrtSet->size(); iv++) {
          WrkVrt & curVrt=(*wrkVrtSet)[iv];
          nth=curVrt.selTrk.size();
          if(!curVrt.Good || nth<2)      continue;
          double minPtT=1.e6, minSig3DT=1.e6, maxSig3DT=0.;
          int ntrkBC=0,ntrkI=0,sumIBLHits=0,sumBLHits=0;
          for(i=0;i<nth;i++) {
             j=curVrt.selTrk[i];                           //Track number
             minPtT=std::min( minPtT, xAODwrk->listSelTracks[j]->pt());
             m_fitSvc->VKalGetImpact(xAODwrk->listSelTracks[j], primVrt.position(), 1, impact, impactError);
             double SigR2 = impact[0]*impact[0]/impactError[0];
             double SigZ2 = impact[1]*impact[1]/impactError[2];
             minSig3DT=std::min( minSig3DT, sqrt( SigR2 + SigZ2) );
             maxSig3DT=std::max( maxSig3DT, sqrt( SigR2 + SigZ2) );
             sumIBLHits += std::max(getIBLHit(xAODwrk->listSelTracks[j]),0);
             sumBLHits  += std::max(getBLHit(xAODwrk->listSelTracks[j]),0);
             if(m_fillHist) {
                ntrkBC += getIdHF(xAODwrk->listSelTracks[j]);
                ntrkI  += getG4Inter(xAODwrk->listSelTracks[j]);
             }
          }
          float vProb=TMath::Prob(curVrt.chi2, 2*nth-3);
          float cosSVPVM=projSV_PV(curVrt.vertex, primVrt, curVrt.vertexMom);
          float vrtR=curVrt.vertex.perp();
          TLorentzVector SVPV(curVrt.vertex.x()-primVrt.x(),curVrt.vertex.y()-primVrt.y(),curVrt.vertex.z()-primVrt.z(), 10.);
          if(m_fillHist){
             Hists& h = getHists();
             if( nth>1 ){
                vrtVrtDist(primVrt,curVrt.vertex, curVrt.vertexCov, signif3D); 
                float Dist2D=vrtVrtDist2D(primVrt,curVrt.vertex, curVrt.vertexCov, signif2D); 
                h.m_curTup->NVrtTrk   [h.m_curTup->nNVrt] = nth;
                h.m_curTup->NVrtTrkHF [h.m_curTup->nNVrt] = ntrkBC;
                h.m_curTup->NVrtTrkI  [h.m_curTup->nNVrt] = ntrkI;
                h.m_curTup->NVrtProb  [h.m_curTup->nNVrt] = vProb;
                h.m_curTup->NVrtSig3D [h.m_curTup->nNVrt] = signif3D;
                h.m_curTup->NVrtSig2D [h.m_curTup->nNVrt] = signif2D;
                h.m_curTup->NVrtDist2D[h.m_curTup->nNVrt] = vrtR<20. ? Dist2D : vrtR;
                h.m_curTup->NVrtM     [h.m_curTup->nNVrt] = curVrt.vertexMom.M();
                h.m_curTup->NVrtPt    [h.m_curTup->nNVrt] = curVrt.vertexMom.Pt();
                h.m_curTup->NVrtEta   [h.m_curTup->nNVrt] = SVPV.Eta();
                h.m_curTup->NVrtIBL   [h.m_curTup->nNVrt] = sumIBLHits;
                h.m_curTup->NVrtBL    [h.m_curTup->nNVrt] = sumBLHits;
                h.m_curTup->NVrtCosSPM[h.m_curTup->nNVrt] = cosSVPVM;
                h.m_curTup->NVrtCh    [h.m_curTup->nNVrt] = curVrt.vertexCharge;
                h.m_curTup->NVMinPtT  [h.m_curTup->nNVrt] = minPtT;
                h.m_curTup->NVMinS3DT [h.m_curTup->nNVrt] = minSig3DT;
                h.m_curTup->NVrtBDT   [h.m_curTup->nNVrt] = 1.1;
                h.m_curTup->NVrtHR1   [h.m_curTup->nNVrt] = xAODwrk->listSelTracks[curVrt.selTrk[0]]->radiusOfFirstHit();
                h.m_curTup->NVrtHR2   [h.m_curTup->nNVrt] = xAODwrk->listSelTracks[curVrt.selTrk[1]]->radiusOfFirstHit();
                if( h.m_curTup->nNVrt < DevTuple::maxNVrt-1 )h.m_curTup->nNVrt++;
            }
          }
//--------Final selection of the remaining 2-track vertices 
//    Should be tighter than initila 2-track vertex selection for compatibility graph construction
//
          if(nth==2){
             float wgtSelect=-1.1;
             xAOD::Vertex testV;
             testV.makePrivateStore();
             testV.setPosition(curVrt.vertex);
             std::vector<float> testVcov(curVrt.vertexCov.begin(),curVrt.vertexCov.end());
             testV.setCovariance(testVcov);
             testV.setFitQuality(curVrt.chi2,1.);
             bool acceptV=m_fin_v2trselector->isgood(std::make_pair(xAODwrk->listSelTracks[curVrt.selTrk[0]],
                                                                    xAODwrk->listSelTracks[curVrt.selTrk[1]]),
                                                                    testV, 
                      std::make_pair(momAtVrt(curVrt.trkAtVrt[0]),momAtVrt(curVrt.trkAtVrt[1])), primVrt, wgtSelect);
             curVrt.BDT=wgtSelect;
             if(m_fillHist){
               Hists& h = getHists();
               h.m_hb_fakeSVBDT->Fill(wgtSelect,1.);
               h.m_curTup->NVrtBDT[h.m_curTup->nNVrt-1] = wgtSelect;
             }
             if(!acceptV){
               curVrt.Good = false;             // Disable 2-track vertex with bad BDT score
               if(m_multiWithOneTrkVrt){        // Check if linked 1-track vertex exists and disable it
                 for(auto it : curVrt.selTrk){
                   for(auto &vtmp : (*wrkVrtSet)){
                     if(vtmp.selTrk.size()!=1 || (!vtmp.Good)) continue;
                         if(it==vtmp.detachedTrack)vtmp.Good=false;
               } } }
             }
          }
    } //End vertex set loop
//
//-- Debug ntuple for 1track vertex is filled here
//
    if(m_fillHist && m_multiWithOneTrkVrt){
      Hists& h = getHists();
      for(auto & vrt : (*wrkVrtSet)) {
        if( !vrt.Good || vrt.selTrk.size() != 1 ) continue;  // Good 1track vertices
        const auto *xaodtp=xAODwrk->listSelTracks[vrt.selTrk[0]];
        m_fitSvc->VKalGetImpact(xaodtp, primVrt.position(), 1, impact, impactError);
        double SigR2 = std::abs(impact[0]*impact[0]/impactError[0]);
        double SigZ2 = std::abs(impact[1]*impact[1]/impactError[2]);
        float dist2D=vrtVrtDist2D(primVrt,vrt.vertex, vrt.vertexCov, signif2D); 
        h.m_curTup->NVrtTrk   [h.m_curTup->nNVrt] = 1;
        h.m_curTup->NVrtTrkHF [h.m_curTup->nNVrt] = getIdHF(xaodtp);
        h.m_curTup->NVrtProb  [h.m_curTup->nNVrt] = trkNPairs[vrt.selTrk[0]];
        h.m_curTup->NVrtSig3D [h.m_curTup->nNVrt] = 0.;
        h.m_curTup->NVrtSig2D [h.m_curTup->nNVrt] = signif2D;
        h.m_curTup->NVrtDist2D[h.m_curTup->nNVrt] = dist2D;
        h.m_curTup->NVrtM     [h.m_curTup->nNVrt] = vrt.vertexMom.M();
        h.m_curTup->NVrtPt    [h.m_curTup->nNVrt] = vrt.vertexMom.Pt();
        h.m_curTup->NVrtCosSPM[h.m_curTup->nNVrt] = 0.;
        h.m_curTup->NVrtCh    [h.m_curTup->nNVrt] = vrt.vertexCharge;
        h.m_curTup->NVMinPtT  [h.m_curTup->nNVrt] = xaodtp->pt();
        h.m_curTup->NVMinS3DT [h.m_curTup->nNVrt] = sqrt(SigR2 + SigZ2);
        h.m_curTup->NVrtBDT   [h.m_curTup->nNVrt] = 1.1;
        h.m_curTup->NVrtIBL   [h.m_curTup->nNVrt] = std::max(getIBLHit(xaodtp),0);
        h.m_curTup->NVrtBL    [h.m_curTup->nNVrt] = std::max(getBLHit (xaodtp),0);
        if( h.m_curTup->nNVrt < DevTuple::maxNVrt-1 )h.m_curTup->nNVrt++;
   }  }
//-------------------------------------------
//Sorting and check
    std::multimap<double,WrkVrt,std::greater<double>> goodVertexMap;
    int nNtrVrt=0;
    for(auto & iv : (*wrkVrtSet) ) {
       nth=iv.selTrk.size(); 
       if(nth==1)iv.BDT=-2.;  //To move 1-track vertices to the end of the vertex list later
       double selector=iv.BDT;
       if(nth==1)     selector=iv.BDT+std::min(iv.vertexMom.Pt()*1.e-5,1.);
       else if(nth>2) selector=iv.BDT+iv.vertexMom.M()*1.e-5;
       if( iv.Good && nth>0 ) {
          goodVertexMap.emplace(selector,iv);    // add it and sort in the map
          if(nth>1)nNtrVrt++;
       }
    }
    if(nNtrVrt==0){             //--- No good vertices at all
      if(m_fillHist) {
        Hists& h = getHists();
        h.m_curTup->nNVrt=0;
      }
      return finalVertices;
    }
//
//-------------------------------------------
// Final vertex refit for full covariance matrix and xAOD::Vertex creation
//
    static const SG::AuxElement::Decorator<float> wgtBDT("wgtBDT");
    static const SG::AuxElement::Decorator<int>   nTrksDec("nTracks");
    static const SG::AuxElement::Decorator<int>   vChrgTot("vCharge");
    int n1trVrt=0;           // Final number of good 1-track vertices
    for(auto & iv : goodVertexMap){
          WrkVrt & curVrt=iv.second;
          nth=curVrt.selTrk.size();
          xAODwrk->tmpListTracks.clear();
          for(auto t : curVrt.selTrk)xAODwrk->tmpListTracks.push_back( xAODwrk->listSelTracks[t] );
          if(m_fillHist){ 
             Hists& h = getHists();
             h.m_hb_totmass->Fill(curVrt.vertexMom.M(), m_w_1);
             h.m_hb_r2d->Fill( curVrt.vertex.perp(), m_w_1);
          } 
//--- Re-fit with full error matrix and xAOD::Vertex creation
          xAOD::Vertex * tmpVertex=nullptr;
          if(nth>1){                                    //-- Common case with full refit
             tmpVertex=m_fitSvc->fit(xAODwrk->tmpListTracks,curVrt.vertex,*state);
          } else if(nth==1){                            //-- Special case for 1-track vertex
             tmpVertex=new (std::nothrow) xAOD::Vertex();
             if(!tmpVertex)continue;
             tmpVertex->makePrivateStore();
             tmpVertex->setPosition(curVrt.vertex);
             std::vector<float> floatErrMtx(6);
             for(int i=0; i<6; i++) floatErrMtx[i]=curVrt.vertexCov[i];
             tmpVertex->setCovariance(floatErrMtx);
             tmpVertex->setFitQuality(curVrt.chi2, (float)(nth*2-3));
             std::vector<Trk::VxTrackAtVertex> & tmpVTAV=tmpVertex->vxTrackAtVertex();    tmpVTAV.clear();
             AmgSymMatrix(5) CovMtxP;    
             CovMtxP.setIdentity(); 
             Trk::Perigee * tmpMeasPer  =  new (std::nothrow) Trk::Perigee( 0.,0.,
                                                                     curVrt.trkAtVrt[0][0],
                                                                     curVrt.trkAtVrt[0][1],
                                                                     curVrt.trkAtVrt[0][2],
                                                              Trk::PerigeeSurface(curVrt.vertex),
                                                              std::move(CovMtxP) );
             tmpVTAV.emplace_back( 1., tmpMeasPer );
             ElementLink<xAOD::TrackParticleContainer> TEL;  TEL.setElement( xAODwrk->tmpListTracks[0] );
             const xAOD::TrackParticleContainer* cont = (const xAOD::TrackParticleContainer* ) (xAODwrk->tmpListTracks[0]->container() );
             TEL.setStorableObject(*cont);
             tmpVertex->addTrackAtVertex(TEL,1.);
             n1trVrt++;
          }
          if(tmpVertex){
            wgtBDT  (*tmpVertex) =curVrt.BDT;
            nTrksDec(*tmpVertex) =curVrt.selTrk.size();
            vChrgTot(*tmpVertex) =curVrt.vertexCharge;
            tmpVertex->setVertexType(xAOD::VxType::SecVtx);
            finalVertices.push_back(tmpVertex);
            for (int ind=0; ind<nth; ind++) {
              m_chi2_toSV(*xAODwrk->listSelTracks[curVrt.selTrk[ind]]) = curVrt.chi2PerTrk[ind] > FLT_MAX ? FLT_MAX : curVrt.chi2PerTrk[ind];
            }
          }
    }
    if(m_fillHist){
      Hists& h = getHists();
      h.m_hb_goodvrtN->Fill( finalVertices.size()+0.1, m_w_1);
      h.m_hb_goodvrt1N->Fill( n1trVrt+0.1, m_w_1);
    }
//-----------------------------------------------------------------------------------
//  Saving of results
//
    return finalVertices;
 
  }

improveVertexChi2()

double Rec::NewVrtSecInclusiveTool::improveVertexChi2 ( WrkVrt & vertex, std::vector< const xAOD::TrackParticle * > & allTracks, Trk::IVKalState & istate, bool ifCovV0 ) const

private

Definition at line 195 of file MultiUtilities.cxx.

   {
 
      int nTrk=vertex.selTrk.size();
      if( nTrk<2 )return 0.;
      double prob=TMath::Prob( vertex.chi2, 2*nTrk-3);
      //
      //----Start track removal iterations
      while(prob<0.01){
        nTrk=vertex.selTrk.size();
        if(nTrk==2)return prob;
        int selT=0;
        for(int i=0; i<nTrk; i++){ if( vertex.chi2PerTrk[i]>vertex.chi2PerTrk[selT]) selT=i; }
        vertex.detachedTrack=vertex.selTrk[selT];
        vertex.selTrk.erase( vertex.selTrk.begin() + selT ); //remove track
        prob = refitVertex( vertex, allTrackList, istate, ifCovV0);
        if(prob<0.)return 0.;
      }
      return prob;
   }

initialize()

StatusCode Rec::NewVrtSecInclusiveTool::initialize

(

)

Definition at line 66 of file NewVrtSecInclusiveTool.cxx.

                                                {
     ATH_MSG_DEBUG( "Initialising NewVrtSecInclusiveTool" );
     ATH_CHECK( m_extrapolator.retrieve() );
     ATH_CHECK( m_trackToVertexTool.retrieve() );
     ATH_CHECK( m_beamSpotKey.initialize() );
     ATH_CHECK( m_fitSvc.retrieve() );
     ATH_CHECK( m_ini_v2trselector.retrieve() );
     ATH_CHECK( m_fin_v2trselector.retrieve() );
 
     m_is_selected = SG::AuxElement::Decorator<char>("is_selected"+m_augString);
     m_is_svtrk_final = SG::AuxElement::Decorator<char>("is_svtrk_final"+m_augString);
     m_pt_wrtSV = SG::AuxElement::Decorator<float>("pt_wrtSV"+m_augString);
     m_eta_wrtSV = SG::AuxElement::Decorator<float>("eta_wrtSV"+m_augString);
     m_phi_wrtSV = SG::AuxElement::Decorator<float>("phi_wrtSV"+m_augString);
     m_d0_wrtSV = SG::AuxElement::Decorator<float>("d0_wrtSV"+m_augString);
     m_z0_wrtSV = SG::AuxElement::Decorator<float>("z0_wrtSV"+m_augString);
     m_errP_wrtSV = SG::AuxElement::Decorator<float>("errP_wrtSV"+m_augString);
     m_errd0_wrtSV = SG::AuxElement::Decorator<float>("errd0_wrtSV"+m_augString);
     m_errz0_wrtSV = SG::AuxElement::Decorator<float>("errz0_wrtSV"+m_augString);
     m_chi2_toSV = SG::AuxElement::Decorator<float>("chi2_toSV"+m_augString);
 
//------------------------------------------       
//
     if(m_fillHist){
       if (Gaudi::Concurrency::ConcurrencyFlags::numThreads() > 1) {
         ATH_MSG_FATAL("Filling histograms not supported in MT jobs.");
         return StatusCode::FAILURE;
       }
 
       SmartIF<ITHistSvc> hist_root{service("THistSvc")};
       if( !hist_root )  ATH_MSG_DEBUG("Could not find THistSvc service");
       else              ATH_MSG_DEBUG("NewVrtSecInclusiveTool Histograms found");
       std::string histDir;
       histDir="/NVSI/stat/MultiSVrt"+m_instanceName+"/";
 
       m_h = std::make_unique<Hists>();
       ATH_CHECK( m_h->book (*hist_root, histDir) );
 
       m_w_1 = 1.;
     }
 
 
     return StatusCode::SUCCESS;
 
   }

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

interfaceID()

const InterfaceID & Rec::IVrtInclusive::interfaceID ( )

inlinestaticinherited

Definition at line 43 of file IVrtInclusive.h.

{ return IID_IVrtInclusive;}

isDisplaced()

bool Rec::NewVrtSecInclusiveTool::isDisplaced ( const xAOD::TrackParticle * tp )

staticprivate

Definition at line 285 of file Reconstruction/VKalVrt/NewVrtSecInclusiveTool/src/Utilities.cxx.

                                                                       {
     if(!TP)return false;
     static const SG::ConstAccessor<ElementLink<xAOD::TruthParticleContainer>> truthParticleLinkAcc( "truthParticleLink");
     if( truthParticleLinkAcc.isAvailable( *TP ) ) {
       const ElementLink<xAOD::TruthParticleContainer>& tplink = truthParticleLinkAcc( *TP );
       if( !tplink.isValid() ) return false;
       if((*tplink)->hasProdVtx() && (*tplink)->prodVtx()->perp() > 1.*Gaudi::Units::mm) return true;
     }
     return false;
  }

isExcitedHadron()

bool Rec::NewVrtSecInclusiveTool::isExcitedHadron ( const xAOD::TruthParticle * tp )

staticprivate

Definition at line 277 of file Reconstruction/VKalVrt/NewVrtSecInclusiveTool/src/Utilities.cxx.

                                                                           {
    if( !tp->hasProdVtx() )return false;
    if( !tp->hasDecayVtx() )return false;
    Amg::Vector3D pvrt(tp->prodVtx()->x(),tp->prodVtx()->y(),tp->prodVtx()->z());
    Amg::Vector3D dvrt(tp->decayVtx()->x(),tp->decayVtx()->y(),tp->decayVtx()->z());
    return Amg::distance(pvrt,dvrt) < 0.001*Gaudi::Units::mm ? true : false;
  }

isPart()

bool Rec::NewVrtSecInclusiveTool::isPart ( const std::deque< long int > & test, std::deque< long int > base )

staticprivate

Definition at line 252 of file MultiUtilities.cxx.

   {
      for (long int trk : test)
         if(std::find(base.begin(), base.end(), trk) == base.end()) return false;  //element not found => test is not part of base
      return true;
   }

lockDecorations()

void Rec::NewVrtSecInclusiveTool::lockDecorations ( const std::vector< const xAOD::TrackParticle * > & inpTrk ) const

private

Definition at line 335 of file NewVrtSecInclusiveTool.cxx.

  {
    // We may have track from several containers.  Use this to keep track
    // of which ones we've processed.  We only expect a few distinct ones,
    // so just use a vector.
    std::vector<const SG::AuxVectorData*> containers;
    containers.reserve (16);
 
    for (const xAOD::TrackParticle* t : inpTrk) {
      const SG::AuxVectorData* c = t->container();
      if (c && std::find (containers.begin(), containers.end(), c) == containers.end())
      {
        containers.push_back (c);
        // Ok because we just made these decorations.
        SG::AuxVectorData* c_nc ATLAS_THREAD_SAFE = const_cast<SG::AuxVectorData*> (c);
        c_nc->lockDecoration (m_is_selected.auxid());
        c_nc->lockDecoration (m_is_svtrk_final.auxid());
        c_nc->lockDecoration (m_pt_wrtSV.auxid());
        c_nc->lockDecoration (m_eta_wrtSV.auxid());
        c_nc->lockDecoration (m_phi_wrtSV.auxid());
        c_nc->lockDecoration (m_d0_wrtSV.auxid());
        c_nc->lockDecoration (m_z0_wrtSV.auxid());
        c_nc->lockDecoration (m_errP_wrtSV.auxid());
        c_nc->lockDecoration (m_errd0_wrtSV.auxid());
        c_nc->lockDecoration (m_errz0_wrtSV.auxid());
        c_nc->lockDecoration (m_chi2_toSV.auxid());
      }
    }
  }

massV0()

double Rec::NewVrtSecInclusiveTool::massV0 ( const std::vector< std::vector< double > > & TrkAtVrt, double massP, double massPi )

staticprivate

Definition at line 177 of file Reconstruction/VKalVrt/NewVrtSecInclusiveTool/src/Utilities.cxx.

   {
        double ap1i=std::abs(TrkAtVrt[0][2]); double ap2i=std::abs(TrkAtVrt[1][2]);
        CxxUtils::sincos   phi1(TrkAtVrt[0][0]);
        CxxUtils::sincos theta1(TrkAtVrt[0][1]);
        CxxUtils::sincos   phi2(TrkAtVrt[1][0]);
        CxxUtils::sincos theta2(TrkAtVrt[1][1]);
        double px = phi1.cs * theta1.sn * ap1i 
                  + phi2.cs * theta2.sn * ap2i;
        double py = phi1.sn * theta1.sn * ap1i 
                  + phi2.sn * theta2.sn * ap2i;
        double pz =           theta1.cs * ap1i 
                  +           theta2.cs * ap2i;
        double ee= (ap1i > ap2i) ? 
            (std::sqrt(ap1i*ap1i+massP*massP)+std::sqrt(ap2i*ap2i+massPi*massPi)):
            (std::sqrt(ap2i*ap2i+massP*massP)+std::sqrt(ap1i*ap1i+massPi*massPi));
        double test=(ee-pz)*(ee+pz)-px*px-py*py;
        return test>0 ? std::sqrt(test) : 0.; 
    }

mergeAndRefitVertices()

double Rec::NewVrtSecInclusiveTool::mergeAndRefitVertices ( WrkVrt & v1, WrkVrt & v2, WrkVrt & newvrt, std::vector< const xAOD::TrackParticle * > & AllTrackList, Trk::IVKalState & istate, int robKey = 0 ) const

private

Definition at line 151 of file MultiUtilities.cxx.

   {
      if(!v1.Good)return -1.;         //bad vertex
      if(!v2.Good)return -1.;         //bad vertex
      std::vector<const xAOD::NeutralParticle*> neutralPartDummy(0);
      newvrt.Good=true;
      int nTrk_V1=v1.selTrk.size();
      int nTrk_V2=v2.selTrk.size();
      newvrt.selTrk.resize(nTrk_V1+nTrk_V2);
      std::copy(v1.selTrk.begin(),v1.selTrk.end(), newvrt.selTrk.begin());
      std::copy(v2.selTrk.begin(),v2.selTrk.end(), newvrt.selTrk.begin()+nTrk_V1);
 
      std::deque<long int>::iterator   TransfEnd ;
      sort( newvrt.selTrk.begin(), newvrt.selTrk.end() );
      TransfEnd =  unique( newvrt.selTrk.begin(), newvrt.selTrk.end() );
      newvrt.selTrk.erase( TransfEnd, newvrt.selTrk.end());
      std::vector<const xAOD::TrackParticle*>  fitTrackList(0);
      for(int it=0; it<(int)newvrt.selTrk.size(); it++)fitTrackList.push_back( AllTrackList[newvrt.selTrk[it]] );
      m_fitSvc->setApproximateVertex( 0.5*(v1.vertex[0]+v2.vertex[0]),
                                      0.5*(v1.vertex[1]+v2.vertex[1]),
                                      0.5*(v1.vertex[2]+v2.vertex[2]),
                                      istate);
      m_fitSvc->setRobustness(robKey,istate);
      
      StatusCode sc=m_fitSvc->VKalVrtFit(fitTrackList,neutralPartDummy,
                                   newvrt.vertex, newvrt.vertexMom, newvrt.vertexCharge, newvrt.vertexCov,
                                   newvrt.chi2PerTrk,  newvrt.trkAtVrt, newvrt.chi2,
                                   istate, false);
      if( sc.isFailure() )             return -1.;  
      if( newvrt.chi2>500. )           return -1.;  //VK protection
      if( newvrt.chi2PerTrk.size()==2) newvrt.chi2PerTrk[0]=newvrt.chi2PerTrk[1]=newvrt.chi2/2.;
 
      m_fitSvc->setRobustness(0,istate); //restore default behaviour
 
      return TMath::Prob( newvrt.chi2, 2*newvrt.selTrk.size()-3);
   }

minVrtVrtDist()

double Rec::NewVrtSecInclusiveTool::minVrtVrtDist ( std::vector< WrkVrt > * WrkVrtSet, int & indexV1, int & indexV2, std::vector< double > & check ) const

private

Definition at line 70 of file MultiUtilities.cxx.

   {  
     V1=V2=-1;
     double foundMinVrtDst=1000000.;
 
     for(int iv=0; iv<(int)wrkVrtSet->size()-1; iv++) {
        if( (*wrkVrtSet)[iv].selTrk.size()< 2)    continue;   /* Bad vertices */
        if(!(*wrkVrtSet)[iv].Good )               continue;   /* Bad vertices */
        for(int jv=iv+1; jv<(int)wrkVrtSet->size(); jv++) {
           if( (*wrkVrtSet)[jv].selTrk.size()< 2) continue;   /* Bad vertices */
           if(!(*wrkVrtSet)[jv].Good )            continue;   /* Bad vertices */
           double tmp= std::abs((*wrkVrtSet)[iv].vertex.x()-(*wrkVrtSet)[jv].vertex.x())
                      +std::abs((*wrkVrtSet)[iv].vertex.y()-(*wrkVrtSet)[jv].vertex.y())
                      +std::abs((*wrkVrtSet)[iv].vertex.z()-(*wrkVrtSet)[jv].vertex.z());
           if(tmp>20.) continue;
           double tmpDst = vrtVrtDist((*wrkVrtSet)[iv].vertex,(*wrkVrtSet)[iv].vertexCov,
                                      (*wrkVrtSet)[jv].vertex,(*wrkVrtSet)[jv].vertexCov);
           if(std::find(checked.begin(),checked.end(),tmpDst) != checked.end()) continue; //Alreasy tried
           if( tmpDst < foundMinVrtDst){foundMinVrtDst = tmpDst; V1=iv; V2=jv;} 
         }
      }
      return foundMinVrtDst;
   }

momAtVrt()

ROOT::Math::PxPyPzEVector Rec::NewVrtSecInclusiveTool::momAtVrt ( const std::vector< double > & inpTrk ) const

private

Definition at line 201 of file Reconstruction/VKalVrt/NewVrtSecInclusiveTool/src/Utilities.cxx.

  {
     double api=1./std::abs(inpTrk[2]);
     CxxUtils::sincos   phi(inpTrk[0]);
     CxxUtils::sincos theta(inpTrk[1]);
     double px = phi.cs  * theta.sn * api;
     double py = phi.sn  * theta.sn * api;
     double pz =           theta.cs * api;
     double ee = std::sqrt( px*px + py*py + pz*pz + m_massPi*m_massPi);
     return {px,py,pz,ee}; 
   }

MomProjDist()

double Rec::NewVrtSecInclusiveTool::MomProjDist ( const Amg::Vector3D & SV, const xAOD::Vertex & PV, const TLorentzVector & Direction )

staticprivate

Definition at line 260 of file MultiUtilities.cxx.

   {
      Amg::Vector3D vv=SecVrt-primVrt.position();
      return ( vv.x()*Mom.X()+vv.y()*Mom.Y()+vv.z()*Mom.Z() )/ Mom.P();
   }

mostHeavyTrk()

int Rec::NewVrtSecInclusiveTool::mostHeavyTrk ( WrkVrt V, std::vector< const xAOD::TrackParticle * > AllTracks )

staticprivate

Definition at line 26 of file MultiUtilities.cxx.

   {
      int NTrk=V.selTrk.size(), SelT=-1;
      if(NTrk<3)return -1;
//--------------------------------------------------
      TLorentzVector TSum;
      for(int i=0; i<NTrk; i++){
         TSum += AllTracks.at(V.selTrk[i])->p4();
      }
      double massMin=1.e9;
      for(int i=0; i<NTrk; i++){
         TLorentzVector TSum_m1 = TSum - AllTracks[V.selTrk[i]]->p4();
         if(TSum_m1.M()<massMin){massMin=TSum_m1.M(); SelT=i;}
      }
      return SelT;
    }

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

nTrkCommon()

int Rec::NewVrtSecInclusiveTool::nTrkCommon ( std::vector< WrkVrt > * WrkVrtSet, int indexV1, int indexV2 )

staticprivate

Definition at line 48 of file MultiUtilities.cxx.

   {
      int nTrk_V1 = (*wrkVrtSet).at(V1).selTrk.size(); if( nTrk_V1< 2) return 0;   /* Bad vertex */
      int nTrk_V2 = (*wrkVrtSet).at(V2).selTrk.size(); if( nTrk_V2< 2) return 0;   /* Bad vertex */
      int nTrkCom=0;
      if(nTrk_V1 < nTrk_V2){
        for(int i=0; i<nTrk_V1; i++){
          int trk=(*wrkVrtSet)[V1].selTrk[i];
          for(int j=0; j<nTrk_V2; j++){ if( trk==(*wrkVrtSet)[V2].selTrk[j]){ nTrkCom++; break;} }
        }
      }else{
        for(int i=0; i<nTrk_V2; i++){
          int trk=(*wrkVrtSet)[V2].selTrk[i];
          for(int j=0; j<nTrk_V1; j++){ if( trk==(*wrkVrtSet)[V1].selTrk[j]){ nTrkCom++; break;} }
        }
      }
      return nTrkCom;
   }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

PntPntDist()

double Rec::NewVrtSecInclusiveTool::PntPntDist ( const Amg::Vector3D & Vrt1, const Amg::Vector3D & Vrt2 )

staticprivate

Definition at line 149 of file Reconstruction/VKalVrt/NewVrtSecInclusiveTool/src/Utilities.cxx.

  { 
    double dx =  Vrt1.x()- Vrt2.x();
    double dy =  Vrt1.y()- Vrt2.y();
    double dz =  Vrt1.z()- Vrt2.z();
    return std::sqrt(dx*dx+dy*dy*dz*dz);
  }

printWrkSet()

void Rec::NewVrtSecInclusiveTool::printWrkSet ( const std::vector< WrkVrt > * WrkSet, const std::string & name ) const

private

Definition at line 27 of file Reconstruction/VKalVrt/NewVrtSecInclusiveTool/src/Utilities.cxx.

                                                                                                          {
    int nGoodV=0;
    if(msgLvl(MSG::INFO)){
    for(int iv=0; iv<(int)WrkVrtSet->size(); iv++) {
      msg(MSG::INFO)<<name
      <<"= "<<(*WrkVrtSet)[iv].vertex[0]
      <<", "<<(*WrkVrtSet)[iv].vertex[1]
      <<", "<<(*WrkVrtSet)[iv].vertex[2]
      <<" NTrk="<<(*WrkVrtSet)[iv].selTrk.size()
      <<" is good="<<std::boolalpha<<(*WrkVrtSet)[iv].Good<<std::noboolalpha
      <<"  Chi2="<<(*WrkVrtSet)[iv].chi2
      <<"  Mass="<<(*WrkVrtSet)[iv].vertexMom.M()
      <<"  detached="<<(*WrkVrtSet)[iv].detachedTrack
      <<"  proj.dist="<<(*WrkVrtSet)[iv].projectedVrt
      <<" trk=";
      for(int kk=0; kk<(int)(*WrkVrtSet)[iv].selTrk.size(); kk++) {
                msg(MSG::INFO)<<", "<<(*WrkVrtSet)[iv].selTrk[kk];}
      for(int kk=0; kk<(int)(*WrkVrtSet)[iv].selTrk.size(); kk++) {
                msg(MSG::INFO)<<", "<<momAtVrt((*WrkVrtSet)[iv].trkAtVrt[kk]).Pt();}
      msg(MSG::INFO)<<endmsg;
      if((*WrkVrtSet)[iv].Good)nGoodV++;
    }
    msg(MSG::INFO)<<name<<" N="<<nGoodV<<endmsg; 
    }
  }

projSV_PV()

double Rec::NewVrtSecInclusiveTool::projSV_PV ( const Amg::Vector3D & SV, const xAOD::Vertex & PV, const TLorentzVector & Direction )

staticprivate

Definition at line 54 of file Reconstruction/VKalVrt/NewVrtSecInclusiveTool/src/Utilities.cxx.

  {  
     TVector3 SV_PV( SV.x()-PV.x(), SV.y()-PV.y(), SV.z()-PV.z() );
     return Direction.Vect().Unit()*SV_PV.Unit();
  }

refineVerticesWithCommonTracks()

double Rec::NewVrtSecInclusiveTool::refineVerticesWithCommonTracks ( WrkVrt & v1, WrkVrt & v2, std::vector< const xAOD::TrackParticle * > & allTrackList, Trk::IVKalState & istate ) const

private

Definition at line 100 of file MultiUtilities.cxx.

   {
      if(!v1.Good || !v2.Good)return -1.;         //bad vertex check for safety
 
      int ntv1=v1.selTrk.size();
      int ntv2=v2.selTrk.size();
      if( ntv1<2 || ntv2<2 ) return -1.;          //for safety
      double prb_v1=TMath::Prob( v1.chi2, 2*ntv1-3);
      double prb_v2=TMath::Prob( v2.chi2, 2*ntv2-3);
      WrkVrt * badV =&v1;
      WrkVrt * goodV=&v2;
      bool swap=false;
      //---- Good vertex selection
      if(prb_v1>0.01&&prb_v2>0.01){     //Both vertices are good Prob>1%
         if( ntv1==ntv2 ) {if(prb_v1>prb_v2) swap=true;}  //If multiplicities are equal- select better Chi2
         else             {if(ntv1>ntv2)     swap=true;}
      }
      if(prb_v1<0.01&&prb_v2<0.01){     //Both vertices are bad Prob<1%
         if(prb_v1>prb_v2) swap=true;   // select better Chi2
      }
      if(prb_v1>0.01&&prb_v2<0.01){     //Second vertex is bad Prob<1%
         if(prb_v1>prb_v2) swap=true;   
      }
      if(swap) {badV =&v2; goodV =&v1;}
      int badVNtrk=(*badV).selTrk.size();
      //-----------------
      unsigned int it=0;
      while( it<(*badV).selTrk.size() ){
         int trk=(*badV).selTrk[it];
         if(std::find((*goodV).selTrk.begin(),(*goodV).selTrk.end(),trk) != (*goodV).selTrk.end()){
            (*badV).selTrk.erase((*badV).selTrk.begin()+it);
            (*badV).detachedTrack=trk;
         } else it++;
      }
      if((*badV).selTrk.size()<2){
         (*badV).Good=false;
         if((*badV).selTrk.size()==1 && m_multiWithOneTrkVrt){  //Special case if 1-track vertices are allowed
           (*badV).vertexCharge=allTrackList[(*badV).selTrk.at(0)]->charge();
           (*badV).vertexMom=allTrackList[(*badV).selTrk.at(0)]->p4();
           if( badVNtrk>=2 && TMath::Prob((*badV).chi2,2*badVNtrk-3)>0.1 ) (*badV).Good=true;  //Accept only if original vertex prob>10%!
         }
         return -1.;
      }
      return refitVertex((*badV),allTrackList, istate, false);
   }

refitVertex()

double Rec::NewVrtSecInclusiveTool::refitVertex ( WrkVrt & Vrt, std::vector< const xAOD::TrackParticle * > & SelectedTracks, Trk::IVKalState & istate, bool ifCovV0 ) const

private

Definition at line 221 of file MultiUtilities.cxx.

   {
      int i,j;
      int nth = vrt.selTrk.size();
 
      if(nth<2) return -1.;
 
      std::vector<const xAOD::NeutralParticle*> neutralPartDummy(0);
      std::vector<const xAOD::TrackParticle*>  listTracks(0);
      for(i=0;i<nth;i++) {
          j=vrt.selTrk[i];                           /*Track number*/
          listTracks.push_back( selectedTracks[j] );
      }
      vrt.Good = false;
      vrt.chi2PerTrk.resize(nth);
      for(i=0;i<nth;i++)vrt.chi2PerTrk[i]=100000.+i; //VK safety
 
      m_fitSvc->setApproximateVertex(vrt.vertex[0],vrt.vertex[1],vrt.vertex[2],istate);
      StatusCode sc=m_fitSvc->VKalVrtFit(listTracks,neutralPartDummy,vrt.vertex,vrt.vertexMom,vrt.vertexCharge,
                                         vrt.vertexCov,vrt.chi2PerTrk, vrt.trkAtVrt,vrt.chi2,
                                         istate, ifCovV0);
      if(sc.isSuccess())vrt.Good = true;
      else {vrt.Good = false; return -1.;}
      if(vrt.chi2PerTrk.size()==2) vrt.chi2PerTrk[0]=vrt.chi2PerTrk[1]=vrt.chi2/2.;
      return TMath::Prob( vrt.chi2, 2*nth-1);
   }

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< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

select2TrVrt()

void Rec::NewVrtSecInclusiveTool::select2TrVrt ( std::vector< const xAOD::TrackParticle * > & SelectedTracks, const xAOD::Vertex & primVrt, std::map< long int, std::vector< double > > & vrt, compatibilityGraph_t & compatibilityGraph ) const

private

-—Prepare data for selector

Definition at line 31 of file Sel2TrkVertices.cxx.

    {
      std::vector<const xAOD::NeutralParticle*> neutralPartDummy(0);
      std::vector<const xAOD::TrackParticle*>  tracksForFit(2,nullptr);
      std::vector<double> impact,impactError;
      std::vector<double> inpMass(2,m_massPi);
      long int      Charge;
      int i,j;
      StatusCode sc;
      Vrt2Tr tmpVrt;
      std::vector<Vrt2Tr> all2TrVrt(0);
      TLorentzVector PSum2T; 
      Amg::Vector3D iniVrt(0.,0.,0.);
//
      int NTracks = (int) (selectedTracks.size());
//
//  impact parameters with sign calculations
//
      uint8_t nPixelHits;
      double signifR=0.,signifZ=0.;
      std::vector<int> nPixHits(NTracks,0);
      std::vector<double> trackSignif(NTracks),dRdZratio(NTracks);
      for (i=0; i<NTracks; i++) {
         m_fitSvc->VKalGetImpact(selectedTracks[i], primVrt.position(), 1, impact, impactError);
         signifR = impact[0]/ sqrt(impactError[0]);
         signifZ = impact[1]/ sqrt(impactError[2]);
         trackSignif[i] = sqrt( signifR*signifR + signifZ*signifZ);
         dRdZratio[i] = std::abs(signifR/signifZ);
         if( !(selectedTracks[i]->summaryValue(nPixelHits,xAOD::numberOfPixelHits)) ) nPixelHits=0;
         nPixHits[i]=nPixelHits;
         if(m_fillHist){
            Hists& h = getHists();
            h.m_hb_impactR->Fill( signifR, m_w_1);
            h.m_hb_impactZ->Fill( signifZ, m_w_1);
            h.m_hb_impactRZ->Fill(signifR, signifZ, m_w_1); 
            h.m_hb_impact->Fill( trackSignif[i], m_w_1);
            if( i<DevTuple::maxNTrk){
               Hists& h = getHists();
               h.m_curTup->pttrk[i]=selectedTracks[i]->pt();
               h.m_curTup->d0trk[i]=selectedTracks[i]->d0();
               h.m_curTup->Sig3D[i]=trackSignif[i];
               h.m_curTup->idHF[i] =getIdHF(selectedTracks[i]);
               h.m_curTup->dRdZrat[i] =dRdZratio[i];
               h.m_curTup->displaced[i]=isDisplaced(selectedTracks[i]);
 
               uint8_t TRTHits;
               if( !(selectedTracks[i]->summaryValue(  TRTHits,xAOD::numberOfTRTHits))) TRTHits=0;
               h.m_curTup->trkTRT[i] =TRTHits;
               h.m_curTup->etatrk[i] =selectedTracks[i]->eta();
           }
         }
      }
 
      if( m_fillHist ){
          Hists& h = getHists();
          h.m_curTup->nTrk=NTracks < DevTuple::maxNTrk ? NTracks : DevTuple::maxNTrk ;
          h.m_curTup->n2Vrt=0;
      }
   
      std::vector<std::vector<std::tuple<int,float>>> trkCount(NTracks);
      std::unique_ptr<Trk::IVKalState> state = m_fitSvc->makeState();
      m_fitSvc->setMassInputParticles( inpMass, *state );     // Use pion masses for fit
      for (i=0; i<NTracks-1; i++) {
         if(trackSignif[i]<m_trkSigCut || dRdZratio[i]<m_dRdZRatioCut )continue;
         for (j=i+1; j<NTracks; j++) {
             if(trackSignif[j]<m_trkSigCut || dRdZratio[j]<m_dRdZRatioCut )continue;
             PSum2T=selectedTracks[i]->p4()+selectedTracks[j]->p4();
             if( std::abs(selectedTracks[i]->eta()-selectedTracks[j]->eta())==0 &&
                 std::abs(selectedTracks[i]->phi()-selectedTracks[j]->phi())==0 &&
                 std::abs(selectedTracks[i]->pt() -selectedTracks[j]->pt())==0 ) continue; //remove duplicated tracks
             tracksForFit[0]=selectedTracks[i];
             tracksForFit[1]=selectedTracks[j];
             double minDZ=0.;
             sc=m_fitSvc->VKalVrtFitFast(tracksForFit,tmpVrt.fitVertex,minDZ,*state);            /* Fast crude estimation*/
             if( sc.isFailure()  ) {   /* No initial estimation */ 
                iniVrt=primVrt.position();
             } else {
                double cosMomVrtDir = projSV_PV(tmpVrt.fitVertex,primVrt,PSum2T);
                if( cosMomVrtDir>0. ) iniVrt=tmpVrt.fitVertex;                /* Good initial estimation */ 
                else                  iniVrt=primVrt.position();
             }
             if(nPixHits[i]>0 && nPixHits[j]>0){ if(minDZ>   m_fastZSVCut) continue; } // Drop SV candidates with big Z track-track distance.
             else{                               if(minDZ>2.*m_fastZSVCut) continue; } // Drop SV candidates with big Z track-track distance.  
             m_fitSvc->setApproximateVertex(iniVrt.x(), iniVrt.y(), iniVrt.z(), *state);
             sc=m_fitSvc->VKalVrtFit(tracksForFit, neutralPartDummy, tmpVrt.fitVertex, tmpVrt.momentum, Charge,
                                  tmpVrt.errorMatrix, tmpVrt.chi2PerTrk, tmpVrt.trkAtVrt, tmpVrt.chi2, *state, false );
             if(sc.isFailure())           continue;          /* No fit */ 
             if(tmpVrt.chi2>20.)          continue;    /*Too bad Chi2 for nDoF=1 fit*/    
             float vQuality;
             xAOD::Vertex testV;
             testV.makePrivateStore();
             testV.setPosition(tmpVrt.fitVertex);
             std::vector<float> testVcov(tmpVrt.errorMatrix.begin(),tmpVrt.errorMatrix.end());
             testV.setCovariance(testVcov);
             testV.setFitQuality(tmpVrt.chi2,1.);
             bool acceptV=m_ini_v2trselector->isgood(std::make_pair(selectedTracks[i],selectedTracks[j]), testV, 
                              std::make_pair(momAtVrt(tmpVrt.trkAtVrt[0]),momAtVrt(tmpVrt.trkAtVrt[1])), primVrt, vQuality);
             if(!acceptV) continue; // Main 2-track vertex selection
 
 
//Check close material layer. Not validated in detail, use with care.
             double vrtR=tmpVrt.fitVertex.perp();
             double dstMatSignif=1.e4;
             if(m_removeTrkMatSignif>0. && vrtR>20.){
                double vrtRErr=vrtRadiusError(tmpVrt.fitVertex,tmpVrt.errorMatrix );               
                if(vrtR<30.){ dstMatSignif=std::abs(vrtR-m_beampipeR)/vrtRErr;}
                else        { dstMatSignif=distToMatLayerSignificance(tmpVrt);}     //Material in Pixel volume
                if(dstMatSignif<m_removeTrkMatSignif)continue;
             }
//
// Debugging and BDT
             double minPtT = std::min(tracksForFit[0]->pt(),tracksForFit[1]->pt());
             if( m_fillHist ){
                float ihitR  = selectedTracks[i]->radiusOfFirstHit();
                float jhitR  = selectedTracks[j]->radiusOfFirstHit();
                int ihitIBL  = getIBLHit(selectedTracks[i]);
                int jhitIBL  = getIBLHit(selectedTracks[j]);
                int ihitBL   = getBLHit (selectedTracks[i]);
                int jhitBL   = getBLHit (selectedTracks[j]);
                double Prob2v=TMath::Prob(tmpVrt.chi2,1);
                double cosSVPV=projSV_PV(tmpVrt.fitVertex, primVrt, tmpVrt.momentum);
                ROOT::Math::PxPyPzMVector SVPV(tmpVrt.fitVertex.x()-primVrt.x(),
                                               tmpVrt.fitVertex.y()-primVrt.y(),
                                               tmpVrt.fitVertex.z()-primVrt.z(), 10.);
 
                Hists& h = getHists();
 
                if(Charge==0){h.m_hb_massPiPi->Fill(tmpVrt.momentum.M(),1.);}
                h.m_hb_cosSVMom->Fill(cosSVPV,1.);
                h.m_hb_etaSV->Fill(SVPV.Eta(),1.);
 
                double Sig3D=0.,Sig2D=0., Dist2D=0.; 
                int idisk1=0,idisk2=0,idisk3=0,jdisk1=0,jdisk2=0,jdisk3=0;
                int sumIBLHits =  std::max(ihitIBL,0)+std::max(jhitIBL,0);
                int sumBLHits  =  std::max(ihitBL, 0)+std::max(jhitBL, 0);
                getPixelDiscs(selectedTracks[i],idisk1,idisk2,idisk3);
                getPixelDiscs(selectedTracks[j],jdisk1,jdisk2,jdisk3);
                vrtVrtDist(primVrt, tmpVrt.fitVertex, tmpVrt.errorMatrix, Sig3D);
                Dist2D=vrtVrtDist2D(primVrt, tmpVrt.fitVertex, tmpVrt.errorMatrix, Sig2D);
                int barVrt1=getProdVrtBarcode(tracksForFit[0],0.1); // FIXME barcode-based
                int barVrt2=getProdVrtBarcode(tracksForFit[1],0.1); // FIXME barcode-based
                h.m_hb_signif3D->Fill(Sig3D,1.);
                h.m_curTup->VrtTrkHF [h.m_curTup->n2Vrt] = getIdHF(tracksForFit[0])+ getIdHF(tracksForFit[1]);
                h.m_curTup->VrtTrkI  [h.m_curTup->n2Vrt] = getG4Inter(tracksForFit[0])+ getG4Inter(tracksForFit[1]);
                h.m_curTup->VrtTrueBar[h.m_curTup->n2Vrt]  = (barVrt1 && barVrt2 && barVrt1==barVrt2) ? 1 : 0;
                h.m_curTup->VrtTrueNear[h.m_curTup->n2Vrt] = checkTrue2TrVrt(tracksForFit[0],tracksForFit[1],0.1);
                h.m_curTup->VrtCh    [h.m_curTup->n2Vrt] = Charge;
                h.m_curTup->VrtProb  [h.m_curTup->n2Vrt] = Prob2v;
                h.m_curTup->VrtSig3D [h.m_curTup->n2Vrt] = Sig3D;
                h.m_curTup->VrtSig2D [h.m_curTup->n2Vrt] = Sig2D;
                h.m_curTup->VrtDist2D[h.m_curTup->n2Vrt] = vrtR<20. ? Dist2D : vrtR;
                h.m_curTup->VrtM     [h.m_curTup->n2Vrt] = tmpVrt.momentum.M();
                h.m_curTup->VrtZ     [h.m_curTup->n2Vrt] = tmpVrt.fitVertex.z();
                h.m_curTup->VrtPt    [h.m_curTup->n2Vrt] = tmpVrt.momentum.Pt();
                h.m_curTup->VrtEta   [h.m_curTup->n2Vrt] = SVPV.Eta();
                h.m_curTup->VrtIBL   [h.m_curTup->n2Vrt] = sumIBLHits;
                h.m_curTup->VrtBL    [h.m_curTup->n2Vrt] = sumBLHits;
                h.m_curTup->VrtCosSPM[h.m_curTup->n2Vrt] = cosSVPV;
                h.m_curTup->VMinPtT  [h.m_curTup->n2Vrt] = minPtT;
                h.m_curTup->VMinS3DT [h.m_curTup->n2Vrt] = std::min(trackSignif[i],trackSignif[j]);
                h.m_curTup->VMaxS3DT [h.m_curTup->n2Vrt] = std::max(trackSignif[i],trackSignif[j]);
                h.m_curTup->VrtBDT   [h.m_curTup->n2Vrt] = vQuality;
                h.m_curTup->VrtHR1   [h.m_curTup->n2Vrt] = ihitR;
                h.m_curTup->VrtHR2   [h.m_curTup->n2Vrt] = jhitR;
                h.m_curTup->VrtDZ    [h.m_curTup->n2Vrt] = minDZ;
                h.m_curTup->VrtDisk  [h.m_curTup->n2Vrt] = idisk1+10*idisk2+20*idisk3+30*jdisk1+40*jdisk2+50*jdisk3;
                h.m_curTup->VSigMat  [h.m_curTup->n2Vrt] = dstMatSignif;
                h.m_curTup->VrtIT    [h.m_curTup->n2Vrt] = i;
                h.m_curTup->VrtJT    [h.m_curTup->n2Vrt] = j;
                if(h.m_curTup->n2Vrt<DevTuple::maxNVrt-1)h.m_curTup->n2Vrt++;
             }
//
//---  Save good candidate for multi-vertex fit
//
             add_edge(i,j,compatibilityGraph);
             goodVrt[NTracks*i+j]=std::vector<double>{tmpVrt.fitVertex.x(),tmpVrt.fitVertex.y(),tmpVrt.fitVertex.z()};
             trkCount[i].emplace_back(j,vQuality); trkCount[j].emplace_back(i,vQuality);            
         }
      }
      //=== Resolve -!----!- case to speed up cluster finding
      for(int t=0; t<NTracks; t++){
         if(trkCount[t].size()==2){
            i=std::get<0>(trkCount[t][0]);
            j=std::get<0>(trkCount[t][1]);
            if(trkCount[i].size()==1 && trkCount[j].size()==1 ){
               if( std::get<1>(trkCount[t][0]) < std::get<1>(trkCount[t][1]) ) {
                  remove_edge(t,i,compatibilityGraph);
                  if(t<i)goodVrt.erase(NTracks*t+i); else goodVrt.erase(NTracks*i+t);
                  trkCount[i].clear();
                  trkCount[t].erase(trkCount[t].begin()+0);
               } else {
                  remove_edge(t,j,compatibilityGraph);
                  if(t<j)goodVrt.erase(NTracks*t+j); else goodVrt.erase(NTracks*j+t);
                  trkCount[j].clear();
                  trkCount[t].erase(trkCount[t].begin()+1);
               }
            }      
         }
      }
 
   }

selGoodTrkParticle()

void Rec::NewVrtSecInclusiveTool::selGoodTrkParticle ( workVectorArrxAOD * xAODwrk, const xAOD::Vertex & primVrt ) const

private

Definition at line 21 of file Reconstruction/VKalVrt/NewVrtSecInclusiveTool/src/CutTrk.cxx.

   {    
    std::vector<const xAOD::TrackParticle*>& inpTrk          = xAODwrk->inpTrk;
    std::vector<const xAOD::TrackParticle*>& selectedTracks  = xAODwrk->listSelTracks;
    std::vector<const xAOD::TrackParticle*>::const_iterator   i_ntrk;
    std::vector<double> impact,impactError;
    std::multimap<double,const xAOD::TrackParticle*> orderedTrk;
    if(m_fillHist){
      Hists& h = getHists();
      h.m_hb_ntrkInput->Fill( inpTrk.size()+0.1, m_w_1);
    }
    for (i_ntrk = inpTrk.begin(); i_ntrk < inpTrk.end(); ++i_ntrk) {
//
//-- Perigee in TrackParticle
//
          if(m_fillHist){
            Hists& h = getHists();
            h.m_hb_trkSelect->Fill( 0., m_w_1);
          }
          if((*i_ntrk)->numberDoF() == 0) continue; //Protection
          double trkChi2 = (*i_ntrk)->chiSquared() / (*i_ntrk)->numberDoF();
          if(trkChi2           > m_cutChi2)          continue;
          if( (*i_ntrk)->pt()  < m_cutPt)            continue;
          if(m_fillHist){
            Hists& h = getHists();
            h.m_hb_trkSelect->Fill( 1., m_w_1);
          }
 
          const Trk::Perigee mPer=(*i_ntrk)->perigeeParameters() ;
          const AmgSymMatrix(5) * locCov = mPer.covariance();
          const double CovTrkMtx00 = (*locCov)(0,0);
 
          uint8_t PixelHits,SctHits,BLayHits,TRTHits;
          if( !((*i_ntrk)->summaryValue(PixelHits,xAOD::numberOfPixelHits)) )   continue; // Track is
          if( !((*i_ntrk)->summaryValue(  SctHits,xAOD::numberOfSCTHits))   )   continue; // definitely
          if( SctHits<3 )                                                       continue; // bad
          if( !((*i_ntrk)->summaryValue(  TRTHits,xAOD::numberOfTRTHits))   )   continue;
          if( !((*i_ntrk)->summaryValue(BLayHits,xAOD::numberOfInnermostPixelLayerHits)))  BLayHits=0;
          if(m_fillHist){
            Hists& h = getHists();
            h.m_hb_trkSelect->Fill( 2., m_w_1);
          }
 
          Amg::Vector3D perigeePos=mPer.position();
          double impactD0=sqrt( (perigeePos.x()-primVrt.x())*(perigeePos.x()-primVrt.x())
                               +(perigeePos.y()-primVrt.y())*(perigeePos.y()-primVrt.y()) );
          double impactZ=perigeePos.z()-primVrt.z();
          if(m_fillHist){  
            Hists& h = getHists();
            h.m_hb_trkD0->Fill( impactD0, m_w_1);
            h.m_hb_trkZ ->Fill( impactZ, m_w_1);
          }
          if(std::abs(impactZ)*std::sin((*i_ntrk)->theta())>m_maxZVrt && m_maxZVrt > 0.) continue;
          if(std::abs(impactZ)*std::sin((*i_ntrk)->theta())<m_minZVrt && m_minZVrt > 0.) continue;
          if(impactD0>m_cutD0Max)        continue;
          if(impactD0<m_cutD0Min)        continue;
          if(m_fillHist){
            Hists& h = getHists();
            h.m_hb_trkSelect->Fill( 3., m_w_1);
          }
 
          double bX=xAODwrk->beamX + (perigeePos.z()-xAODwrk->beamZ)*xAODwrk->tanBeamTiltX;
          double bY=xAODwrk->beamY + (perigeePos.z()-xAODwrk->beamZ)*xAODwrk->tanBeamTiltY;
          double impactBeam=sqrt( (perigeePos.x()-bX)*(perigeePos.x()-bX) + (perigeePos.y()-bY)*(perigeePos.y()-bY));
//----Anti-pileup
          double signifBeam = impactBeam    / sqrt(CovTrkMtx00);
          if(signifBeam < m_antiPileupSigRCut) continue;   // cut against tracks from pileup vertices
          if(m_fillHist){
            Hists& h = getHists();
            h.m_hb_trkSelect->Fill( 4., m_w_1);
          }
//----
          if(PixelHits      < m_cutPixelHits)       continue;
          if(SctHits        < m_cutSctHits)         continue;
          if((PixelHits+SctHits) < m_cutSiHits)     continue;
          if(BLayHits       < m_cutBLayHits)        continue;
          if(std::abs((*i_ntrk)->eta())<1.9 && TRTHits < m_cutTRTHits) continue; //TRT hits must be present inside TRT
          if(m_fillHist){
            Hists& h = getHists();
            h.m_hb_trkSelect->Fill( 5., m_w_1);
          }
//----
          orderedTrk.emplace(signifBeam,*i_ntrk);
          selectedTracks.push_back(*i_ntrk);
      }
//---- Order tracks according to ranks
      std::map<double,const xAOD::TrackParticle*>::reverse_iterator rt=orderedTrk.rbegin();
      selectedTracks.resize(orderedTrk.size());
      for ( int cntt=0; rt!=orderedTrk.rend(); ++rt,++cntt) {selectedTracks[cntt]=(*rt).second;}
        }

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::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);
      }
    }
  }

vrtRadiusError()

double Rec::NewVrtSecInclusiveTool::vrtRadiusError ( const Amg::Vector3D & secVrt, const std::vector< double > & vrtErr )

staticprivate

Definition at line 160 of file Reconstruction/VKalVrt/NewVrtSecInclusiveTool/src/Utilities.cxx.

  {
    double DirX=SecVrt.x(), DirY=SecVrt.y(); 
    double Covar =    DirX*VrtErr[0]*DirX
                  +2.*DirX*VrtErr[1]*DirY
                     +DirY*VrtErr[2]*DirY;
    Covar /= DirX*DirX + DirY*DirY;
    Covar=std::sqrt(std::abs(Covar));
    if(Covar != Covar)  Covar = 0.;
    return Covar;
  }

vrtVrtDist() [1/2]

double Rec::NewVrtSecInclusiveTool::vrtVrtDist ( const Amg::Vector3D & vrt1, const std::vector< double > & vrtErr1, const Amg::Vector3D & vrt2, const std::vector< double > & vrtErr2 )

staticprivate

Definition at line 119 of file Reconstruction/VKalVrt/NewVrtSecInclusiveTool/src/Utilities.cxx.

  {
    double distx =  vrt1.x()- vrt2.x();
    double disty =  vrt1.y()- vrt2.y();
    double distz =  vrt1.z()- vrt2.z();
 
    AmgSymMatrix(3)  primCovMtx;  //Create
    primCovMtx(0,0) =                   vrtErr1[0]+vrtErr2[0];
    primCovMtx(0,1) = primCovMtx(1,0) = vrtErr1[1]+vrtErr2[1];
    primCovMtx(1,1) =                   vrtErr1[2]+vrtErr2[2];
    primCovMtx(0,2) = primCovMtx(2,0) = vrtErr1[3]+vrtErr2[3];
    primCovMtx(1,2) = primCovMtx(2,1) = vrtErr1[4]+vrtErr2[4];
    primCovMtx(2,2) =                   vrtErr1[5]+vrtErr2[5];
 
    AmgSymMatrix(3)  wgtMtx = primCovMtx.inverse();
 
    double signif = 
               distx*wgtMtx(0,0)*distx
              +disty*wgtMtx(1,1)*disty
              +distz*wgtMtx(2,2)*distz
           +2.*distx*wgtMtx(0,1)*disty
           +2.*distx*wgtMtx(0,2)*distz
           +2.*disty*wgtMtx(1,2)*distz;
    signif=std::sqrt(std::abs(signif));
    if(signif != signif)  signif = 0.;
    return signif;
  }

vrtVrtDist() [2/2]

double Rec::NewVrtSecInclusiveTool::vrtVrtDist ( const xAOD::Vertex & primVrt, const Amg::Vector3D & secVrt, const std::vector< double > & vrtErr, double & signif )

staticprivate

Definition at line 60 of file Reconstruction/VKalVrt/NewVrtSecInclusiveTool/src/Utilities.cxx.

  {
    double distx =  primVrt.x()- secVrt.x();
    double disty =  primVrt.y()- secVrt.y();
    double distz =  primVrt.z()- secVrt.z();
 
 
    AmgSymMatrix(3)  primCovMtx=primVrt.covariancePosition();  //Create
    primCovMtx(0,0) += secVrtErr[0];
    primCovMtx(0,1) += secVrtErr[1];
    primCovMtx(1,0) += secVrtErr[1];
    primCovMtx(1,1) += secVrtErr[2];
    primCovMtx(0,2) += secVrtErr[3];
    primCovMtx(2,0) += secVrtErr[3];
    primCovMtx(1,2) += secVrtErr[4];
    primCovMtx(2,1) += secVrtErr[4];
    primCovMtx(2,2) += secVrtErr[5];
 
    AmgSymMatrix(3)  wgtMtx = primCovMtx.inverse();
 
    signif = distx*wgtMtx(0,0)*distx
            +disty*wgtMtx(1,1)*disty
            +distz*wgtMtx(2,2)*distz
         +2.*distx*wgtMtx(0,1)*disty
         +2.*distx*wgtMtx(0,2)*distz
         +2.*disty*wgtMtx(1,2)*distz;
    signif=std::sqrt(std::abs(signif));
    if( signif!=signif ) signif = 0.;
    return std::sqrt(distx*distx+disty*disty+distz*distz);
  }

vrtVrtDist2D()

double Rec::NewVrtSecInclusiveTool::vrtVrtDist2D ( const xAOD::Vertex & primVrt, const Amg::Vector3D & secVrt, const std::vector< double > & vrtErr, double & signif )

staticprivate

Definition at line 93 of file Reconstruction/VKalVrt/NewVrtSecInclusiveTool/src/Utilities.cxx.

  {
    double distx =  primVrt.x()- secVrt.x();
    double disty =  primVrt.y()- secVrt.y();
 
 
    AmgSymMatrix(3)  primCovMtx=primVrt.covariancePosition();  //Create
    AmgSymMatrix(2)  covMtx;
    covMtx(0,0) = primCovMtx(0,0) + secVrtErr[0];
    covMtx(0,1) = primCovMtx(0,1) + secVrtErr[1];
    covMtx(1,0) = primCovMtx(1,0) + secVrtErr[1];
    covMtx(1,1) = primCovMtx(1,1) + secVrtErr[2];
 
    AmgSymMatrix(2)  wgtMtx = covMtx.inverse();
 
    signif = distx*wgtMtx(0,0)*distx
            +disty*wgtMtx(1,1)*disty
         +2.*distx*wgtMtx(0,1)*disty;
    signif=std::sqrt(std::abs(signif));
    if( signif!=signif ) signif = 0.;
    return std::sqrt(distx*distx+disty*disty);
  }

Member Data Documentation

m_antiPileupSigRCut

Gaudi::Property<float> Rec::NewVrtSecInclusiveTool::m_antiPileupSigRCut {this, "AntiPileupSigRCut", 2.0, "Upper cut on significance of 2D distance between beam and perigee" }

private

Definition at line 160 of file NewVrtSecInclusiveTool.h.

{this, "AntiPileupSigRCut", 2.0,  "Upper cut on significance of 2D distance between beam and perigee"  };

m_augString

Gaudi::Property<std::string> Rec::NewVrtSecInclusiveTool::m_augString {this, "AugmentingVersionString", "_NVSI", "Augmentation version string"}

private

Definition at line 193 of file NewVrtSecInclusiveTool.h.

{this, "AugmentingVersionString", "_NVSI", "Augmentation version string"};

m_beampipeR

Gaudi::Property<float> Rec::NewVrtSecInclusiveTool::m_beampipeR {this, "BeampipeR", 24.3, "Radius of the beampipe material for aggressive material rejection" }

private

Definition at line 171 of file NewVrtSecInclusiveTool.h.

{this, "BeampipeR",   24.3, "Radius of the beampipe material for aggressive material rejection" };

m_beamSpotKey

SG::ReadCondHandleKey<InDet::BeamSpotData> Rec::NewVrtSecInclusiveTool::m_beamSpotKey { this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" }

private

Definition at line 182 of file NewVrtSecInclusiveTool.h.

{ this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" };

m_chi2_toSV

SG::AuxElement::Decorator<float> Rec::NewVrtSecInclusiveTool::m_chi2_toSV

private

Definition at line 212 of file NewVrtSecInclusiveTool.h.

m_chiScale

float Rec::NewVrtSecInclusiveTool::m_chiScale[11] {}

private

Definition at line 312 of file NewVrtSecInclusiveTool.h.

{};

m_cutBLayHits

Gaudi::Property<int> Rec::NewVrtSecInclusiveTool::m_cutBLayHits {this, "CutBLayHits", 0, "Remove track if it has less B-layer hits" }

private

Definition at line 152 of file NewVrtSecInclusiveTool.h.

{this,  "CutBLayHits",  0, "Remove track if it has less B-layer hits"   };

m_cutChi2

Gaudi::Property<float> Rec::NewVrtSecInclusiveTool::m_cutChi2 {this, "CutChi2", 5., "Track Chi2 selection cut" }

private

Definition at line 159 of file NewVrtSecInclusiveTool.h.

{this,    "CutChi2",     5.,  "Track Chi2 selection cut" };

m_cutD0Max

Gaudi::Property<float> Rec::NewVrtSecInclusiveTool::m_cutD0Max {this, "CutD0Max", 10., "Track maximal D0 selection cut" }

private

Definition at line 156 of file NewVrtSecInclusiveTool.h.

{this,   "CutD0Max",   10.,  "Track maximal D0 selection cut"  };

m_cutD0Min

Gaudi::Property<float> Rec::NewVrtSecInclusiveTool::m_cutD0Min {this, "CutD0Min", 0., "Track minimal D0 selection cut" }

private

Definition at line 155 of file NewVrtSecInclusiveTool.h.

{this,   "CutD0Min",    0.,  "Track minimal D0 selection cut"  };

m_cutPixelHits

Gaudi::Property<int> Rec::NewVrtSecInclusiveTool::m_cutPixelHits {this, "CutPixelHits", 2, "Remove track if it has less Pixel hits"}

private

Definition at line 149 of file NewVrtSecInclusiveTool.h.

{this, "CutPixelHits", 2, "Remove track if it has less Pixel hits"};

m_cutPt

Gaudi::Property<float> Rec::NewVrtSecInclusiveTool::m_cutPt {this, "CutPt", 500., "Track Pt selection cut" }

private

Definition at line 154 of file NewVrtSecInclusiveTool.h.

{this,      "CutPt",     500.,  "Track Pt selection cut"  };

m_cutSctHits

Gaudi::Property<int> Rec::NewVrtSecInclusiveTool::m_cutSctHits {this, "CutSctHits", 4, "Remove track if it has less SCT hits" }

private

Definition at line 148 of file NewVrtSecInclusiveTool.h.

{this,   "CutSctHits",   4, "Remove track if it has less SCT hits" };

m_cutSharedHits

Gaudi::Property<int> Rec::NewVrtSecInclusiveTool::m_cutSharedHits {this,"CutSharedHits",1, "Reject final 2tr vertices if tracks have shared hits" }

private

Definition at line 153 of file NewVrtSecInclusiveTool.h.

{this,"CutSharedHits",1, "Reject final 2tr vertices if tracks have shared hits" };

m_cutSiHits

Gaudi::Property<int> Rec::NewVrtSecInclusiveTool::m_cutSiHits {this, "CutSiHits", 8, "Remove track if it has less Pixel+SCT hits" }

private

Definition at line 151 of file NewVrtSecInclusiveTool.h.

{this,    "CutSiHits",    8, "Remove track if it has less Pixel+SCT hits"  };

m_cutTRTHits

Gaudi::Property<int> Rec::NewVrtSecInclusiveTool::m_cutTRTHits {this, "CutTRTHits", 10, "Remove track if it has less TRT hits"}

private

Definition at line 150 of file NewVrtSecInclusiveTool.h.

{this,   "CutTRTHits",  10, "Remove track if it has less TRT hits"};

m_d0_wrtSV

SG::AuxElement::Decorator<float> Rec::NewVrtSecInclusiveTool::m_d0_wrtSV

private

Definition at line 207 of file NewVrtSecInclusiveTool.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_dRdZRatioCut

Gaudi::Property<float> Rec::NewVrtSecInclusiveTool::m_dRdZRatioCut {this, "dRdZRatioCut", 0.25, "Cut on dR/dZ ratio to remove pileup tracks" }

private

Definition at line 164 of file NewVrtSecInclusiveTool.h.

{this, "dRdZRatioCut", 0.25, "Cut on dR/dZ ratio to remove pileup tracks"  };

m_errd0_wrtSV

SG::AuxElement::Decorator<float> Rec::NewVrtSecInclusiveTool::m_errd0_wrtSV

private

Definition at line 210 of file NewVrtSecInclusiveTool.h.

m_errP_wrtSV

SG::AuxElement::Decorator<float> Rec::NewVrtSecInclusiveTool::m_errP_wrtSV

private

Definition at line 209 of file NewVrtSecInclusiveTool.h.

m_errz0_wrtSV

SG::AuxElement::Decorator<float> Rec::NewVrtSecInclusiveTool::m_errz0_wrtSV

private

Definition at line 211 of file NewVrtSecInclusiveTool.h.

m_eta_wrtSV

SG::AuxElement::Decorator<float> Rec::NewVrtSecInclusiveTool::m_eta_wrtSV

private

Definition at line 205 of file NewVrtSecInclusiveTool.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_extrapolator

ToolHandle<Trk::IExtrapolator> Rec::NewVrtSecInclusiveTool::m_extrapolator {this,"ExtrapolatorName","Trk::Extrapolator/Extrapolator", "Name of the extrapolator tool"}

private

Definition at line 184 of file NewVrtSecInclusiveTool.h.

{this,"ExtrapolatorName","Trk::Extrapolator/Extrapolator", "Name of the extrapolator tool"};

m_fastZSVCut

Gaudi::Property<float> Rec::NewVrtSecInclusiveTool::m_fastZSVCut {this, "FastZSVCut", 10., "Cut to remove SV candidates based on fast SV estimation. To save full fit CPU." }

private

Definition at line 167 of file NewVrtSecInclusiveTool.h.

{this, "FastZSVCut",        10.,  "Cut to remove SV candidates based on fast SV estimation. To save full fit CPU."  };

m_fillHist

Gaudi::Property<bool> Rec::NewVrtSecInclusiveTool::m_fillHist {this, "FillHist", false, "Fill debugging and development histograms+ntuple" }

private

Definition at line 145 of file NewVrtSecInclusiveTool.h.

{this, "FillHist",   false, "Fill debugging and development histograms+ntuple"  };

m_fin_v2trselector

ToolHandle<Rec::ITwoTrackVertexSelector> Rec::NewVrtSecInclusiveTool::m_fin_v2trselector

private

Initial value:

{this, "TwoTrkVtxSelectorFinal", "Rec::TwoTrackVrtBDTSelector/V2TrBDTSelectorFin",
                                                                         "Name of the final 2-track vertex selector"}

Definition at line 190 of file NewVrtSecInclusiveTool.h.

                                                                {this, "TwoTrkVtxSelectorFinal", "Rec::TwoTrackVrtBDTSelector/V2TrBDTSelectorFin",
                                                                         "Name of the final 2-track vertex selector"};

m_fitSvc

ToolHandle<Trk::TrkVKalVrtFitter> Rec::NewVrtSecInclusiveTool::m_fitSvc {this, "VertexFitterTool", "Trk::TrkVKalVrtFitter/VertexFitterTool", "Name of the Vertex Fitter tool"}

private

Definition at line 185 of file NewVrtSecInclusiveTool.h.

{this, "VertexFitterTool", "Trk::TrkVKalVrtFitter/VertexFitterTool", "Name of the Vertex Fitter tool"};

m_globVrtProbCut

Gaudi::Property<float> Rec::NewVrtSecInclusiveTool::m_globVrtProbCut {this, "GlobVrtProbCut", 0.005, "Cut on probability of any vertex for final selection" }

private

Definition at line 175 of file NewVrtSecInclusiveTool.h.

{this, "GlobVrtProbCut", 0.005, "Cut on probability of any vertex for final selection"  };

m_h

std::unique_ptr<Hists> Rec::NewVrtSecInclusiveTool::m_h

private

Definition at line 144 of file NewVrtSecInclusiveTool.h.

m_ini_v2trselector

ToolHandle<Rec::ITwoTrackVertexSelector> Rec::NewVrtSecInclusiveTool::m_ini_v2trselector

private

Initial value:

{this, "TwoTrkVtxSelectorIni", "Rec::TwoTrackVrtBDTSelector/V2TrBDTSelectorIni",
                                                                         "Name of the initial 2-track vertex selector"}

Definition at line 188 of file NewVrtSecInclusiveTool.h.

                                                                {this, "TwoTrkVtxSelectorIni", "Rec::TwoTrackVrtBDTSelector/V2TrBDTSelectorIni",
                                                                         "Name of the initial 2-track vertex selector"};

m_instanceName

std::string Rec::NewVrtSecInclusiveTool::m_instanceName

private

Definition at line 200 of file NewVrtSecInclusiveTool.h.

m_is_selected

SG::AuxElement::Decorator<char> Rec::NewVrtSecInclusiveTool::m_is_selected

private

Definition at line 202 of file NewVrtSecInclusiveTool.h.

m_is_svtrk_final

SG::AuxElement::Decorator<char> Rec::NewVrtSecInclusiveTool::m_is_svtrk_final

private

Definition at line 203 of file NewVrtSecInclusiveTool.h.

m_massE

double Rec::NewVrtSecInclusiveTool::m_massE {}

private

Definition at line 197 of file NewVrtSecInclusiveTool.h.

{};

m_massK0

double Rec::NewVrtSecInclusiveTool::m_massK0 {}

private

Definition at line 198 of file NewVrtSecInclusiveTool.h.

{};

m_massLam

double Rec::NewVrtSecInclusiveTool::m_massLam {}

private

Definition at line 199 of file NewVrtSecInclusiveTool.h.

{};

m_massP

double Rec::NewVrtSecInclusiveTool::m_massP {}

private

Definition at line 196 of file NewVrtSecInclusiveTool.h.

{};

m_massPi

double Rec::NewVrtSecInclusiveTool::m_massPi {}

private

Definition at line 195 of file NewVrtSecInclusiveTool.h.

{};

m_maxSVRadiusCut

Gaudi::Property<float> Rec::NewVrtSecInclusiveTool::m_maxSVRadiusCut {this, "MaxSVRadiusCut", 140., "Cut on maximal radius of SV (def = Pixel detector size)" }

private

Definition at line 176 of file NewVrtSecInclusiveTool.h.

{this, "MaxSVRadiusCut",  140., "Cut on maximal radius of SV (def = Pixel detector size)"  };

m_maxZVrt

Gaudi::Property<float> Rec::NewVrtSecInclusiveTool::m_maxZVrt {this, "MaxZVrt", 15., "Track Z impact selection max"}

private

Definition at line 157 of file NewVrtSecInclusiveTool.h.

{this,    "MaxZVrt",    15.,  "Track Z impact selection max"};

m_minZVrt

Gaudi::Property<float> Rec::NewVrtSecInclusiveTool::m_minZVrt {this, "MinZVrt", 0., "Track Z impact selection min"}

private

Definition at line 158 of file NewVrtSecInclusiveTool.h.

{this,    "MinZVrt",     0.,  "Track Z impact selection min"};

m_multiWithOneTrkVrt

Gaudi::Property<bool> Rec::NewVrtSecInclusiveTool::m_multiWithOneTrkVrt {this, "MultiWithOneTrkVrt", true, "Allow one-track-vertex addition to already found secondary vertices"}

private

Definition at line 179 of file NewVrtSecInclusiveTool.h.

{this, "MultiWithOneTrkVrt", true, "Allow one-track-vertex addition to already found secondary vertices"};

m_phi_wrtSV

SG::AuxElement::Decorator<float> Rec::NewVrtSecInclusiveTool::m_phi_wrtSV

private

Definition at line 206 of file NewVrtSecInclusiveTool.h.

m_pt_wrtSV

SG::AuxElement::Decorator<float> Rec::NewVrtSecInclusiveTool::m_pt_wrtSV

private

Definition at line 204 of file NewVrtSecInclusiveTool.h.

m_removeTrkMatSignif

Gaudi::Property<float> Rec::NewVrtSecInclusiveTool::m_removeTrkMatSignif {this, "removeTrkMatSignif", 0., "Significance of Vertex-TrackingMaterial distance for removal. No removal if <=0." }

private

Definition at line 170 of file NewVrtSecInclusiveTool.h.

{this, "removeTrkMatSignif", 0., "Significance of Vertex-TrackingMaterial distance for removal. No removal if <=0." };

m_selVrtSigCut

Gaudi::Property<float> Rec::NewVrtSecInclusiveTool::m_selVrtSigCut {this, "SelVrtSigCut", 3.0, "Cut on significance of 3D distance between vertex and PV" }

private

Definition at line 177 of file NewVrtSecInclusiveTool.h.

{this,   "SelVrtSigCut",     3.0, "Cut on significance of 3D distance between vertex and PV"  };

m_trackToVertexTool

ToolHandle<Reco::ITrackToVertex> Rec::NewVrtSecInclusiveTool::m_trackToVertexTool {this, "TrackToVertexTool", "Reco::TrackToVertex/TrackToVertex", "Name of the TrackToVertex tool"}

private

Definition at line 186 of file NewVrtSecInclusiveTool.h.

{this, "TrackToVertexTool", "Reco::TrackToVertex/TrackToVertex", "Name of the TrackToVertex tool"};

m_trkSigCut

Gaudi::Property<float> Rec::NewVrtSecInclusiveTool::m_trkSigCut {this, "TrkSigCut", 2.0, "Track 3D impact significance w/r primary vertex. Should be >=AntiPileupSigRCut" }

private

Definition at line 163 of file NewVrtSecInclusiveTool.h.

{this,    "TrkSigCut",     2.0, "Track 3D impact significance w/r primary vertex. Should be >=AntiPileupSigRCut" };

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vertexMergeCut

Gaudi::Property<float> Rec::NewVrtSecInclusiveTool::m_vertexMergeCut {this, "VertexMergeCut", 4., "To allow vertex merging for MultiVertex Finder" }

private

Definition at line 178 of file NewVrtSecInclusiveTool.h.

{this,  "VertexMergeCut",   4., "To allow vertex merging for MultiVertex Finder" };

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_vrtMassLimit

Gaudi::Property<float> Rec::NewVrtSecInclusiveTool::m_vrtMassLimit {this, "VrtMassLimit", 5500., "Maximal allowed mass for found vertices" }

private

Definition at line 174 of file NewVrtSecInclusiveTool.h.

{this,    "VrtMassLimit",  5500., "Maximal allowed mass for found vertices" };

m_w_1

double Rec::NewVrtSecInclusiveTool::m_w_1 {}

private

Definition at line 106 of file NewVrtSecInclusiveTool.h.

{};

m_z0_wrtSV

SG::AuxElement::Decorator<float> Rec::NewVrtSecInclusiveTool::m_z0_wrtSV

private

Definition at line 208 of file NewVrtSecInclusiveTool.h.

---

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

• NewVrtSecInclusiveTool.h
• Reconstruction/VKalVrt/NewVrtSecInclusiveTool/src/CutTrk.cxx
• MultiUtilities.cxx
• NewVrtSecInclusiveTool.cxx
• Sel2TrkVertices.cxx
• Reconstruction/VKalVrt/NewVrtSecInclusiveTool/src/Utilities.cxx
• VrtSecMulti.cxx