ATLAS Offline Software
Public Member Functions | Private Attributes | List of all members
DerivationFramework::Reco_Vertex Class Reference

#include <Reco_Vertex.h>

Inheritance diagram for DerivationFramework::Reco_Vertex:
Collaboration diagram for DerivationFramework::Reco_Vertex:

Public Member Functions

 Reco_Vertex (const std::string &t, const std::string &n, const IInterface *p)
 
virtual StatusCode initialize ()
 
virtual StatusCode addBranches (const EventContext &ctx) const
 

Private Attributes

ToolHandle< Trk::V0Tools > m_v0Tools
 tools More...
 
ToolHandle< Analysis::ICandidateSearch > m_SearchTool
 
ToolHandle< Analysis::PrimaryVertexRefitter > m_pvRefitter
 
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfo_key {this, "EventInfo", "EventInfo", "Input event information"}
 
SG::WriteHandleKey< xAOD::VertexContainer > m_outputVtxContainerName
 job options More...
 
SG::ReadHandleKey< xAOD::VertexContainer > m_pvContainerName
 
SG::WriteHandleKey< xAOD::VertexContainer > m_refPVContainerName
 
bool m_refitPV
 
int m_PV_max
 
int m_DoVertexType
 
size_t m_PV_minNTracks
 
bool m_do3d
 
bool m_checkCollections
 
SG::ReadHandleKeyArray< xAOD::VertexContainer > m_CollectionsToCheck
 
SG::ReadHandleKeyArray< xAOD::TrackParticleContainer > m_RelinkContainers {this, "RelinkTracks", {}, "Track Containers if they need to be relinked through indirect use" }
 
SG::ReadHandleKeyArray< xAOD::MuonContainer > m_RelinkMuons {this, "RelinkMuons", {}, "Muon Containers if they need to be relinked through indirect use" }
 

Detailed Description

Definition at line 25 of file Reco_Vertex.h.

Constructor & Destructor Documentation

◆ Reco_Vertex()

DerivationFramework::Reco_Vertex::Reco_Vertex ( const std::string &  t,
const std::string &  n,
const IInterface *  p 
)

Definition at line 21 of file Reco_Vertex.cxx.

23  :
24  base_class(t,n,p),
25  m_v0Tools("Trk::V0Tools", this),
26  m_SearchTool("",this),
27  m_pvRefitter("Analysis::PrimaryVertexRefitter", this)
28  {
29 
30  // Declare tools
31  declareProperty("V0Tools" , m_v0Tools);
32  declareProperty("VertexSearchTool", m_SearchTool);
33  declareProperty("PVRefitter", m_pvRefitter);
34 
35  // Declare user-defined properties
36  declareProperty("OutputVtxContainerName", m_outputVtxContainerName = "OniaCandidates");
37  declareProperty("PVContainerName" , m_pvContainerName = "PrimaryVertices");
38  declareProperty("RefPVContainerName" , m_refPVContainerName = "RefittedPrimaryVertices");
39  declareProperty("RefitPV" , m_refitPV = false);
40  declareProperty("MaxPVrefit" , m_PV_max = 1000);
41  declareProperty("DoVertexType" , m_DoVertexType = 7);
42  // minimum number of tracks for PV to be considered for PV association
43  declareProperty("MinNTracksInPV" , m_PV_minNTracks = 0);
44  declareProperty("Do3d" , m_do3d = false);
45  declareProperty("CheckCollections" , m_checkCollections = false);
46  declareProperty("CheckVertexContainers" , m_CollectionsToCheck);
47  }

Member Function Documentation

◆ addBranches()

StatusCode DerivationFramework::Reco_Vertex::addBranches ( const EventContext &  ctx) const
virtual

Definition at line 81 of file Reco_Vertex.cxx.

82  {
83  bool callTool = true;
84  if(m_checkCollections) {
85  for(const auto &str : m_CollectionsToCheck){
86  SG::ReadHandle<xAOD::VertexContainer> handle(str,ctx);
87  ATH_CHECK(handle.isValid());
88  if(handle->size() == 0) {
89  callTool = false;
90  ATH_MSG_DEBUG("Container VertexContainer (" << str << ") is empty");
91  break;//No point checking other containers
92  }
93  }
94  }
95 
96  // Vertex container and its auxilliary store
97  std::unique_ptr<xAOD::VertexContainer> vtxContainer = std::make_unique<xAOD::VertexContainer>();
98  std::unique_ptr<xAOD::VertexAuxContainer> vtxAuxContainer = std::make_unique<xAOD::VertexAuxContainer>();
99  vtxContainer->setStore(vtxAuxContainer.get());
100 
101  if(callTool) {
102  //----------------------------------------------------
103  // call Tool
104  //----------------------------------------------------
105  if( !m_SearchTool->performSearch(ctx,*vtxContainer).isSuccess() ) {
106  ATH_MSG_FATAL("Tool (" << m_SearchTool << ") failed.");
107  return StatusCode::FAILURE;
108  }
109 
110  //----------------------------------------------------
111  // retrieve primary vertices
112  //----------------------------------------------------
113  SG::ReadHandle<xAOD::VertexContainer> pvContainer(m_pvContainerName,ctx);
114 
115  //----------------------------------------------------
116  // Try to retrieve refitted primary vertices
117  //----------------------------------------------------
118  std::unique_ptr<xAOD::VertexContainer> refPvContainer;
119  std::unique_ptr<xAOD::VertexAuxContainer> refPvAuxContainer;
120  if(m_refitPV) {
121  // refitted PV container does not exist. Create a new one.
122  refPvContainer = std::make_unique<xAOD::VertexContainer>();
123  refPvAuxContainer = std::make_unique<xAOD::VertexAuxContainer>();
124  refPvContainer->setStore(refPvAuxContainer.get());
125  }
126 
127  // Give the helper class the ptr to v0tools and beamSpotsSvc to use
128  SG::ReadHandle<xAOD::EventInfo> evt(m_eventInfo_key, ctx);
129  if(not evt.isValid()) ATH_MSG_ERROR("Cannot Retrieve " << evt.key() );
130  BPhysPVTools helper(&(*m_v0Tools), evt.cptr());
131  helper.SetMinNTracksInPV(m_PV_minNTracks);
132  helper.SetSave3d(m_do3d);
133 
134  if(m_refitPV){
135  if(vtxContainer->size() >0){
136  if(vtxContainer->size() > 10000){
137  ATH_MSG_WARNING("Number of candidates is very high N=" << vtxContainer->size() << " this may crash the sharedwriter");
138  }
139  StatusCode SC = helper.FillCandwithRefittedVertices(vtxContainer.get(), pvContainer.cptr(), refPvContainer.get(), &(*m_pvRefitter) , m_PV_max, m_DoVertexType);
140  if(SC.isFailure()){
141  ATH_MSG_FATAL("refitting failed - check the vertices you passed");
142  return SC;
143  }
144  if(refPvContainer->size() > 10000){
145  ATH_MSG_WARNING("Number of refitted vertices is very high N=" << refPvContainer->size() << " this may crash the sharedwriter");
146  }
147  }
148  }else{
149  if(vtxContainer->size() >0)CHECK(helper.FillCandExistingVertices(vtxContainer.get(), pvContainer.cptr(), m_DoVertexType));
150  }
151 
152  using Analysis::JpsiUpsilonCommon;
153 
154  std::vector<const xAOD::TrackParticleContainer*> trackCols;
155  for(const auto &str : m_RelinkContainers){
156  SG::ReadHandle<xAOD::TrackParticleContainer> handle(str,ctx);
157  trackCols.push_back(handle.cptr());
158  }
159  if(not trackCols.empty()){
160  for(xAOD::Vertex* vtx : *vtxContainer.get()){
161  try{
162  JpsiUpsilonCommon::RelinkVertexTracks(trackCols, vtx);
163  }catch(std::runtime_error const& e){
164  ATH_MSG_ERROR(e.what());
165  return StatusCode::FAILURE;
166  }
167  }
168  }
169  std::vector<const xAOD::MuonContainer*> muCols;
170  for(const auto &str : m_RelinkMuons){
171  SG::ReadHandle<xAOD::MuonContainer> handle(str,ctx);
172  muCols.push_back(handle.cptr());
173  }
174  if(not muCols.empty()){
175  for(xAOD::Vertex* vtx : *vtxContainer.get()){
176  try{
177  JpsiUpsilonCommon::RelinkVertexMuons(muCols, vtx);
178  }catch(std::runtime_error const& e){
179  ATH_MSG_ERROR(e.what());
180  return StatusCode::FAILURE;
181  }
182  }
183  }
184  //----------------------------------------------------
185  // save in the StoreGate
186  //----------------------------------------------------
187  SG::WriteHandle<xAOD::VertexContainer> handle(m_outputVtxContainerName, ctx);
188  ATH_CHECK(handle.record(std::move(vtxContainer), std::move(vtxAuxContainer)));
189 
190  if(m_refitPV) {
191  SG::WriteHandle<xAOD::VertexContainer> handle(m_refPVContainerName, ctx);
192  ATH_CHECK(handle.record(std::move(refPvContainer), std::move(refPvAuxContainer)));
193  }
194  }
195 
196  if (!callTool) { //Fill with empty containers
197  SG::WriteHandle<xAOD::VertexContainer> handle(m_outputVtxContainerName, ctx);
198  ATH_CHECK(handle.record(std::unique_ptr<xAOD::VertexContainer>(new xAOD::VertexContainer ),
199  std::unique_ptr<xAOD::VertexAuxContainer>(new xAOD::VertexAuxContainer )));
200  }
201 
202  return StatusCode::SUCCESS;
203  }

◆ initialize()

StatusCode DerivationFramework::Reco_Vertex::initialize ( )
virtual

Definition at line 51 of file Reco_Vertex.cxx.

52  {
53 
54  ATH_MSG_DEBUG("in initialize()");
55 
56  // retrieve V0 tools
57  CHECK( m_v0Tools.retrieve() );
58 
59  // get the Search tool
60  CHECK( m_SearchTool.retrieve() );
61 
62  // get the PrimaryVertexRefitter tool
63  CHECK( m_pvRefitter.retrieve() );
64 
65  // Get the beam spot service
66  ATH_CHECK(m_eventInfo_key.initialize());
67 
68 
69  ATH_CHECK(m_outputVtxContainerName.initialize());
70  ATH_CHECK(m_pvContainerName.initialize());
71  ATH_CHECK(m_refPVContainerName.initialize());
72  ATH_CHECK(m_RelinkContainers.initialize());
73  ATH_CHECK(m_RelinkMuons.initialize());
74  if(m_checkCollections) ATH_CHECK(m_CollectionsToCheck.initialize());
75  return StatusCode::SUCCESS;
76 
77  }

Member Data Documentation

◆ m_checkCollections

bool DerivationFramework::Reco_Vertex::m_checkCollections
private

Definition at line 50 of file Reco_Vertex.h.

◆ m_CollectionsToCheck

SG::ReadHandleKeyArray<xAOD::VertexContainer> DerivationFramework::Reco_Vertex::m_CollectionsToCheck
private

Definition at line 51 of file Reco_Vertex.h.

◆ m_do3d

bool DerivationFramework::Reco_Vertex::m_do3d
private

Definition at line 49 of file Reco_Vertex.h.

◆ m_DoVertexType

int DerivationFramework::Reco_Vertex::m_DoVertexType
private

Definition at line 47 of file Reco_Vertex.h.

◆ m_eventInfo_key

SG::ReadHandleKey<xAOD::EventInfo> DerivationFramework::Reco_Vertex::m_eventInfo_key {this, "EventInfo", "EventInfo", "Input event information"}
private

Definition at line 39 of file Reco_Vertex.h.

◆ m_outputVtxContainerName

SG::WriteHandleKey<xAOD::VertexContainer> DerivationFramework::Reco_Vertex::m_outputVtxContainerName
private

job options

Definition at line 42 of file Reco_Vertex.h.

◆ m_PV_max

int DerivationFramework::Reco_Vertex::m_PV_max
private

Definition at line 46 of file Reco_Vertex.h.

◆ m_PV_minNTracks

size_t DerivationFramework::Reco_Vertex::m_PV_minNTracks
private

Definition at line 48 of file Reco_Vertex.h.

◆ m_pvContainerName

SG::ReadHandleKey<xAOD::VertexContainer> DerivationFramework::Reco_Vertex::m_pvContainerName
private

Definition at line 43 of file Reco_Vertex.h.

◆ m_pvRefitter

ToolHandle<Analysis::PrimaryVertexRefitter> DerivationFramework::Reco_Vertex::m_pvRefitter
private

Definition at line 38 of file Reco_Vertex.h.

◆ m_refitPV

bool DerivationFramework::Reco_Vertex::m_refitPV
private

Definition at line 45 of file Reco_Vertex.h.

◆ m_refPVContainerName

SG::WriteHandleKey<xAOD::VertexContainer> DerivationFramework::Reco_Vertex::m_refPVContainerName
private

Definition at line 44 of file Reco_Vertex.h.

◆ m_RelinkContainers

SG::ReadHandleKeyArray<xAOD::TrackParticleContainer> DerivationFramework::Reco_Vertex::m_RelinkContainers {this, "RelinkTracks", {}, "Track Containers if they need to be relinked through indirect use" }
private

Definition at line 52 of file Reco_Vertex.h.

◆ m_RelinkMuons

SG::ReadHandleKeyArray<xAOD::MuonContainer> DerivationFramework::Reco_Vertex::m_RelinkMuons {this, "RelinkMuons", {}, "Muon Containers if they need to be relinked through indirect use" }
private

Definition at line 53 of file Reco_Vertex.h.

◆ m_SearchTool

ToolHandle<Analysis::ICandidateSearch> DerivationFramework::Reco_Vertex::m_SearchTool
private

Definition at line 37 of file Reco_Vertex.h.

◆ m_v0Tools

ToolHandle<Trk::V0Tools> DerivationFramework::Reco_Vertex::m_v0Tools
private

tools

Definition at line 36 of file Reco_Vertex.h.

The documentation for this class was generated from the following files:
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
xAOD::VertexAuxContainer_v1
Temporary container used until we have I/O for AuxStoreInternal.
Definition: VertexAuxContainer_v1.h:32
DerivationFramework::Reco_Vertex::m_eventInfo_key
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfo_key
Definition: Reco_Vertex.h:39
Analysis::JpsiUpsilonCommon::RelinkVertexMuons
static void RelinkVertexMuons(const std::vector< const xAOD::MuonContainer * > &muoncols, xAOD::Vertex *vtx)
Definition: JpsiUpsilonCommon.cxx:148
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
DerivationFramework::Reco_Vertex::m_checkCollections
bool m_checkCollections
Definition: Reco_Vertex.h:50
DerivationFramework::Reco_Vertex::m_RelinkContainers
SG::ReadHandleKeyArray< xAOD::TrackParticleContainer > m_RelinkContainers
Definition: Reco_Vertex.h:52
LArG4FSStartPointFilter.evt
evt
Definition: LArG4FSStartPointFilter.py:42
DerivationFramework::Reco_Vertex::m_SearchTool
ToolHandle< Analysis::ICandidateSearch > m_SearchTool
Definition: Reco_Vertex.h:37
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
DerivationFramework::Reco_Vertex::m_outputVtxContainerName
SG::WriteHandleKey< xAOD::VertexContainer > m_outputVtxContainerName
job options
Definition: Reco_Vertex.h:42
DerivationFramework::Reco_Vertex::m_v0Tools
ToolHandle< Trk::V0Tools > m_v0Tools
tools
Definition: Reco_Vertex.h:36
DerivationFramework::Reco_Vertex::m_PV_minNTracks
size_t m_PV_minNTracks
Definition: Reco_Vertex.h:48
runBeamSpotCalibration.helper
helper
Definition: runBeamSpotCalibration.py:115
DerivationFramework::Reco_Vertex::m_pvContainerName
SG::ReadHandleKey< xAOD::VertexContainer > m_pvContainerName
Definition: Reco_Vertex.h:43
DerivationFramework::Reco_Vertex::m_CollectionsToCheck
SG::ReadHandleKeyArray< xAOD::VertexContainer > m_CollectionsToCheck
Definition: Reco_Vertex.h:51
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
DerivationFramework::Reco_Vertex::m_refitPV
bool m_refitPV
Definition: Reco_Vertex.h:45
beamspotman.n
n
Definition: beamspotman.py:727
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
DerivationFramework::Reco_Vertex::m_DoVertexType
int m_DoVertexType
Definition: Reco_Vertex.h:47
TRT_PAI_gasdata::SC
const float SC[NC]
Cross sections for Carbon.
Definition: TRT_PAI_gasdata.h:255
CHECK
#define CHECK(...)
Evaluate an expression and check for errors.
Definition: Control/AthenaKernel/AthenaKernel/errorcheck.h:422
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
DataVector
Derived DataVector<T>.
Definition: DataVector.h:795
Analysis::JpsiUpsilonCommon::RelinkVertexTracks
static void RelinkVertexTracks(const std::vector< const xAOD::TrackParticleContainer * > &trkcols, xAOD::Vertex *vtx)
Definition: JpsiUpsilonCommon.cxx:126
DerivationFramework::Reco_Vertex::m_do3d
bool m_do3d
Definition: Reco_Vertex.h:49
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:73
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
DerivationFramework::Reco_Vertex::m_RelinkMuons
SG::ReadHandleKeyArray< xAOD::MuonContainer > m_RelinkMuons
Definition: Reco_Vertex.h:53
Analysis::JpsiUpsilonCommon
Definition: JpsiUpsilonCommon.h:39
DerivationFramework::Reco_Vertex::m_PV_max
int m_PV_max
Definition: Reco_Vertex.h:46
DerivationFramework::Reco_Vertex::m_pvRefitter
ToolHandle< Analysis::PrimaryVertexRefitter > m_pvRefitter
Definition: Reco_Vertex.h:38
DerivationFramework::Reco_Vertex::m_refPVContainerName
SG::WriteHandleKey< xAOD::VertexContainer > m_refPVContainerName
Definition: Reco_Vertex.h:44
str
Definition: BTagTrackIpAccessor.cxx:11
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
Generated on Sat Oct 25 2025 21:52:56 for ATLAS Offline Software by   doxygen 1.8.18