This class uses primary vertex reconstruction to measure and monitor the LHC beam as seen by the ATLAS detector. More...

#include <T2VertexBeamSpotTool.h>

Inheritance diagram for PESA::T2VertexBeamSpotTool:

Collaboration diagram for PESA::T2VertexBeamSpotTool:

Public Types
using	TrackVector = std::vector< const Trk::Track * >

Public Member Functions
	T2VertexBeamSpotTool (const std::string &type, const std::string &name, const IInterface *parent)

virtual StatusCode	initialize () override final

void	updateBS (const TrackCollection &tracks, const EventContext &ctx) const
	Update beam spot data with new track information. More...

ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`. More...

virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm. More...

virtual StatusCode	sysStart () override
	Handle START transition. More...

virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...

virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...

Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...

void	updateVHKA (Gaudi::Details::PropertyBase &)

MsgStream &	msg () const

MsgStream &	msg (const MSG::Level lvl) const

bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...

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. More...

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
unsigned	numHighPTTrack (const TrackVector &tracks) const
	Return count of high pT track in the track list, the total number of these high pT tracks is checked in the selectTracks function and the threshold can be set via TrackSeedPt (by default 1 GeV) More...

unsigned int	reconstructVertices (TrackVector &tracks, TrigVertexCollection &myVertexCollection, DataVector< TrigVertexCollection > &mySplitVertexCollections, const EventContext &) const

bool	isGoodVertex (const T2Vertex &vertex) const

bool	isGoodVertexBCID (const T2Vertex &vertex) const

void	reconstructSplitVertices (TrackVector &tracks, DataVector< TrigVertexCollection > &mySplitVertexCollections, T2TrackClusterer &trackClusterer, const InDet::BeamSpotData *indetBeamSpot, const EventContext &) const

void	monitor_cluster (const T2TrackClusterer &clusterer) const

void	monitor_cluster_tracks (T2TrackClusterer &clusterer, const Trk::Track &track) const

void	monitor_vertex (const std::string &prefix, const std::string &suffix, const T2Vertex &vertex, int bcid=-1) const

void	monitor_split_vertex (const std::string &prefix, const std::string &suffix, const T2SplitVertex &vertex) const

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
double	m_trackClusDZ

bool	m_weightSeed

bool	m_splitWholeCluster

bool	m_reclusterSplit

double	m_trackSeedPt

std::string	m_clusterPerigee = "original"

T2TrackClusterer::TrackPerigee	m_clusterTrackPerigee = T2TrackClusterer::perigee_original

unsigned	m_totalNTrkMin

unsigned int	m_vtxNTrkMin

unsigned int	m_vtxNTrkMax

double	m_vtxQualMin

double	m_vtxQualMax

double	m_vtxChi2ProbMin

double	m_vtxMassMin

double	m_vtxSumPtMin

double	m_vtxXposMax

double	m_vtxXerrMax

double	m_vtxYposMax

double	m_vtxYerrMax

double	m_vtxZposMax

double	m_vtxZerrMax

unsigned int	m_vtxBCIDNTrkMin
	Additional vertex selection criteria for BCID measurements. More...

unsigned	m_nSplitVertices

bool	m_filterBS

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

SG::WriteHandleKey< TrigVertexCollection >	m_outputVertexCollectionKey {this, "OutputVertexCollection", "myVertices", "SG key for output vertex collection"}

ToolHandle< ITrigPrimaryVertexFitter >	m_primaryVertexFitterTool
	Primary Vertex Fitter Tool. More...

ToolHandle< T2BSTrackFilterTool >	m_trackFilterTool {this, "TrackFilter", "PESA::T2BSTrackFilterTool/T2BSTrackFilterTool" }

ToolHandle< GenericMonitoringTool >	m_monTool {this,"MonTool","","Monitoring tool"}

StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...

StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...

std::vector< SG::VarHandleKeyArray * >	m_vhka

bool	m_varHandleArraysDeclared

Detailed Description

This class uses primary vertex reconstruction to measure and monitor the LHC beam as seen by the ATLAS detector.

Fast, online vertexing is implemented using Dmitry Emeliyanov's (D.Eme.nosp@m.liya.nosp@m.nov@r.nosp@m.l.ac.nosp@m..uk) TrigPrimaryVertexFitter.

Author: Ignacio Aracena ignac.nosp@m.io.a.nosp@m.racen.nosp@m.a@ce.nosp@m.rn.ch; Rainer Bartoldus barto.nosp@m.ldu@.nosp@m.slac..nosp@m.stan.nosp@m.ford..nosp@m.edu; Su Dong sudon.nosp@m.g@sl.nosp@m.ac.st.nosp@m.anfo.nosp@m.rd.ed.nosp@m.u; David W. Miller David.nosp@m..W.M.nosp@m.iller.nosp@m.@cer.nosp@m.n.ch

Definition at line 69 of file T2VertexBeamSpotTool.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

◆ TrackVector

using PESA::T2VertexBeamSpotTool::TrackVector = std::vector<const Trk::Track*>

Definition at line 72 of file T2VertexBeamSpotTool.h.

Constructor & Destructor Documentation

◆ T2VertexBeamSpotTool()

PESA::T2VertexBeamSpotTool::T2VertexBeamSpotTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent
	)

Definition at line 67 of file T2VertexBeamSpotTool.cxx.

    : AthAlgTool( type, name, parent),
    m_primaryVertexFitterTool("TrigInDetToolInterfaces/ITrigPrimaryVertexFitter", this){
  
  
    //Declare properties in here
    declareProperty( "PrimaryVertexFitter",    m_primaryVertexFitterTool);
  
    //Declare variables:
    declareProperty("TotalNTrackMin",  m_totalNTrkMin = 2 ); 
  
    // Track clustering parameters 
    declareProperty("TrackSeedPt",       m_trackSeedPt       =  1.0*GeV ); 
    declareProperty("TrackClusterDZ",    m_trackClusDZ       = 10.0*mm  ); 
    declareProperty("WeightClusterZ",    m_weightSeed        = true     ); 
    declareProperty("ReclusterSplit",    m_reclusterSplit    = true     ); 
    declareProperty("SplitWholeCluster", m_splitWholeCluster = false    ); 
    declareProperty("ClusterPerigee",    m_clusterPerigee    = "beamspot" );
  
    // Vertex Selection criteria 
    declareProperty("VertexMinNTrk",     m_vtxNTrkMin     =   2      ); 
    declareProperty("VertexMaxNTrk",     m_vtxNTrkMax     = 100      ); 
    declareProperty("VertexMinQual",     m_vtxQualMin     =   0.0    ); 
    declareProperty("VertexMaxQual",     m_vtxQualMax     =   5.     ); 
    declareProperty("VertexMinChi2Prob", m_vtxChi2ProbMin = -10.0    ); 
    declareProperty("VertexMinMass",     m_vtxMassMin     =  -1.*GeV ); 
    declareProperty("VertexMinSumPt",    m_vtxSumPtMin    =   0.*GeV ); 
    declareProperty("VertexMaxX",        m_vtxXposMax     =  10.*mm  ); 
    declareProperty("VertexMaxXerr",     m_vtxXerrMax     =   1.*mm  ); 
    declareProperty("VertexMaxY",        m_vtxYposMax     =  10.*mm  ); 
    declareProperty("VertexMaxYerr",     m_vtxYerrMax     =   1.*mm  ); 
    declareProperty("VertexMaxZ",        m_vtxZposMax     = 200.*mm  ); 
    declareProperty("VertexMaxZerr",     m_vtxZerrMax     =   1.*mm  ); 
  
    // Vertex selection for use in BCID measurements 
    declareProperty("VertexBCIDMinNTrk", m_vtxBCIDNTrkMin =   2      ); 
  
    declareProperty("nSplitVertices",    m_nSplitVertices      = 1);
  
    declareProperty("filterBS",          m_filterBS         = true);
 }

Member Function Documentation

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	hndl,
		const SG::VarHandleKeyArrayType &
	)

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

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

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	hndl,
		const SG::VarHandleType &
	)

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	t,
		const SG::NotHandleType &
	)

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(t);
   }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleBase &	hndl,
		const std::string &	doc,
		const SG::VarHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

   {
     this->declare(hndl.vhKey());
     hndl.vhKey().setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKey &	hndl,
		const std::string &	doc,
		const SG::VarHandleKeyType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

   {
     this->declare(hndl);
     hndl.setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKeyArray &	hndArr,
		const std::string &	doc,
		const SG::VarHandleKeyArrayType &
	)

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

   {
  
     // std::ostringstream ost;
     // ost << Algorithm::name() << " VHKA declareProp: " << name 
     //     << " size: " << hndArr.keys().size() 
     //     << " mode: " << hndArr.mode() 
     //     << "  vhka size: " << m_vhka.size()
     //     << "\n";
     // debug() << ost.str() << endmsg;
  
     hndArr.setOwner(this);
     m_vhka.push_back(&hndArr);
  
     Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
     if (p != 0) {
       p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
     } else {
       ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                     << name);
     }
  
     return p;
  
   }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc,
		const SG::NotHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(name, property, doc);
   }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc = `"none"`
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

   {
     typedef typename SG::HandleClassifier<T>::type htype;
     return declareProperty (name, property, doc, htype());
   }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > & 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.

95 { return m_detStore; }

◆ evtStore() [1/2]

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.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( ) const

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

90 { 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

◆ initialize()

StatusCode T2VertexBeamSpotTool::initialize ( )

finaloverridevirtual

Definition at line 109 of file T2VertexBeamSpotTool.cxx.

                                            {
    ATH_MSG_INFO( "Initialising BeamSpot tool" );
  
    //Initialize data Handles
    ATH_CHECK( m_beamSpotKey.initialize() ) ;
    ATH_CHECK( m_outputVertexCollectionKey.initialize() );
  
    // Retrieve tools
    ATH_CHECK(m_trackFilterTool.retrieve());
    if (!m_monTool.empty()) ATH_CHECK(m_monTool.retrieve());
    ATH_CHECK( m_primaryVertexFitterTool.retrieve() );
  
    m_clusterTrackPerigee = T2TrackClusterer::trackPerigeeFromString(m_clusterPerigee);
  
    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.

◆ isGoodVertex()

bool T2VertexBeamSpotTool::isGoodVertex ( const T2Vertex & vertex ) const

private

Definition at line 473 of file T2VertexBeamSpotTool.cxx.

                                                                       {
   // Vertex quality cuts
   return
     (
      vertex.NTrks()       >= m_vtxNTrkMin     &&  // FIXME: harmonize spelling
      abs( vertex.X() )    <= m_vtxXposMax     &&
      abs( vertex.Y() )    <= m_vtxYposMax     &&
      abs( vertex.Z() )    <= m_vtxZposMax     &&
      abs( vertex.Xerr() ) <= m_vtxXerrMax     &&  // FIXME: do we have negative errors?
      abs( vertex.Yerr() ) <= m_vtxYerrMax     &&
      abs( vertex.Zerr() ) <= m_vtxZerrMax     &&
      vertex.Mass()        >= m_vtxMassMin     &&
      vertex.SumPt()       >= m_vtxSumPtMin    &&
      vertex.Qual()        >= m_vtxQualMin     &&
      vertex.Qual()        <= m_vtxQualMax     &&
      vertex.Chi2Prob()    >= m_vtxChi2ProbMin &&
      true
      );
 }

◆ isGoodVertexBCID()

bool T2VertexBeamSpotTool::isGoodVertexBCID ( const T2Vertex & vertex ) const

private

Definition at line 494 of file T2VertexBeamSpotTool.cxx.

                                                                           {
   // Track quality cuts
   return
     (
      vertex.NTrks()       >= m_vtxBCIDNTrkMin &&  // FIXME: harmonize spelling
      true
      );
 }

◆ monitor_cluster()

void T2VertexBeamSpotTool::monitor_cluster ( const T2TrackClusterer & clusterer ) const

private

Definition at line 504 of file T2VertexBeamSpotTool.cxx.

                                                                                      {
    auto  clusterZ                = Monitored::Scalar<double>("ClusterZ", clusterer.seedZ0()            );
    auto  clusterNtracks          = Monitored::Scalar<int>("ClusterNTracks", clusterer.clusterTracks().size()       );
    auto  clusterNUnusedTracks    = Monitored::Scalar<int>("ClusterNTracksUnused", clusterer.unusedTracks().size()  );
  
    auto mon = Monitored::Group(m_monTool, clusterZ, clusterNtracks, clusterNUnusedTracks ); 
 }

◆ monitor_cluster_tracks()

void T2VertexBeamSpotTool::monitor_cluster_tracks	(	T2TrackClusterer &	clusterer,
		const Trk::Track &	track
	)		const

private

Definition at line 513 of file T2VertexBeamSpotTool.cxx.

                                                                                                             {
    const double deltaZ0 = track.perigeeParameters()->parameters()[Trk::z0] - clusterer.seedZ0();
    const AmgSymMatrix(5)& perigeeCov = *track.perigeeParameters()->covariance();
    const double z0Error = std::sqrt(perigeeCov(Trk::z0,Trk::z0));
    const double z0Pull  = ( z0Error > 0. ) ? deltaZ0 / z0Error : 0.;
  
    auto  mon_deltaZ0          = Monitored::Scalar<double>("ClusterDeltaZ0",  deltaZ0    );
    auto  mon_z0Pull           = Monitored::Scalar<double>("ClusterZ0Pull",   z0Pull    );
    auto  mon = Monitored::Group(m_monTool, mon_deltaZ0, mon_z0Pull ); 
 }

◆ monitor_split_vertex()

void T2VertexBeamSpotTool::monitor_split_vertex	(	const std::string &	prefix,
		const std::string &	suffix,
		const T2SplitVertex &	vertex
	)		const

private

Definition at line 556 of file T2VertexBeamSpotTool.cxx.

                                                                                                                                    {
  
    auto ntrk1 = Monitored::Scalar<unsigned>( prefix + "1NTrks"   + suffix, vertex.vertex1().NTrks());
    auto x1 = Monitored::Scalar<double>( prefix + "1X"       + suffix, vertex.vertex1().X());
    auto y1 = Monitored::Scalar<double>( prefix + "1Y"       + suffix, vertex.vertex1().Y());
    auto z1 = Monitored::Scalar<double>( prefix + "1Z"       + suffix, vertex.vertex1().Z());
    auto x1err = Monitored::Scalar<double>( prefix + "1Xerr"    + suffix, vertex.vertex1().Xerr());
    auto y1err = Monitored::Scalar<double>( prefix + "1Yerr"    + suffix, vertex.vertex1().Yerr());
    auto z1err = Monitored::Scalar<double>( prefix + "1Zerr"    + suffix, vertex.vertex1().Zerr());
    auto ntrk2 = Monitored::Scalar<unsigned>( prefix + "2NTrks"   + suffix, vertex.vertex2().NTrks());
    auto x2 = Monitored::Scalar<double>( prefix + "2X"       + suffix, vertex.vertex2().X());
    auto y2 = Monitored::Scalar<double>( prefix + "2Y"       + suffix, vertex.vertex2().Y());
    auto z2 = Monitored::Scalar<double>( prefix + "2Z"       + suffix, vertex.vertex2().Z());
    auto x2err = Monitored::Scalar<double>( prefix + "2Xerr"    + suffix, vertex.vertex2().Xerr());
    auto y2err = Monitored::Scalar<double>( prefix + "2Yerr"    + suffix, vertex.vertex2().Yerr());
    auto z2err = Monitored::Scalar<double>( prefix + "2Zerr"    + suffix, vertex.vertex2().Zerr());
    auto dntrk = Monitored::Scalar<double>( prefix + "DNTrks"   + suffix, vertex.DNTrks());
    auto dx = Monitored::Scalar<double>( prefix + "DX"       + suffix, vertex.DX());
    auto dy = Monitored::Scalar<double>( prefix + "DY"       + suffix, vertex.DY());
    auto dz = Monitored::Scalar<double>( prefix + "DZ"       + suffix, vertex.DZ());
    auto dxerr = Monitored::Scalar<double>( prefix + "DXerr"    + suffix, vertex.DXerr());
    auto dyerr = Monitored::Scalar<double>( prefix + "DYerr"    + suffix, vertex.DYerr());
    auto dzerr = Monitored::Scalar<double>( prefix + "DZerr"    + suffix, vertex.DZerr());
    auto dxpull = Monitored::Scalar<double>( prefix + "DXpull"   + suffix, vertex.DXpull());
    auto dypull = Monitored::Scalar<double>( prefix + "DYpull"   + suffix, vertex.DYpull());
    auto dzpull = Monitored::Scalar<double>( prefix + "DZpull"   + suffix, vertex.DZpull());
  
    auto mon = Monitored::Group(m_monTool, ntrk1, x1, y1, z1, x1err, y1err, z1err, ntrk2, x2, y2, z2, x2err, y2err, z2err,
                                dntrk, dx, dy, dz, dxerr, dyerr, dzerr, dxpull, dypull, dzpull);
 }

◆ monitor_vertex()

void T2VertexBeamSpotTool::monitor_vertex	(	const std::string &	prefix,
		const std::string &	suffix,
		const T2Vertex &	vertex,
		int	bcid = `-1`
	)		const

private

Definition at line 526 of file T2VertexBeamSpotTool.cxx.

                                                                                                                                    {
  
    auto ntrk      = Monitored::Scalar<int>   ( prefix + "NTrks"      + suffix, vertex.NTrks()      ); 
    auto sumpt     = Monitored::Scalar<double>( prefix + "SumPt"      + suffix, vertex.SumPt()      ); 
    auto sumpt2    = Monitored::Scalar<double>( prefix + "SumPt2"     + suffix, vertex.SumPt2()     ); 
    auto mass      = Monitored::Scalar<double>( prefix + "Mass"       + suffix, vertex.Mass()       );      
    auto qual      = Monitored::Scalar<double>( prefix + "Qual"       + suffix, vertex.Qual()       ); 
    auto chi2      = Monitored::Scalar<double>( prefix + "Chi2Prob"   + suffix, vertex.Chi2Prob()   ); 
    auto x         = Monitored::Scalar<double>( prefix + "X"          + suffix, vertex.X()          ); 
    auto y         = Monitored::Scalar<double>( prefix + "Y"          + suffix, vertex.Y()          ); 
    auto z         = Monitored::Scalar<double>( prefix + "Z"          + suffix, vertex.Z()          ); 
    auto xzoom     = Monitored::Scalar<double>( prefix + "XZoom"      + suffix, vertex.XZoom()      ); 
    auto yzoom     = Monitored::Scalar<double>( prefix + "YZoom"      + suffix, vertex.YZoom()      ); 
    auto zzoom     = Monitored::Scalar<double>( prefix + "ZZoom"      + suffix, vertex.ZZoom()      ); 
    auto xerr      = Monitored::Scalar<double>( prefix + "Xerr"       + suffix, vertex.Xerr()       ); 
    auto yerr      = Monitored::Scalar<double>( prefix + "Yerr"       + suffix, vertex.Yerr()       ); 
    auto zerr      = Monitored::Scalar<double>( prefix + "Zerr"       + suffix, vertex.Zerr()       ); 
    auto xy        = Monitored::Scalar<double>( prefix + "XY"         + suffix, vertex.XY()         ); 
    auto pull      = Monitored::Scalar<double>( prefix + "Pull"       + suffix, vertex.Pull()       ); 
    auto ntrkInVtx = Monitored::Scalar<double>( prefix + "NTrksInVtx" + suffix, vertex.NTrksInVtx() );
  
    if (bcid >= 0) {
       auto BCID = Monitored::Scalar<unsigned>("BCID", unsigned(bcid));
       auto mon = Monitored::Group(m_monTool, ntrk, sumpt, sumpt2, mass, qual, chi2, x, y, z, xzoom, yzoom, zzoom, xerr, yerr, zerr, xy, pull, ntrkInVtx, BCID );
    } else {
       auto mon = Monitored::Group(m_monTool, ntrk, sumpt, sumpt2, mass, qual, chi2, x, y, z, xzoom, yzoom, zzoom, xerr, yerr, zerr, xy, pull, ntrkInVtx );
    }
 }

◆ msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                                {
     return this->msgLevel(lvl);
   }

◆ numHighPTTrack()

unsigned T2VertexBeamSpotTool::numHighPTTrack ( const TrackVector & tracks ) const

private

Return count of high pT track in the track list, the total number of these high pT tracks is checked in the selectTracks function and the threshold can be set via TrackSeedPt (by default 1 GeV)

Definition at line 176 of file T2VertexBeamSpotTool.cxx.

 {
    unsigned count = 0;
    for (auto&& track: tracks) {
       const Trk::TrackParameters* trackPars = track->perigeeParameters();
       if (trackPars) {
          float qOverP = trackPars->parameters()[Trk::qOverP];
          float theta = trackPars->parameters()[Trk::theta];
          double pt = std::abs(std::sin(theta)/qOverP)/Gaudi::Units::GeV;
          if (pt > m_trackSeedPt) {
             ++count;
          }
       }
    }
    return count;
 }

◆ 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.

◆ reconstructSplitVertices()

void T2VertexBeamSpotTool::reconstructSplitVertices	(	TrackVector &	tracks,
		DataVector< TrigVertexCollection > &	mySplitVertexCollections,
		T2TrackClusterer &	trackClusterer,
		const InDet::BeamSpotData *	indetBeamSpot,
		const EventContext &	ctx
	)		const

private

Definition at line 379 of file T2VertexBeamSpotTool.cxx.

 {
   auto timerVertexRec = Monitored::Timer("TIME_SplitVertexReconstruction");
  
   // Sort the tracks in phi for splitting in the most independent, uniform variable
   {
     auto timeToSortTracks = Monitored::Timer("TIME_toSortSplitTracks");
     std::sort(myFullTrackCollection.begin(), myFullTrackCollection.end(), Beamspot::TrackPhiSort());
     auto mon = Monitored::Group(m_monTool,  timeToSortTracks );
   }
  
   // This returns m_nSplitVertices (ideally) or fewer (if clustering fails) track collections
   T2TrackManager trackManager(m_nSplitVertices);
   vector<TrackVector> splitTrackCollections = trackManager.split(myFullTrackCollection, ctx);
  
   // Add a new track collection for the split vertices corresponding to this primary vertex
   // There can be anywhere between zero and m_nSplitVertices entries in the collection
   TrigVertexCollection* splitVertices =  new TrigVertexCollection();
   mySplitVertexCollections.push_back(splitVertices); // passes ownership
  
   // Loop over the split track collections to perform clustering and vertex fitting
   for (auto&& tracks: splitTrackCollections) {
      TrigVertex* splitVertex = nullptr;
      ATH_MSG_DEBUG( "split vertex # of tracks " << tracks.size());
  
      if ( m_reclusterSplit ) {
         // Sort the tracks in pT for clustering around the highest-pT seed
         {
            std::sort(tracks.begin(), tracks.end(), Beamspot::TrackPTSort());
         }
  
         // Cluster in z
         {
            auto timeToZClusterSplit = Monitored::Timer("TIME_toZClusterSplit");
            trackClusterer.cluster(tracks, indetBeamSpot);
            auto mon = Monitored::Group(m_monTool,  timeToZClusterSplit ); 
         }
  
         // Check for a good cluster
         if ( trackClusterer.clusterTracks().size() < m_totalNTrkMin ) continue;
  
         // Fit a vertex to this split track cluster
         {
            auto timeToVertexFitSplit = Monitored::Timer("TIME_toVertexFitSplit");
            TrackCollection vertexTracks;
            ConstDataVector<TrackCollection> cluster(trackClusterer.clusterTracks().begin(), trackClusterer.clusterTracks().end());
            splitVertex = m_primaryVertexFitterTool->fit(cluster.asDataVector(), vertexTracks, trackClusterer.seedZ0());
            auto mon = Monitored::Group(m_monTool,  timeToVertexFitSplit ); 
         }
  
      }
      else
      {
         // Alternatively: Fit a vertex to the unclustered split track
         // collection, using the seed Z0 from the primary vertex
         {
            auto timeToVertexFitSplit = Monitored::Timer("TIME_toVertexFitSplit");
            TrackCollection vertexTracks;
            ConstDataVector<TrackCollection> cluster(tracks.begin(), tracks.end());
            splitVertex = m_primaryVertexFitterTool->fit(cluster.asDataVector(), vertexTracks, trackClusterer.seedZ0() );
            auto mon = Monitored::Group(m_monTool,  timeToVertexFitSplit ); 
         }
      }
  
      if ( splitVertex ) {
         ATH_MSG_DEBUG( "Reconstructed a split vertex");
         // Add split vertex to collection
         splitVertices->push_back( splitVertex );  // passes ownership to split vertex collection
      } else {
         ATH_MSG_DEBUG( "Could not reconstruct a split vertex");
      }
   }
  
   // Monitor split vertex distributions (if we found all of them)
   if ( m_nSplitVertices > 1 && splitVertices->size() == m_nSplitVertices ) {
      ATH_MSG_DEBUG( "Split vertexing is ON." << "Attempting to split N = " << m_nSplitVertices << " vertices. ");
  
      // Store information on the first two vertices
      // There shouldn't be more, unless it's for systematic studies anyway
      const T2SplitVertex splitVertex( *(*splitVertices)[0], *(*splitVertices)[1] );
  
      monitor_split_vertex("SplitVertex", "Pass", splitVertex);
   }
  
       //Monitor timing
       auto mon = Monitored::Group(m_monTool, timerVertexRec ); 
 }

◆ reconstructVertices()

unsigned int T2VertexBeamSpotTool::reconstructVertices	(	TrackVector &	tracks,
		TrigVertexCollection &	myVertexCollection,
		DataVector< TrigVertexCollection > &	mySplitVertexCollections,
		const EventContext &	ctx
	)		const

private

Definition at line 193 of file T2VertexBeamSpotTool.cxx.

 {
     ATH_MSG_DEBUG( "Reconstructing vertices" );
  
    unsigned bcid = ctx.eventID().bunch_crossing_id();
  
    //Monitoring counters and timers
    auto timerVertexRec = Monitored::Timer("TIME_VertexReconstruction");
    auto nClusters      = Monitored::Scalar<unsigned>("NClusters", 0);
    auto nVtx           = Monitored::Scalar<unsigned>("Nvtx", 0);
    auto nPassVtx       = Monitored::Scalar<unsigned>("NvtxPass", 0);
    auto nPassBCIDVtx   = Monitored::Scalar<unsigned>("NvtxPassBCID", 0);
    auto BCID           = Monitored::Scalar<unsigned>("BCID", bcid);
  
    // Sort tracks by track pT
    {
       auto timeToSortTracks = Monitored::Timer("TIME_toSortTracks");
       std::sort(tracks.begin(), tracks.end(), Beamspot::TrackPTSort());
       auto mon = Monitored::Group(m_monTool,  timeToSortTracks );
    }
  
    // Extract beam spot parameters
    SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey, ctx };
    const InDet::BeamSpotData* indetBeamSpot(*beamSpotHandle);
    const T2BeamSpot beamSpot(indetBeamSpot);
    ATH_MSG_DEBUG( "Beamspot from BeamCondSvc: " << beamSpot);
  
    // Prepare a track clustering algorithm with the given parameters
    // Should we leave this as a standalone class or merge with the tool?
    T2TrackClusterer trackClusterer( m_trackClusDZ, m_trackSeedPt, m_weightSeed, m_vtxNTrkMax,
                                     m_clusterTrackPerigee );
  
    std::vector<double> clusterZ0; // Z0 for each cluster, for monitoring only
  
    // Create clusters from the track collection until all its tracks are used
    while ( ! tracks.empty() ) {
  
       const Trk::TrackParameters* params = (*tracks.begin())->perigeeParameters();
       float pT = std::abs(sin(params->parameters()[Trk::theta])/params->parameters()[Trk::qOverP]);
       ATH_MSG_DEBUG( "Number of tracks remaining = " << tracks.size() );
       ATH_MSG_DEBUG( "pT of first (seed) track (GeV) = " << pT/GeV );
  
  
       // Cluster tracks in z around the first (highest-pT track) in the collection, which is taken
       // as the seed.
       {
          auto timeToZCluster = Monitored::Timer("TIME_toZCluster");
          trackClusterer.cluster(tracks, indetBeamSpot);
          auto mon = Monitored::Group(m_monTool,  timeToZCluster);
       }
  
       // Sanity check:
       if ( trackClusterer.clusterTracks().size() + trackClusterer.unusedTracks().size()
             != tracks.size() ) {
          ATH_MSG_DEBUG( "Track clustering check sum failed: "
                << "cluster().size()=" << trackClusterer.clusterTracks().size()
                << " + unusedTracks().size()=" << trackClusterer.unusedTracks().size()
                << " != tracks.size()=" << tracks.size()
                );
       }
  
       // Continue with the remaining tracks - still pT-sorted
       tracks = trackClusterer.unusedTracks();
  
       // This always uses at least one track (the seed), so we are sure to reduce the track
       // selection and terminate the loop
  
       // Make sure we have enough tracks in the cluster
       if ( trackClusterer.clusterTracks().size() < m_totalNTrkMin ) {
          ATH_MSG_DEBUG( "Not enough tracks in cluster!" );
          continue;
       }
  
       // Event has a good cluster
       nClusters++;
  
       // Monitor properties of of the cluster
       monitor_cluster( trackClusterer );
  
       // Monitor properties of tracks inside the cluster
       for (auto&& track: trackClusterer.clusterTracks()) {
          monitor_cluster_tracks( trackClusterer,  *track);
       }
  
       ATH_MSG_DEBUG( "Number of tracks remaining after cluster #(" << nClusters << ") = " << tracks.size());
       ATH_MSG_DEBUG( "Total number of tracks to fit    = " << trackClusterer.clusterTracks().size() );
       ATH_MSG_DEBUG( "Average Z position (from trk Z0) = " << trackClusterer.seedZ0()         );
       ATH_MSG_DEBUG( "Fitting tracks");
  
       // Fit a primary vertex to this cluster around its seed track
       TrackCollection vertexTracks;
       ConstDataVector<TrackCollection> cluster(trackClusterer.clusterTracks().begin(), trackClusterer.clusterTracks().end());
       TrigVertex* primaryVertex = m_primaryVertexFitterTool->fit(cluster.asDataVector(), vertexTracks, trackClusterer.seedZ0());
  
       // Check to see if the fit succeeded / converged
       if ( ! primaryVertex ) { 
          ATH_MSG_DEBUG( "Vertex fit failed");
          continue; 
       }
  
       // Update vertex counter
       nVtx++;
  
       const T2Vertex myVertex(*primaryVertex, vertexTracks, beamSpot, trackClusterer.seedZ0());
  
       // Monitor all vertices parameters
       monitor_vertex( "Vertex", "", myVertex ); 
       ATH_MSG_DEBUG( "Vertex fit: " << '\n' << myVertex);
  
       // Query for vertex selection
       const bool passVertex = isGoodVertex( myVertex );
  
       if ( ! passVertex ) { 
          ATH_MSG_DEBUG( "Vertex failed selection" );
          continue; 
       }
  
       // Add primary vertex to collection
       myVertexCollection.push_back(primaryVertex); // passes ownership to vertex collection
  
       //Monitor parameters of the  passed vertex 
       monitor_vertex( "Vertex", "Pass", myVertex ); 
  
       //Update good vertex counter
       nPassVtx++;    
  
       // Learn something more about the cluster that ended up in this vertex
       auto deltaVtxZ = Monitored::Scalar<double>("ClusterDeltaVertexZ",  trackClusterer.seedZ0() - myVertex.Z());
       auto mon = Monitored::Group(m_monTool, deltaVtxZ);
  
       // monitor cluster-cluster delta Z0
       for (double prevClusterZ0: clusterZ0) {
          auto clusterClusterDeltaZ = Monitored::Scalar<double>("ClusterClusterDeltaZ0",  trackClusterer.seedZ0() - prevClusterZ0);
          auto mon = Monitored::Group(m_monTool,  clusterClusterDeltaZ);
       }
       clusterZ0.push_back(trackClusterer.seedZ0());
  
       // If the vertex is good, splits are requested, and we have enough tracks to split, split them!
       if ( passVertex && m_nSplitVertices > 1 ) {
  
          TrackVector mySplitTrackCollection;
  
          if ( m_splitWholeCluster ) {
             ATH_MSG_DEBUG( "Splitting the entire cluster of tracks into two");
             // Alternative 1: Split the entire cluster of track into two
             mySplitTrackCollection = trackClusterer.clusterTracks();
          } else {
             ATH_MSG_DEBUG( "Splitting only tracks succesfully fitted to a vertex");
             // Alternative 2: Split only the tracks that were successfully fit to a vertex
             mySplitTrackCollection.assign(vertexTracks.begin(), vertexTracks.end());
          }
  
          if (mySplitTrackCollection.size() >= m_nSplitVertices * m_totalNTrkMin) {
             // Split, optinally re-cluster, and fit separate vertices
             ATH_MSG_DEBUG( "Reconstruct split vertices");
             reconstructSplitVertices( mySplitTrackCollection, mySplitVertexCollections, trackClusterer, indetBeamSpot, ctx );
          }
          // Alternative 3: Split all the tracks and iterate with the remaining tracks
          //          mySplitTrackCollection = tracks;
       }
  
       ATH_MSG_DEBUG( "Number of tracks remaining = " << tracks.size() );
  
       // Now check if this vertex passed the higher multiplicity cut to be used for per-BCID measurements
       const bool passVertexBCID = isGoodVertexBCID( myVertex );
  
       if ( passVertexBCID ) {
          // Fill accepted per-BCID vertex histograms 
          monitor_vertex( "Vertex", "PassBCID", myVertex, bcid );
  
          // Update good per-BCID vertex counter
          nPassBCIDVtx++;
       }
  
     }//End looping over tracks
  
   //monitor number of (passed) vertices, clusters, etc
   auto mon = Monitored::Group(m_monTool, nVtx, nPassVtx, nPassBCIDVtx, nClusters, timerVertexRec, BCID);
   return static_cast<unsigned int>(nPassVtx);
 }

◆ 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();
   }

◆ 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 DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ 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.

◆ updateBS()

void T2VertexBeamSpotTool::updateBS	(	const TrackCollection &	tracks,
		const EventContext &	ctx
	)		const

Update beam spot data with new track information.

Parameter provides a lists of tracks.

Definition at line 127 of file T2VertexBeamSpotTool.cxx.

 {
    // Monitor how long does it take to loop over all collections
    auto tSelectingTracks = Monitored::Timer("TIME_SelectingTracks");
  
    // Select tracks
    auto selectedTracks = m_trackFilterTool->filter(tracks);
    if (m_filterBS) {
       auto& eventID = ctx.eventID();
       bool has_bs = m_trackFilterTool->updateBS(selectedTracks, eventID.lumi_block(),
                                                 eventID.bunch_crossing_id());
       if (has_bs) {
          selectedTracks = m_trackFilterTool->filterBS(selectedTracks);
       }
    }
  
    //Monitor total all/passed/highPt track numbers
    tSelectingTracks.stop();
    auto nTotalTracks = Monitored::Scalar<unsigned>("nTotalTracks", tracks.size());
    auto nTotalPassedTracks = Monitored::Scalar<unsigned>("nTotalPassedTracks", selectedTracks.size());
    auto nTotalHighPTTracks = Monitored::Scalar<unsigned>("nTotalHighPTTracks", numHighPTTrack(selectedTracks));
  
    //Monitor total number of tracks
    auto monitor = Monitored::Group(m_monTool, tSelectingTracks, nTotalTracks,
                                    nTotalPassedTracks, nTotalHighPTTracks);
    ATH_MSG_DEBUG("Number of all Tracks: " << nTotalTracks << " Selected Tracks: " << nTotalPassedTracks <<
                  " highPt Tracks: " << nTotalHighPTTracks );
  
    // Check for seed tracks (= high-pT tracks)
    if (nTotalHighPTTracks == 0) {
       ATH_MSG_DEBUG("No seed tracks for vertexing");
       return;
    }
  
    // Check for the total number of available tracks
    if (nTotalPassedTracks < m_totalNTrkMin) {
       ATH_MSG_DEBUG( "Not enough total passed tracks to vertex");
       return;
    }
  
    SG::WriteHandle<TrigVertexCollection> myVertexCollection(m_outputVertexCollectionKey, ctx);
    myVertexCollection = std::make_unique<TrigVertexCollection>();
    DataVector<TrigVertexCollection> mySplitVertexCollections;
  
    ATH_MSG_DEBUG( "Reconstruct vertices" );
    reconstructVertices(selectedTracks, *myVertexCollection, mySplitVertexCollections, ctx);
 }

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

Member Data Documentation

◆ m_beamSpotKey

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

private

Definition at line 152 of file T2VertexBeamSpotTool.h.

◆ m_clusterPerigee

std::string PESA::T2VertexBeamSpotTool::m_clusterPerigee = "original"

private

Definition at line 123 of file T2VertexBeamSpotTool.h.

◆ m_clusterTrackPerigee

T2TrackClusterer::TrackPerigee PESA::T2VertexBeamSpotTool::m_clusterTrackPerigee = T2TrackClusterer::perigee_original

private

Definition at line 124 of file T2VertexBeamSpotTool.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_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_filterBS

bool PESA::T2VertexBeamSpotTool::m_filterBS

private

Definition at line 149 of file T2VertexBeamSpotTool.h.

◆ m_monTool

ToolHandle<GenericMonitoringTool> PESA::T2VertexBeamSpotTool::m_monTool {this,"MonTool","","Monitoring tool"}

private

Definition at line 162 of file T2VertexBeamSpotTool.h.

◆ m_nSplitVertices

unsigned PESA::T2VertexBeamSpotTool::m_nSplitVertices

private

Definition at line 147 of file T2VertexBeamSpotTool.h.

◆ m_outputVertexCollectionKey

SG::WriteHandleKey<TrigVertexCollection> PESA::T2VertexBeamSpotTool::m_outputVertexCollectionKey {this, "OutputVertexCollection", "myVertices", "SG key for output vertex collection"}

private

Definition at line 155 of file T2VertexBeamSpotTool.h.

◆ m_primaryVertexFitterTool

ToolHandle<ITrigPrimaryVertexFitter> PESA::T2VertexBeamSpotTool::m_primaryVertexFitterTool

private

Primary Vertex Fitter Tool.

Definition at line 159 of file T2VertexBeamSpotTool.h.

◆ m_reclusterSplit

bool PESA::T2VertexBeamSpotTool::m_reclusterSplit

private

Definition at line 121 of file T2VertexBeamSpotTool.h.

◆ m_splitWholeCluster

bool PESA::T2VertexBeamSpotTool::m_splitWholeCluster

private

Definition at line 120 of file T2VertexBeamSpotTool.h.

◆ m_totalNTrkMin

unsigned PESA::T2VertexBeamSpotTool::m_totalNTrkMin

private

Definition at line 127 of file T2VertexBeamSpotTool.h.

◆ m_trackClusDZ

double PESA::T2VertexBeamSpotTool::m_trackClusDZ

private

Definition at line 118 of file T2VertexBeamSpotTool.h.

◆ m_trackFilterTool

ToolHandle<T2BSTrackFilterTool> PESA::T2VertexBeamSpotTool::m_trackFilterTool {this, "TrackFilter", "PESA::T2BSTrackFilterTool/T2BSTrackFilterTool" }

private

Definition at line 161 of file T2VertexBeamSpotTool.h.

◆ m_trackSeedPt

double PESA::T2VertexBeamSpotTool::m_trackSeedPt

private

Definition at line 122 of file T2VertexBeamSpotTool.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ m_vtxBCIDNTrkMin

unsigned int PESA::T2VertexBeamSpotTool::m_vtxBCIDNTrkMin

private

Additional vertex selection criteria for BCID measurements.

Definition at line 145 of file T2VertexBeamSpotTool.h.

◆ m_vtxChi2ProbMin

double PESA::T2VertexBeamSpotTool::m_vtxChi2ProbMin

private

Definition at line 134 of file T2VertexBeamSpotTool.h.

◆ m_vtxMassMin

double PESA::T2VertexBeamSpotTool::m_vtxMassMin

private

Definition at line 135 of file T2VertexBeamSpotTool.h.

◆ m_vtxNTrkMax

unsigned int PESA::T2VertexBeamSpotTool::m_vtxNTrkMax

private

Definition at line 131 of file T2VertexBeamSpotTool.h.

◆ m_vtxNTrkMin

unsigned int PESA::T2VertexBeamSpotTool::m_vtxNTrkMin

private

Definition at line 130 of file T2VertexBeamSpotTool.h.

◆ m_vtxQualMax

double PESA::T2VertexBeamSpotTool::m_vtxQualMax

private

Definition at line 133 of file T2VertexBeamSpotTool.h.

◆ m_vtxQualMin

double PESA::T2VertexBeamSpotTool::m_vtxQualMin

private

Definition at line 132 of file T2VertexBeamSpotTool.h.

◆ m_vtxSumPtMin

double PESA::T2VertexBeamSpotTool::m_vtxSumPtMin

private

Definition at line 136 of file T2VertexBeamSpotTool.h.

◆ m_vtxXerrMax

double PESA::T2VertexBeamSpotTool::m_vtxXerrMax

private

Definition at line 138 of file T2VertexBeamSpotTool.h.

◆ m_vtxXposMax

double PESA::T2VertexBeamSpotTool::m_vtxXposMax

private

Definition at line 137 of file T2VertexBeamSpotTool.h.

◆ m_vtxYerrMax

double PESA::T2VertexBeamSpotTool::m_vtxYerrMax

private

Definition at line 140 of file T2VertexBeamSpotTool.h.

◆ m_vtxYposMax

double PESA::T2VertexBeamSpotTool::m_vtxYposMax

private

Definition at line 139 of file T2VertexBeamSpotTool.h.

◆ m_vtxZerrMax

double PESA::T2VertexBeamSpotTool::m_vtxZerrMax

private

Definition at line 142 of file T2VertexBeamSpotTool.h.

◆ m_vtxZposMax

double PESA::T2VertexBeamSpotTool::m_vtxZposMax

private

Definition at line 141 of file T2VertexBeamSpotTool.h.

◆ m_weightSeed

bool PESA::T2VertexBeamSpotTool::m_weightSeed

private

Definition at line 119 of file T2VertexBeamSpotTool.h.

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

Public Types

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

◆ TrackVector

Constructor & Destructor Documentation

◆ T2VertexBeamSpotTool()

Member Function Documentation

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ extraDeps_update_handler()

◆ initialize()

◆ inputHandles()

◆ isGoodVertex()

◆ isGoodVertexBCID()

◆ monitor_cluster()

◆ monitor_cluster_tracks()

◆ monitor_split_vertex()

◆ monitor_vertex()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ numHighPTTrack()

◆ outputHandles()

◆ reconstructSplitVertices()

◆ reconstructVertices()

◆ renounce()

◆ renounceArray()

◆ sysInitialize()

◆ sysStart()

◆ updateBS()

◆ updateVHKA()

Member Data Documentation

◆ m_beamSpotKey

◆ m_clusterPerigee

◆ m_clusterTrackPerigee

◆ m_detStore

◆ m_evtStore

◆ m_filterBS

◆ m_monTool

◆ m_nSplitVertices

◆ m_outputVertexCollectionKey

◆ m_primaryVertexFitterTool

◆ m_reclusterSplit

◆ m_splitWholeCluster

◆ m_totalNTrkMin

◆ m_trackClusDZ

◆ m_trackFilterTool

◆ m_trackSeedPt

◆ m_varHandleArraysDeclared

◆ m_vhka

◆ m_vtxBCIDNTrkMin

◆ m_vtxChi2ProbMin

◆ m_vtxMassMin

◆ m_vtxNTrkMax

◆ m_vtxNTrkMin

◆ m_vtxQualMax

◆ m_vtxQualMin

◆ m_vtxSumPtMin

◆ m_vtxXerrMax

◆ m_vtxXposMax

◆ m_vtxYerrMax

◆ m_vtxYposMax

◆ m_vtxZerrMax