ATLAS Offline Software
Loading...
Searching...
No Matches
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::V0Toolsm_v0Tools
 tools
ToolHandle< Analysis::ICandidateSearchm_SearchTool
ToolHandle< Analysis::PrimaryVertexRefitterm_pvRefitter
SG::ReadHandleKey< xAOD::EventInfom_eventInfo_key {this, "EventInfo", "EventInfo", "Input event information"}
SG::WriteHandleKey< xAOD::VertexContainerm_outputVtxContainerName
 job options
SG::ReadHandleKey< xAOD::VertexContainerm_pvContainerName
SG::WriteHandleKey< xAOD::VertexContainerm_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::VertexContainerm_CollectionsToCheck
SG::ReadHandleKeyArray< xAOD::TrackParticleContainerm_RelinkContainers {this, "RelinkTracks", {}, "Track Containers if they need to be relinked through indirect use" }
SG::ReadHandleKeyArray< xAOD::MuonContainerm_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 }
ToolHandle< Analysis::ICandidateSearch > m_SearchTool
Definition Reco_Vertex.h:37
SG::WriteHandleKey< xAOD::VertexContainer > m_refPVContainerName
Definition Reco_Vertex.h:44
ToolHandle< Trk::V0Tools > m_v0Tools
tools
Definition Reco_Vertex.h:36
SG::ReadHandleKey< xAOD::VertexContainer > m_pvContainerName
Definition Reco_Vertex.h:43
ToolHandle< Analysis::PrimaryVertexRefitter > m_pvRefitter
Definition Reco_Vertex.h:38
SG::WriteHandleKey< xAOD::VertexContainer > m_outputVtxContainerName
job options
Definition Reco_Vertex.h:42
SG::ReadHandleKeyArray< xAOD::VertexContainer > m_CollectionsToCheck
Definition Reco_Vertex.h:51

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;
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{
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{
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 }
#define ATH_CHECK
Evaluate an expression and check for errors.
#define ATH_MSG_ERROR(x)
#define ATH_MSG_FATAL(x)
#define ATH_MSG_WARNING(x)
#define ATH_MSG_DEBUG(x)
#define CHECK(...)
Evaluate an expression and check for errors.
static void RelinkVertexMuons(const std::vector< const xAOD::MuonContainer * > &muoncols, xAOD::Vertex *vtx)
static void RelinkVertexTracks(const std::vector< const xAOD::TrackParticleContainer * > &trkcols, xAOD::Vertex *vtx)
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfo_key
Definition Reco_Vertex.h:39
SG::ReadHandleKeyArray< xAOD::TrackParticleContainer > m_RelinkContainers
Definition Reco_Vertex.h:52
SG::ReadHandleKeyArray< xAOD::MuonContainer > m_RelinkMuons
Definition Reco_Vertex.h:53
::StatusCode StatusCode
StatusCode definition for legacy code.
const float SC[NC]
Cross sections for Carbon.
VertexAuxContainer_v1 VertexAuxContainer
Definition of the current jet auxiliary container.
VertexContainer_v1 VertexContainer
Definition of the current "Vertex container version".
Vertex_v1 Vertex
Define the latest version of the vertex class.

◆ 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
70 ATH_CHECK(m_pvContainerName.initialize());
71 ATH_CHECK(m_refPVContainerName.initialize());
72 ATH_CHECK(m_RelinkContainers.initialize());
73 ATH_CHECK(m_RelinkMuons.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.

39{this, "EventInfo", "EventInfo", "Input event information"};

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

52{this, "RelinkTracks", {}, "Track Containers if they need to be relinked through indirect use" };

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

53{this, "RelinkMuons", {}, "Muon Containers if they need to be relinked through indirect use" };

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