ATLAS Offline Software
Loading...
Searching...
No Matches
Rec::MuSAVtxFitter Class Reference

#include <MuSAVtxFitter.h>

Inheritance diagram for Rec::MuSAVtxFitter:
Collaboration diagram for Rec::MuSAVtxFitter:

Public Member Functions

virtual ~MuSAVtxFitter ()
virtual StatusCode initialize () override
StatusCode fillCollections (std::vector< MuSAVtxFitterTool::WrkVrt > &workVerticesContainer, xAOD::VertexContainer *MuSAVtxContainer, xAOD::TrackParticleContainer *MuSAExtrapolatedTracksContainer, const xAOD::MuonContainer &muonContainer, const xAOD::TrackParticleContainer &MSTPContainer, const EventContext &ctx) const
virtual StatusCode execute (const EventContext &ctx) const override
virtual StatusCode sysInitialize () override
 Override sysInitialize.
virtual bool isClonable () const override
 Specify if the algorithm is clonable.
virtual unsigned int cardinality () const override
 Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.
virtual StatusCode sysExecute (const EventContext &ctx) override
 Execute an algorithm.
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies.
virtual bool filterPassed (const EventContext &ctx) const
virtual void setFilterPassed (bool state, const EventContext &ctx) const
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.

Protected Attributes

SG::ReadHandleKey< xAOD::MuonContainerm_muonContainer { this, "MuonContainerName", "Muons", "Muon container key" }
SG::ReadHandleKey< xAOD::EventInfom_eventInfo { this, "EventInfoName", "EventInfo", "Event info key" }
SG::ReadHandleKey< xAOD::TrackParticleContainerm_MSTPContainer {this, "MSTPContainerName", "MuonSpectrometerTrackParticles", "MSTP Key"}
SG::WriteHandleKey< xAOD::VertexContainerm_MuSAVertices { this, "MuSAVtxContainerName", "MuSAVertices", "MuSA vtx container" }
SG::WriteHandleKey< xAOD::TrackParticleContainerm_MuSAExtrapolatedTracks { this, "MuSAExtrapolatedTracksName", "MuSAExtrapolatedTrackParticles", "MuSA extrapolated tracks" }
ToolHandle< Rec::MuSAVtxFitterToolm_MuSAVtxFitterTool {this, "MuSAVtxToolName", "Rec::MuSAVtxFitterTool"}
ToolHandle< Reco::ITrackToVertexm_trackToVertexTool {this, "TrackToVertexTool", "Reco::TrackToVertex"}

Private Types

typedef ServiceHandle< StoreGateSvcStoreGateSvc_t

Private Member Functions

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

Private Attributes

DataObjIDColl m_extendedExtraObjects
 Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
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 27 of file MuSAVtxFitter.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ ~MuSAVtxFitter()

MuSAVtxFitter::~MuSAVtxFitter ( )
virtualdefault

Member Function Documentation

◆ cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality ( ) const
overridevirtualinherited

Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.

Override this to return 0 for reentrant algorithms.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

64{
65 return 0;
66}

◆ declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::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.

158 {
160 hndl.value(),
161 hndl.documentation());
162
163 }
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)

◆ declareProperty()

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

Definition at line 145 of file AthCommonDataStore.h.

145 {
146 typedef typename SG::HandleClassifier<T>::type htype;
148 }
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>

◆ detStore()

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

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

Definition at line 95 of file AthCommonDataStore.h.

◆ evtStore()

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

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

Definition at line 85 of file AthCommonDataStore.h.

◆ execute()

StatusCode MuSAVtxFitter::execute ( const EventContext & ctx) const
overridevirtual

Definition at line 219 of file MuSAVtxFitter.cxx.

220{
221 SG::ReadHandle muonContainer(m_muonContainer, ctx);
222 ATH_CHECK(muonContainer.isValid());
223
224 SG::ReadHandle MSTPContainer(m_MSTPContainer, ctx);
225 ATH_CHECK(MSTPContainer.isValid());
226
227 SG::ReadHandle eventInfo(m_eventInfo, ctx);
228 ATH_CHECK(eventInfo.isValid());
229
230 SG::WriteHandle MuSAVtxContainer(m_MuSAVertices, ctx);
231 ATH_CHECK(MuSAVtxContainer.record(std::make_unique<xAOD::VertexContainer>(), std::make_unique<xAOD::VertexAuxContainer>()));
232
233 SG::WriteHandle MuSAExtrapolatedTracksContainer(m_MuSAExtrapolatedTracks, ctx);
234 ATH_CHECK(MuSAExtrapolatedTracksContainer.record(std::make_unique<xAOD::TrackParticleContainer>(), std::make_unique<xAOD::TrackParticleAuxContainer>()));
235
236 std::vector<MuSAVtxFitterTool::WrkVrt> workVerticesContainer;
237
238 // Perform primary MuSA vertex fit
239 ATH_CHECK(m_MuSAVtxFitterTool->doMuSAVtxFit(workVerticesContainer, *muonContainer, *eventInfo, ctx));
240
241 // If there's no MuSA vertices to begin with, stop here to avoid wasting CPU cycles
242 if (workVerticesContainer.empty()) {
243 ATH_MSG_DEBUG("No MuSA vertices found");
244 return StatusCode::SUCCESS;
245 }
246
247 // Perform user-configurable post-fit selections
248 ATH_CHECK(m_MuSAVtxFitterTool->doPostFitSelections(workVerticesContainer));
249
250 // If there's no MuSA vertices remaining, stop here to again avoid wasting CPU cycles
251 if (workVerticesContainer.empty()) {
252 ATH_MSG_DEBUG("No MuSA vertices found after post-fit selection!");
253 return StatusCode::SUCCESS;
254 }
255
256 // Perform "ambiguity resolution" to prevent re-used SA muons in events with more than one MuSA vtx
257 ATH_CHECK(m_MuSAVtxFitterTool->selectBestVertices(workVerticesContainer));
258
259 // Again avoiding wasting CPU cycles if no MuSA vertices remain
260 if (workVerticesContainer.empty()) {
261 ATH_MSG_DEBUG("No MuSA vertices found after best overlap selection!");
262 return StatusCode::SUCCESS;
263 } else {
264 ATH_MSG_DEBUG("Found " << workVerticesContainer.size() << " MuSA vertices");
265 }
266
267 ATH_CHECK(fillCollections(workVerticesContainer, MuSAVtxContainer.ptr(), MuSAExtrapolatedTracksContainer.ptr(), *muonContainer, *MSTPContainer, ctx));
268 ATH_MSG_DEBUG("Saved MuSA collections!");
269
270 return StatusCode::SUCCESS;
271}
#define ATH_CHECK
Evaluate an expression and check for errors.
#define ATH_MSG_DEBUG(x)
xAOD::MuonContainer * muonContainer
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_MSTPContainer
StatusCode fillCollections(std::vector< MuSAVtxFitterTool::WrkVrt > &workVerticesContainer, xAOD::VertexContainer *MuSAVtxContainer, xAOD::TrackParticleContainer *MuSAExtrapolatedTracksContainer, const xAOD::MuonContainer &muonContainer, const xAOD::TrackParticleContainer &MSTPContainer, const EventContext &ctx) const
SG::ReadHandleKey< xAOD::MuonContainer > m_muonContainer
SG::WriteHandleKey< xAOD::VertexContainer > m_MuSAVertices
SG::WriteHandleKey< xAOD::TrackParticleContainer > m_MuSAExtrapolatedTracks
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfo
ToolHandle< Rec::MuSAVtxFitterTool > m_MuSAVtxFitterTool

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::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 & AthCommonReentrantAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 94 of file AthCommonReentrantAlgorithm.cxx.

90{
91 // If we didn't find any symlinks to add, just return the collection
92 // from the base class. Otherwise, return the extended collection.
93 if (!m_extendedExtraObjects.empty()) {
95 }
97}
An algorithm that can be simultaneously executed in multiple threads.

◆ fillCollections()

StatusCode MuSAVtxFitter::fillCollections ( std::vector< MuSAVtxFitterTool::WrkVrt > & workVerticesContainer,
xAOD::VertexContainer * MuSAVtxContainer,
xAOD::TrackParticleContainer * MuSAExtrapolatedTracksContainer,
const xAOD::MuonContainer & muonContainer,
const xAOD::TrackParticleContainer & MSTPContainer,
const EventContext & ctx ) const

Definition at line 75 of file MuSAVtxFitter.cxx.

81{
82 ATH_MSG_DEBUG("MuSAVtxFitter::fillCollections");
83 for (const auto& workVertex : workVerticesContainer) {
84
85 xAOD::Vertex* MuSAVertex = new xAOD::Vertex();
86 MuSAVtxContainer->emplace_back(MuSAVertex);
87
88 // Place the new extrapolated tracks in the new container (we need the index for bookkeeping)
89 for (size_t i = 0; i < workVertex.newExtrapolatedTracks.size(); i++) {
90
91 // copy transfers ownership of the shared_ptr in wrkvrt to container
92 xAOD::TrackParticle* containerTrack = MuSAExtrapolatedTracksContainer->push_back(new xAOD::TrackParticle());
93 *containerTrack=*workVertex.newExtrapolatedTracks[i];
94
95 // Link the new tracks to the vertex
96 ElementLink<xAOD::TrackParticleContainer> link_trk(*MuSAExtrapolatedTracksContainer, MuSAExtrapolatedTracksContainer->size() - 1);
97 MuSAVertex->addTrackAtVertex(link_trk, 1.0);
98
99 //Also link the extrapolated tracks and vertices to their original muons -- extrapolated tracks and their muons should have the same index in workVertex
100
101 bool muonLinkSuccess = false;
102 bool MSTPLinkSuccess = false;
103
104 ElementLink<xAOD::MuonContainer> link_muon;
105 ElementLink<xAOD::TrackParticleContainer> link_MSTP;
106 muonLinkSuccess = link_muon.toContainedElement(muonContainer, workVertex.muonCandidates[i]);
107
108 const xAOD::Muon* muon = muonContainer[link_muon.index()];
109 const xAOD::TrackParticle* MSTP = muon->trackParticle(xAOD::Muon::MuonSpectrometerTrackParticle);
110 if (MSTP) {
111 MSTPLinkSuccess = link_MSTP.toContainedElement(MSTPContainer, MSTP);
112 }
113
114 // Check that links are valid
115 if (!MSTPLinkSuccess) {
116 ATH_MSG_WARNING("Failed to link MSTP!");
117 } else {
118 acc_MSTPLink(*containerTrack) = link_MSTP;
119 auto& mstpLinks = acc_MSTPLinks(*MuSAVertex);
120 mstpLinks.push_back(link_MSTP);
121 }
122
123 if (!muonLinkSuccess) {
124 ATH_MSG_WARNING("Failed to link muon!");
125 } else {
126 acc_MuonLink(*containerTrack) = link_muon;
127 auto& muonLinks = acc_MuonLinks(*MuSAVertex);
128 muonLinks.push_back(link_muon);
129 }
130 }
131
132 MuSAVertex->setPosition(workVertex.pos);
134 MuSAVertex->setFitQuality(workVertex.chi2, 1);
135 std::vector<float> fCov(workVertex.cov.cbegin(), workVertex.cov.cend());
136 MuSAVertex->setCovariance(fCov);
137
138 vtx_pxAcc(*MuSAVertex) = workVertex.mom.Px();
139 vtx_pyAcc(*MuSAVertex) = workVertex.mom.Py();
140 vtx_pzAcc(*MuSAVertex) = workVertex.mom.Pz();
141
142 vtx_massAcc(*MuSAVertex) = workVertex.mom.M();
143 vtx_chargeAcc(*MuSAVertex) = workVertex.charge;
144
145 minOpAngAcc(*MuSAVertex) = workVertex.minOpAng;
146
147 chi2_coreAcc(*MuSAVertex) = workVertex.chi2Core;
148 ndof_coreAcc(*MuSAVertex) = 1;
149 chi2_assocAcc(*MuSAVertex) = workVertex.chi2;
150 ndof_assocAcc(*MuSAVertex) = workVertex.ndof();
151
152 TLorentzVector sumP4_muon;
153 TLorentzVector sumP4_electron;
154 TLorentzVector sumP4_selected;
155
156 constexpr double muonMass = 105.658; // Muon mass in MeV
157
158 for (size_t i = 0; i < workVertex.newExtrapolatedTracks.size(); i++) {
159 const xAOD::TrackParticle* track = workVertex.newExtrapolatedTracks[i].get();
160 double pt_wrtSV = track->pt();
161 double eta_wrtSV = track->eta();
162 double phi_wrtSV = track->phi();
163
164 TLorentzVector p4wrtSV_muon;
165 TLorentzVector p4wrtSV_electron;
166
167 p4wrtSV_muon.SetPtEtaPhiM(pt_wrtSV, eta_wrtSV, phi_wrtSV, muonMass);
168 p4wrtSV_electron.SetPtEtaPhiM(pt_wrtSV, eta_wrtSV, phi_wrtSV, VKalVrtAthena::PhysConsts::mass_electron);
169
170 sumP4_muon += p4wrtSV_muon;
171 sumP4_electron += p4wrtSV_electron;
172 sumP4_selected += p4wrtSV_muon;
173
174 size_t trackIndex = MuSAVertex->trackParticleLinks()[i].index();
175 xAOD::TrackParticle* containerTrack = MuSAExtrapolatedTracksContainer->at(trackIndex);
176
177 std::unique_ptr<Trk::Perigee> sv_perigee = m_trackToVertexTool->perigeeAtVertex(ctx, *containerTrack, workVertex.pos);
178 if (!sv_perigee) {
179 ATH_MSG_WARNING("Failed in obtaining the SV perigee for track!");
180 continue;
181 }
182
183 double qOverP_wrtSV = sv_perigee->parameters()[Trk::qOverP];
184 double theta_wrtSV = sv_perigee->parameters()[Trk::theta];
185 double p_wrtSV = 1.0 / std::abs(qOverP_wrtSV);
186 pt_wrtSV = p_wrtSV * sin(theta_wrtSV);
187 eta_wrtSV = -log(tan(theta_wrtSV / 2.0));
188 phi_wrtSV = sv_perigee->parameters()[Trk::phi];
189 double d0_wrtSV = sv_perigee->parameters()[Trk::d0];
190 double z0_wrtSV = sv_perigee->parameters()[Trk::z0];
191 double sqrd0Err_wrtSV = (*sv_perigee->covariance())(Trk::d0, Trk::d0);
192 double sqrz0Err_wrtSV = (*sv_perigee->covariance())(Trk::z0, Trk::z0);
193 double sqrQoPErr_wrtSV = (*sv_perigee->covariance())(Trk::qOverP, Trk::qOverP);
194
195 qOverP_wrtSVAcc(*containerTrack) = qOverP_wrtSV;
196 theta_wrtSVAcc(*containerTrack) = theta_wrtSV;
197 p_wrtSVAcc(*containerTrack) = p_wrtSV;
198 pt_wrtSVAcc(*containerTrack) = pt_wrtSV;
199 eta_wrtSVAcc(*containerTrack) = eta_wrtSV;
200 phi_wrtSVAcc(*containerTrack) = phi_wrtSV;
201 d0_wrtSVAcc(*containerTrack) = d0_wrtSV;
202 z0_wrtSVAcc(*containerTrack) = z0_wrtSV;
203 sqrd0Err_wrtSVAcc(*containerTrack) = sqrd0Err_wrtSV;
204 sqrz0Err_wrtSVAcc(*containerTrack) = sqrz0Err_wrtSV;
205 sqrQoPErr_wrtSVAcc(*containerTrack) = sqrQoPErr_wrtSV;
206 }
207
208 massAcc(*MuSAVertex) = sumP4_muon.M();
209 mass_eAcc(*MuSAVertex) = sumP4_electron.M();
210 mass_selectedTracksAcc(*MuSAVertex) = sumP4_selected.M();
211 num_trksAcc(*MuSAVertex) = workVertex.nTracksTotal();
212 num_selectedTracksAcc(*MuSAVertex) = workVertex.selectedTrackIndices.size();
213 num_associatedTracksAcc(*MuSAVertex) = workVertex.associatedTrackIndices.size();
214 dCloseVrtAcc(*MuSAVertex) = workVertex.closestWrkVrtValue;
215 }
216 return StatusCode::SUCCESS;
217}
#define ATH_MSG_WARNING(x)
value_type emplace_back(value_type pElem)
Add an element to the end of the collection.
const T * at(size_type n) const
Access an element, as an rvalue.
value_type push_back(value_type pElem)
Add an element to the end of the collection.
size_type size() const noexcept
Returns the number of elements in the collection.
ToolHandle< Reco::ITrackToVertex > m_trackToVertexTool
void addTrackAtVertex(const ElementLink< TrackParticleContainer > &tr, float weight=1.0)
Add a new track to the vertex.
const TrackParticleLinks_t & trackParticleLinks() const
Get all the particles associated with the vertex.
void setVertexType(VxType::VertexType vType)
Set the type of the vertex.
void setCovariance(const std::vector< float > &value)
Sets the covariance matrix as a simple vector of values.
void setPosition(const Amg::Vector3D &position)
Sets the 3-position.
void setFitQuality(float chiSquared, float numberDoF)
Set the 'Fit Quality' information.
@ theta
Definition ParamDefs.h:66
@ qOverP
perigee
Definition ParamDefs.h:67
@ phi
Definition ParamDefs.h:75
@ d0
Definition ParamDefs.h:63
@ z0
Definition ParamDefs.h:64
@ SecVtx
Secondary vertex.
TrackParticle_v1 TrackParticle
Reference the current persistent version:
Vertex_v1 Vertex
Define the latest version of the vertex class.
Muon_v1 Muon
Reference the current persistent version:

◆ filterPassed()

virtual bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx) const
inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

96 {
97 return execState( ctx ).filterPassed();
98 }
virtual bool filterPassed(const EventContext &ctx) const

◆ initialize()

StatusCode MuSAVtxFitter::initialize ( )
overridevirtual

Definition at line 55 of file MuSAVtxFitter.cxx.

56{
57 ATH_CHECK( m_muonContainer.initialize() );
58 ATH_CHECK( m_MSTPContainer.initialize() );
59 ATH_CHECK( m_eventInfo.initialize() );
60 ATH_CHECK( m_MuSAVertices.initialize() );
61 ATH_CHECK( m_MuSAExtrapolatedTracks.initialize() );
62
63 ATH_CHECK( m_MuSAVtxFitterTool.retrieve() );
64 ATH_MSG_DEBUG("Retrieved tool " << m_MuSAVtxFitterTool);
65
66 ATH_CHECK( m_trackToVertexTool.retrieve() );
67 ATH_MSG_DEBUG("Retrieved tool " << m_trackToVertexTool);
68
69 ATH_MSG_DEBUG("Initialization successful");
70
71 return StatusCode::SUCCESS;
72
73}

◆ inputHandles()

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

◆ isClonable()

◆ msg()

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

Definition at line 24 of file AthCommonMsg.h.

24 {
25 return this->msgStream();
26 }

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

30 {
31 return this->msgLevel(lvl);
32 }

◆ outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::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< Gaudi::Algorithm > >::renounce ( T & h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381 {
382 h.renounce();
384 }
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)

◆ renounceArray()

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

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364 {
366 }

◆ setFilterPassed()

virtual void AthCommonReentrantAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state,
const EventContext & ctx ) const
inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

100 {
102 }
virtual void setFilterPassed(bool state, const EventContext &ctx) const

◆ sysExecute()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext & ctx)
overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Definition at line 85 of file AthCommonReentrantAlgorithm.cxx.

77{
78 return BaseAlg::sysExecute (ctx);
79}

◆ sysInitialize()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::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< Gaudi::Algorithm > >.

Reimplemented in HypoBase, and InputMakerBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.cxx.

107 {
109
110 if (sc.isFailure()) {
111 return sc;
112 }
113
114 ServiceHandle<ICondSvc> cs("CondSvc",name());
115 for (auto h : outputHandles()) {
116 if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
117 // do this inside the loop so we don't create the CondSvc until needed
118 if ( cs.retrieve().isFailure() ) {
119 ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
120 return StatusCode::SUCCESS;
121 }
122 if (cs->regHandle(this,*h).isFailure()) {
124 ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
125 << " with CondSvc");
126 }
127 }
128 }
129 return sc;
130}
#define ATH_MSG_ERROR(x)
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::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< Gaudi::Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308 {
309 // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310 // << " size: " << m_vhka.size() << endmsg;
311 for (auto &a : m_vhka) {
313 for (auto k : keys) {
314 k->setOwner(this);
315 }
316 }
317 }

Member Data Documentation

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_eventInfo

SG::ReadHandleKey<xAOD::EventInfo> Rec::MuSAVtxFitter::m_eventInfo { this, "EventInfoName", "EventInfo", "Event info key" }
protected

Definition at line 43 of file MuSAVtxFitter.h.

43{ this, "EventInfoName", "EventInfo", "Event info key" };

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.h.

◆ m_MSTPContainer

SG::ReadHandleKey<xAOD::TrackParticleContainer> Rec::MuSAVtxFitter::m_MSTPContainer {this, "MSTPContainerName", "MuonSpectrometerTrackParticles", "MSTP Key"}
protected

Definition at line 44 of file MuSAVtxFitter.h.

44{this, "MSTPContainerName", "MuonSpectrometerTrackParticles", "MSTP Key"};

◆ m_muonContainer

SG::ReadHandleKey<xAOD::MuonContainer> Rec::MuSAVtxFitter::m_muonContainer { this, "MuonContainerName", "Muons", "Muon container key" }
protected

Definition at line 42 of file MuSAVtxFitter.h.

42{ this, "MuonContainerName", "Muons", "Muon container key" };

◆ m_MuSAExtrapolatedTracks

SG::WriteHandleKey<xAOD::TrackParticleContainer> Rec::MuSAVtxFitter::m_MuSAExtrapolatedTracks { this, "MuSAExtrapolatedTracksName", "MuSAExtrapolatedTrackParticles", "MuSA extrapolated tracks" }
protected

Definition at line 50 of file MuSAVtxFitter.h.

50{ this, "MuSAExtrapolatedTracksName", "MuSAExtrapolatedTrackParticles", "MuSA extrapolated tracks" };

◆ m_MuSAVertices

SG::WriteHandleKey<xAOD::VertexContainer> Rec::MuSAVtxFitter::m_MuSAVertices { this, "MuSAVtxContainerName", "MuSAVertices", "MuSA vtx container" }
protected

Definition at line 47 of file MuSAVtxFitter.h.

47{ this, "MuSAVtxContainerName", "MuSAVertices", "MuSA vtx container" };

◆ m_MuSAVtxFitterTool

ToolHandle<Rec::MuSAVtxFitterTool> Rec::MuSAVtxFitter::m_MuSAVtxFitterTool {this, "MuSAVtxToolName", "Rec::MuSAVtxFitterTool"}
protected

Definition at line 53 of file MuSAVtxFitter.h.

53{this, "MuSAVtxToolName", "Rec::MuSAVtxFitterTool"};

◆ m_trackToVertexTool

ToolHandle<Reco::ITrackToVertex> Rec::MuSAVtxFitter::m_trackToVertexTool {this, "TrackToVertexTool", "Reco::TrackToVertex"}
protected

Definition at line 54 of file MuSAVtxFitter.h.

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

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.


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