Prompt::PrimaryVertexReFitter Class Reference

#include <PrimaryVertexReFitter.h>

Inheritance diagram for Prompt::PrimaryVertexReFitter:

Collaboration diagram for Prompt::PrimaryVertexReFitter:

Public Member Functions
	PrimaryVertexReFitter (const std::string &name, ISvcLocator *pSvcLocator)
virtual StatusCode	initialize () override
virtual StatusCode	execute () override
virtual StatusCode	finalize () override
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

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

Private Types
using	accessorFloat_t = SG::Accessor<float>
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
bool	decorateLepWithReFitPrimaryVertex (const FittingInput &input, const xAOD::TrackParticle *tracklep, const std::vector< const xAOD::TrackParticle * > &tracks, xAOD::VertexContainer &refitVtxContainer)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
ToolHandle< Prompt::VertexFittingTool >	m_vertexFitterTool
Gaudi::Property< bool >	m_printTime {this, "PrintTime", false}
Gaudi::Property< std::string >	m_distToRefittedPriVtxName
Gaudi::Property< std::string >	m_normDistToRefittedPriVtxName
TStopwatch	m_timerAll
TStopwatch	m_timerExec
SG::ReadHandleKey< xAOD::TrackParticleContainer >	m_inDetTracksKey
SG::ReadHandleKey< xAOD::IParticleContainer >	m_leptonContainerKey
SG::ReadHandleKey< xAOD::VertexContainer >	m_primaryVertexContainerKey
SG::WriteHandleKey< xAOD::VertexContainer >	m_reFitPrimaryVertexKey
std::optional< accessorFloat_t >	m_distToRefittedPriVtx
std::optional< accessorFloat_t >	m_normdistToRefittedPriVtx
SG::WriteDecorHandleKey< xAOD::IParticleContainer >	m_lepRefittedVtxWithoutLeptonLinkName { this, "RefittedVtxWithoutLeptonLinkName", m_leptonContainerKey, "default", "" }
DataObjIDColl	m_extendedExtraObjects
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 44 of file PrimaryVertexReFitter.h.

Member Typedef Documentation

accessorFloat_t

using Prompt::PrimaryVertexReFitter::accessorFloat_t = SG::Accessor<float>

private

Definition at line 56 of file PrimaryVertexReFitter.h.

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

PrimaryVertexReFitter()

Prompt::PrimaryVertexReFitter::PrimaryVertexReFitter	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Definition at line 20 of file PrimaryVertexReFitter.cxx.

                                                                                           :
    AthAlgorithm (name, pSvcLocator)
{}

Member Function Documentation

declareGaudiProperty()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

decorateLepWithReFitPrimaryVertex()

bool Prompt::PrimaryVertexReFitter::decorateLepWithReFitPrimaryVertex ( const FittingInput & input, const xAOD::TrackParticle * tracklep, const std::vector< const xAOD::TrackParticle * > & tracks, xAOD::VertexContainer & refitVtxContainer )

private

Definition at line 251 of file PrimaryVertexReFitter.cxx.

{
    //
    // Check if the lepton track has been used for primary vertex reconstruction.
    // if true, then remove the lepton track from the input track list, re-fit primary vertex again.
    // Save the ElementLink of the re-fit primary vertex to the lepton
    //
    if(!input.priVtx) {
        ATH_MSG_WARNING("decorateLepWithReFitPrimaryVertex - invalid input primary vertex pointer");
        return false;
    }
 
    //--------------------------------------------------------
    // Remove the lepton track from the track list
    // get re-fitted non-prompt primary vertex
    //
    std::vector<const xAOD::TrackParticle*> priVtx_tracks_pass;
    bool isRefit = false;
 
    for(const xAOD::TrackParticle *track: tracks) {
        if(track == tracklep) {
            isRefit = true;
            ATH_MSG_DEBUG("decorateLepWithReFitPrimaryVertex -- lepton has been used, lepton pT =" << tracklep->pt() << ", track pT =" << track->pt());
            continue;
        }
 
        priVtx_tracks_pass.push_back(track);
    }
 
    if(!isRefit) {
        ATH_MSG_DEBUG("decorateLepWithReFitPrimaryVertex -- Skip the primary vertex without lepton track");
 
        return false;
    }
 
    if(priVtx_tracks_pass.size() < 2) {
        ATH_MSG_DEBUG("decorateLepWithReFitPrimaryVertex -- Skip the primary vertex refitting: N tracks =" << priVtx_tracks_pass.size());
 
        return false;
    }
 
    std::unique_ptr<xAOD::Vertex> refittedVtxRMLep = m_vertexFitterTool->fitVertexWithSeed(
        input, priVtx_tracks_pass, input.priVtx->position(),
        Prompt::kRefittedPriVtxWithoutLep);
 
    if(refittedVtxRMLep) {
        ATH_MSG_DEBUG("decorateLepWithReFitPrimaryVertex -- save refitted non-prompt primary vertex with NTrack = " << refittedVtxRMLep->nTrackParticles());
 
        if(input.refittedPriVtx) {
            (*m_distToRefittedPriVtx)    (*refittedVtxRMLep) = Prompt::getDistance(input.refittedPriVtx->position(), refittedVtxRMLep->position());
            (*m_normdistToRefittedPriVtx)(*refittedVtxRMLep) = Prompt::getNormDist(
                input.refittedPriVtx->position(),
                refittedVtxRMLep->position(),
                refittedVtxRMLep->covariance(),
                msg(MSG::WARNING)
            );
        }
        //
        // Record vertex with output container
        //
        refitVtxContainer.push_back(std::move(refittedVtxRMLep));
 
        return true;
    }
    return false;
}

detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode Prompt::PrimaryVertexReFitter::execute ( )

overridevirtual

Definition at line 91 of file PrimaryVertexReFitter.cxx.

{
    const EventContext& ctx = Gaudi::Hive::currentContext();
 
    //
    // Start execute timer
    //
    TimerScopeHelper timer(m_timerExec);
 
    //
    // Find Inner Detector tracks
    //
    SG::ReadHandle<xAOD::TrackParticleContainer> h_inDetTracks(m_inDetTracksKey, ctx);
    if (!h_inDetTracks.isValid()){
        ATH_MSG_FATAL("execute - failed to find the InDetTrackParticles");
        return StatusCode::FAILURE;
    }
 
    const xAOD::TrackParticleContainer inDetTracks = *h_inDetTracks;
 
    //
    // Create output vertex collections and record them immediately
    // in StoreGate for memory management
    //
    std::unique_ptr<xAOD::VertexContainer> refitVtxContainer = std::make_unique< xAOD::VertexContainer>();
    std::unique_ptr<xAOD::VertexAuxContainer> refitVtxContainerAux = std::make_unique< xAOD::VertexAuxContainer>();
 
    refitVtxContainer->setStore(refitVtxContainerAux.get());
 
    SG::WriteHandle<xAOD::VertexContainer> h_refitVtxContainer (m_reFitPrimaryVertexKey, ctx);
    ATH_CHECK(h_refitVtxContainer.record(
        std::move(refitVtxContainer), std::move(refitVtxContainerAux)
    ));
    xAOD::VertexContainer &refitVtxContainerRef = *h_refitVtxContainer;
 
    //
    // Retrieve containers from evtStore
    //
    SG::ReadHandle<xAOD::IParticleContainer> h_leptonContainer(m_leptonContainerKey, ctx);
    if (!h_leptonContainer.isValid()){
        ATH_MSG_FATAL("execute - failed to find the lepton container");
        return StatusCode::FAILURE;
    }
 
    SG::ReadHandle<xAOD::VertexContainer> h_vertices(m_primaryVertexContainerKey, ctx);
    if (!h_vertices.isValid()){
        ATH_MSG_FATAL("execute - failed to find the vertices");
        return StatusCode::FAILURE;
    }
 
    const xAOD::IParticleContainer leptonContainer = *h_leptonContainer;
    const xAOD::VertexContainer    vertices        = *h_vertices;
 
    Prompt::FittingInput fittingInput(&inDetTracks, 0, 0);
 
    for(const xAOD::Vertex *vertex: vertices) {
        if(vertex->vertexType() == 1) {
            fittingInput.priVtx = dynamic_cast<const xAOD::Vertex*>(vertex);
            break;
        }
    }
 
    if(!fittingInput.priVtx) {
        ATH_MSG_INFO("Failed to find primary vertices - save empty containers");
        return StatusCode::SUCCESS;
    }
 
    //
    // Collect tracks used for primary vertex fit
    //
    std::vector<const xAOD::TrackParticle *> priVtx_tracks;
    priVtx_tracks.reserve(fittingInput.priVtx->nTrackParticles());
 
    for(unsigned k = 0; k < fittingInput.priVtx->nTrackParticles(); ++k) {
        const xAOD::TrackParticle *track  = fittingInput.priVtx->trackParticle(k);
 
        if(track) {
            priVtx_tracks.push_back(track);
        }
    }
 
    // Refit primary vertex
    std::unique_ptr<xAOD::Vertex> refittedPriVtx = m_vertexFitterTool->fitVertexWithSeed(
        fittingInput, priVtx_tracks,
        fittingInput.priVtx->position(),
        Prompt::kRefittedPriVtx
    );
 
    if(!refittedPriVtx) {
        ATH_MSG_WARNING("Failed to refit primary vertex - save empty containers");
        return StatusCode::SUCCESS;
    }
 
    //
    // Save refitted primary vertex for fitting service
    //
    fittingInput.refittedPriVtx = refittedPriVtx.get();
 
    ATH_MSG_DEBUG("execute --          primary vertex NTrack = " << fittingInput.priVtx         ->nTrackParticles());
    ATH_MSG_DEBUG("execute -- refitted primary vertex NTrack = " << fittingInput.refittedPriVtx->nTrackParticles());
 
    //
    // Dynamic cast IParticle container to electron or muon container
    //
    ATH_MSG_DEBUG("======================================="
            << "\n\t\t\t  Size of lepton container:    " << leptonContainer.size()
            << "\n-----------------------------------------------------------------");
 
    SG::WriteDecorHandle<xAOD::IParticleContainer, ElementLink<xAOD::VertexContainer> >
      lepRefittedRMVtxLinkDec (m_lepRefittedVtxWithoutLeptonLinkName, ctx);
 
    DataLink<xAOD::VertexContainer> refitVtxContainerLink (refitVtxContainerRef, ctx);
    for(const xAOD::IParticle *lepton: leptonContainer) {
        const xAOD::TrackParticle *tracklep = 0;
        const xAOD::Electron *elec = dynamic_cast<const xAOD::Electron*>(lepton);
        const xAOD::Muon *muon = dynamic_cast<const xAOD::Muon*>(lepton);
 
        if(elec) {
            //
            // get GSF track
            //
            const xAOD::TrackParticle *bestmatchedGSFElTrack=elec->trackParticle(0);
 
            //
            // get origin ID track for later study
            //
            tracklep = xAOD::EgammaHelpers::getOriginalTrackParticleFromGSF(bestmatchedGSFElTrack);
        }
        else if(muon) {
            if(muon->inDetTrackParticleLink().isValid()) {
                tracklep = *(muon->inDetTrackParticleLink());
            }
            else {
                ATH_MSG_DEBUG("PrimaryVertexReFitter::execute - skip muon without valid inDetTrackParticleLink()");
                continue;
            }
        }
 
        if(!tracklep) {
            ATH_MSG_WARNING("PrimaryVertexReFitter::execute - cannot find muon->inDetTrackParticleLink() nor electron->trackParticle()");
            continue;
        }
 
        if (decorateLepWithReFitPrimaryVertex(fittingInput, tracklep, priVtx_tracks, refitVtxContainerRef))
        {
          lepRefittedRMVtxLinkDec(*lepton) = ElementLink<xAOD::VertexContainer>(refitVtxContainerLink, refitVtxContainerRef.size()-1);
        }
    }
 
    h_refitVtxContainer->push_back(std::move(refittedPriVtx));
 
    ATH_MSG_DEBUG("SV Vertex container " << m_reFitPrimaryVertexKey << " recorded in store");
 
    ATH_MSG_DEBUG("execute - all done");
    ATH_MSG_DEBUG("=======================================");
 
    return StatusCode::SUCCESS;
}

extraDeps_update_handler()

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

protectedinherited

Add StoreName to extra input/output deps as needed.

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

extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 50 of file AthAlgorithm.cxx.

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

finalize()

StatusCode Prompt::PrimaryVertexReFitter::finalize ( )

overridevirtual

Definition at line 75 of file PrimaryVertexReFitter.cxx.

{
    if(m_printTime) {
        //
        // Print full time stopwatch
        //
        m_timerAll.Stop();
 
        ATH_MSG_INFO("Real time: " << m_timerAll.RealTime() << "\t CPU time: " << m_timerAll.CpuTime());
        ATH_MSG_INFO("Execute time: " << PrintResetStopWatch(m_timerExec));
    }
 
    return StatusCode::SUCCESS;
}

initialize()

StatusCode Prompt::PrimaryVertexReFitter::initialize ( )

overridevirtual

Definition at line 25 of file PrimaryVertexReFitter.cxx.

{
    ANA_MSG_DEBUG("ReFitPriVtxName = " << m_reFitPrimaryVertexKey);
    ANA_MSG_DEBUG("LeptonContainerName = " << m_leptonContainerKey);
    ANA_MSG_DEBUG("PriVertexContainerName = " << m_primaryVertexContainerKey);
 
    ANA_MSG_DEBUG("PrintTime = " << m_printTime);
 
    ANA_MSG_DEBUG("DistToRefittedPriVtxName = " << m_distToRefittedPriVtxName);
    ANA_MSG_DEBUG("NormDistToRefittedPriVtxName = " << m_normDistToRefittedPriVtxName);
    ANA_MSG_DEBUG("RefittedVtxWithoutLeptonLinkName = " << m_lepRefittedVtxWithoutLeptonLinkName.key());
 
    ATH_CHECK(m_inDetTracksKey.initialize());
 
    ATH_CHECK(m_leptonContainerKey.initialize());
    ATH_CHECK(m_primaryVertexContainerKey.initialize());
 
    ATH_CHECK(m_reFitPrimaryVertexKey.initialize());
 
    //
    // Must have non-empty container name for refitted primary vertex with/without lepton
    //
    if(m_reFitPrimaryVertexKey.empty()) {
        ATH_MSG_FATAL("initialize - SecVtx container invalid name: \"" << m_reFitPrimaryVertexKey << "\"");
        return StatusCode::FAILURE;
    }
 
    m_distToRefittedPriVtx.emplace (m_distToRefittedPriVtxName);
    m_normdistToRefittedPriVtx.emplace (m_normDistToRefittedPriVtxName);
    ATH_CHECK( m_lepRefittedVtxWithoutLeptonLinkName.initialize() );
 
    ATH_CHECK(m_vertexFitterTool.retrieve());
 
    if(m_printTime) {
        //
        // Reset timers
        //
        m_timerAll .Reset();
        m_timerExec.Reset();
 
        //
        // Start full timer
        //
        m_timerAll.Start();
    }
 
    return StatusCode::SUCCESS;
}

inputHandles()

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

overridevirtualinherited

Return this algorithm's input handles.

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

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

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

overridevirtualinherited

Return this algorithm's output handles.

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

renounce()

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

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

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

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

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

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

Definition at line 66 of file AthAlgorithm.cxx.

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

sysStart()

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

overridevirtualinherited

Handle START transition.

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

updateVHKA()

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

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_distToRefittedPriVtx

std::optional<accessorFloat_t> Prompt::PrimaryVertexReFitter::m_distToRefittedPriVtx

private

Definition at line 110 of file PrimaryVertexReFitter.h.

m_distToRefittedPriVtxName

Gaudi::Property<std::string> Prompt::PrimaryVertexReFitter::m_distToRefittedPriVtxName

private

Initial value:

{
            this, "DistToRefittedPriVtxName", "default"
        }

Definition at line 79 of file PrimaryVertexReFitter.h.

                                                            {
            this, "DistToRefittedPriVtxName", "default"
        };

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects

privateinherited

Definition at line 79 of file AthAlgorithm.h.

m_inDetTracksKey

SG::ReadHandleKey<xAOD::TrackParticleContainer> Prompt::PrimaryVertexReFitter::m_inDetTracksKey

private

Initial value:

{
            this, "InDetTrackParticlesKey", "InDetTrackParticles"
        }

Definition at line 90 of file PrimaryVertexReFitter.h.

                                                                    {
            this, "InDetTrackParticlesKey", "InDetTrackParticles"
        };

m_lepRefittedVtxWithoutLeptonLinkName

SG::WriteDecorHandleKey<xAOD::IParticleContainer> Prompt::PrimaryVertexReFitter::m_lepRefittedVtxWithoutLeptonLinkName { this, "RefittedVtxWithoutLeptonLinkName", m_leptonContainerKey, "default", "" }

private

Definition at line 113 of file PrimaryVertexReFitter.h.

{ this, "RefittedVtxWithoutLeptonLinkName", m_leptonContainerKey, "default", "" };

m_leptonContainerKey

SG::ReadHandleKey<xAOD::IParticleContainer> Prompt::PrimaryVertexReFitter::m_leptonContainerKey

private

Initial value:

{
            this,
            "LeptonContainerName",
            "lepContainerNameDefault", "Name of lepton container"
        }

Definition at line 94 of file PrimaryVertexReFitter.h.

                                                                     {
            this,
            "LeptonContainerName",
            "lepContainerNameDefault", "Name of lepton container"
        };

m_normdistToRefittedPriVtx

std::optional<accessorFloat_t> Prompt::PrimaryVertexReFitter::m_normdistToRefittedPriVtx

private

Definition at line 111 of file PrimaryVertexReFitter.h.

m_normDistToRefittedPriVtxName

Gaudi::Property<std::string> Prompt::PrimaryVertexReFitter::m_normDistToRefittedPriVtxName

private

Initial value:

{
            this, "NormDistToRefittedPriVtxName", "default"
        }

Definition at line 82 of file PrimaryVertexReFitter.h.

                                                                {
            this, "NormDistToRefittedPriVtxName", "default"
        };

m_primaryVertexContainerKey

SG::ReadHandleKey<xAOD::VertexContainer> Prompt::PrimaryVertexReFitter::m_primaryVertexContainerKey

private

Initial value:

{
            this, "PriVertexContainerName", "PrimaryVertices",
            "Name of primary vertex container"
        }

Definition at line 99 of file PrimaryVertexReFitter.h.

                                                                         {
            this, "PriVertexContainerName", "PrimaryVertices",
            "Name of primary vertex container"
        };

m_printTime

Gaudi::Property<bool> Prompt::PrimaryVertexReFitter::m_printTime {this, "PrintTime", false}

private

Definition at line 77 of file PrimaryVertexReFitter.h.

{this, "PrintTime", false};

m_reFitPrimaryVertexKey

SG::WriteHandleKey<xAOD::VertexContainer> Prompt::PrimaryVertexReFitter::m_reFitPrimaryVertexKey

private

Initial value:

{
            this, "ReFitPriVtxName", "default"
        }

Definition at line 103 of file PrimaryVertexReFitter.h.

                                                                      {
            this, "ReFitPriVtxName", "default"
        };

m_timerAll

TStopwatch Prompt::PrimaryVertexReFitter::m_timerAll

private

Definition at line 86 of file PrimaryVertexReFitter.h.

m_timerExec

TStopwatch Prompt::PrimaryVertexReFitter::m_timerExec

private

Definition at line 87 of file PrimaryVertexReFitter.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vertexFitterTool

ToolHandle<Prompt::VertexFittingTool> Prompt::PrimaryVertexReFitter::m_vertexFitterTool

private

Initial value:

{
            this, "VertexFittingTool", "Prompt::VertexFittingTool/VertexFittingTool"
        }

Definition at line 70 of file PrimaryVertexReFitter.h.

                                                               {
            this, "VertexFittingTool", "Prompt::VertexFittingTool/VertexFittingTool"
        };

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• PrimaryVertexReFitter.h
• PrimaryVertexReFitter.cxx