ATLAS Offline Software
Loading...
Searching...
No Matches
BPhysPVTools.cxx
Go to the documentation of this file.
1/*
2 Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
3*/
4
5#include "BPhysPVTools.h"
6#include "xAODTracking/VertexContainer.h"
7#include "TrkVertexAnalysisUtils/V0Tools.h"
8#include "xAODBPhys/BPhysHelper.h"
9#include "JpsiUpsilonTools/PrimaryVertexRefitter.h"
10#include "TVector3.h"
11#include "xAODEventInfo/EventInfo.h"
12
13#include <limits>
14#include <iostream>
15#include <cmath>
16using namespace std;
17
18DerivationFramework::BPhysPVTools::BPhysPVTools(const Trk::V0Tools *v0Tools) :
19 AthMessaging("BPhysPVTools"),
20 m_v0Tools(v0Tools), m_EvtData(nullptr), m_PV_minNTracks(0),
21 m_3dCalc(false)
22{
23}
24
25DerivationFramework::BPhysPVTools::BPhysPVTools(const Trk::V0Tools *v0Tools, const xAOD::EventInfo *eventInfo) :
26 AthMessaging("BPhysPVTools"),
27 m_v0Tools(v0Tools), m_EvtData(eventInfo), m_PV_minNTracks(0),
28 m_3dCalc(false)
29{
30}
31
32void DerivationFramework::BPhysPVTools::FillBPhysHelper(xAOD::BPhysHelper &vtx,
33 const xAOD::Vertex* PV, const xAOD::VertexContainer* PvContainer,
34 xAOD::BPhysHelper::pv_type pvtype, int refitCode) const {
35
36 BPHYS_CHECK( vtx.setPv ( PV, PvContainer, pvtype ) );
37
38 // cout << "BPhysPVTools::FillBPhysHelper for pvtype = " << pvtype << endl;
39
40 // set variables calculated from PV
41 if(m_3dCalc){
42 BPHYS_CHECK( vtx.setLxyz ( m_v0Tools->lxyz (vtx.vtx(), PV), pvtype ) );
43 BPHYS_CHECK( vtx.setLxyzErr ( m_v0Tools->lxyzError (vtx.vtx(), PV), pvtype ) );
44 }
45 BPHYS_CHECK( vtx.setLxy ( m_v0Tools->lxy (vtx.vtx(), PV), pvtype ) );
46 BPHYS_CHECK( vtx.setLxyErr ( m_v0Tools->lxyError (vtx.vtx(), PV), pvtype ) );
47 BPHYS_CHECK( vtx.setA0 ( m_v0Tools->a0 (vtx.vtx(), PV), pvtype ) );
48 BPHYS_CHECK( vtx.setA0Err ( m_v0Tools->a0Error (vtx.vtx(), PV), pvtype ) );
49 BPHYS_CHECK( vtx.setA0xy ( m_v0Tools->a0xy (vtx.vtx(), PV), pvtype ) );
50 BPHYS_CHECK( vtx.setA0xyErr( m_v0Tools->a0xyError (vtx.vtx(), PV), pvtype ) );
51 BPHYS_CHECK( vtx.setZ0 ( m_v0Tools->a0z (vtx.vtx(), PV), pvtype ) );
52 BPHYS_CHECK( vtx.setZ0Err ( m_v0Tools->a0zError (vtx.vtx(), PV), pvtype ) );
53 BPHYS_CHECK( vtx.setRefitPVStatus ( refitCode, pvtype ) );
54
55}
56
57void DerivationFramework::BPhysPVTools::FillBPhysHelperNULL(xAOD::BPhysHelper &vtx,
58 const xAOD::VertexContainer* PvContainer,
59 xAOD::BPhysHelper::pv_type pvtype, bool do3d) const {
60
61 const xAOD::Vertex* PV = nullptr;
62 BPHYS_CHECK( vtx.setPv ( PV, PvContainer, pvtype ) );
63 constexpr float errConst = std::numeric_limits<float>::lowest();
64 // set variables claculated from PV
65 if(do3d){
66 BPHYS_CHECK( vtx.setLxyz ( errConst, pvtype ) );
67 BPHYS_CHECK( vtx.setLxyzErr ( errConst, pvtype ) );
68 }
69 BPHYS_CHECK( vtx.setLxy ( errConst, pvtype ) );
70 BPHYS_CHECK( vtx.setLxyErr ( errConst, pvtype ) );
71 BPHYS_CHECK( vtx.setA0 ( errConst, pvtype ) );
72 BPHYS_CHECK( vtx.setA0Err ( errConst, pvtype ) );
73 BPHYS_CHECK( vtx.setA0xy ( errConst, pvtype ) );
74 BPHYS_CHECK( vtx.setA0xyErr( errConst, pvtype ) );
75 BPHYS_CHECK( vtx.setZ0 ( errConst, pvtype ) );
76 BPHYS_CHECK( vtx.setZ0Err ( errConst, pvtype ) );
77 BPHYS_CHECK( vtx.setRefitPVStatus ( 0, pvtype ) );
78}
79
80size_t DerivationFramework::BPhysPVTools::FindLowZIndex(const xAOD::BPhysHelper &Obj,
81 const std::vector<const xAOD::Vertex*> &PVlist,
82 const size_t PV_minNTracks) const {
83 size_t lowZ = 0;
84 if(PVlist.empty()) {
85 lowZ=std::numeric_limits<std::size_t>::max();
86 return lowZ;
87 }
88 size_t size = PVlist.size();
89 double lowA0zcalc = fabs(m_v0Tools->a0z (Obj.vtx(), PVlist[0]));
90 for(size_t i =1; i<size; i++) {
91 if ( PVlist[i]->nTrackParticles() >= PV_minNTracks ) {
92 double a0z = fabs(m_v0Tools->a0z(Obj.vtx(), PVlist[i]));
93 if(a0z < lowA0zcalc) {
94 lowA0zcalc = a0z;
95 lowZ =i;
96 }
97 }
98 }
99 return lowZ;
100}
101
102void DerivationFramework::BPhysPVTools::DecorateWithDummyVertex(xAOD::VertexContainer* vtxContainer,
103 const xAOD::VertexContainer* pvContainer, const xAOD::Vertex* Dummy,
104 int DoVertexType, const bool SetOrignal) const {
105 const bool doPt = (DoVertexType & 1) != 0;
106 const bool doA0 = (DoVertexType & 2) != 0;
107 const bool doZ0 = (DoVertexType & 4) != 0;
108 const bool doZ0BA = (DoVertexType & 8) != 0;
109
110 xAOD::VertexContainer::iterator vtxItr = vtxContainer->begin();
111 for(; vtxItr!=vtxContainer->end(); ++vtxItr) {
112 xAOD::BPhysHelper vtx(*vtxItr);
113
114 // 1) pT error
115 double ptErr = m_v0Tools->pTError( vtx.vtx() );
116 BPHYS_CHECK( vtx.setPtErr(ptErr) );
117 if(doPt) {
118 // 2.a) the first PV with the largest sum pT.
119 FillBPhysHelper(vtx, Dummy, pvContainer, xAOD::BPhysHelper::PV_MAX_SUM_PT2, 0);
120 if(SetOrignal) vtx.setOrigPv(Dummy, pvContainer, xAOD::BPhysHelper::PV_MAX_SUM_PT2);
121 }
122
123 if(doA0) {
124 // 2.b) the closest in 3D:
125 FillBPhysHelper(vtx, Dummy, pvContainer, xAOD::BPhysHelper::PV_MIN_A0, 0);
126 if(SetOrignal) vtx.setOrigPv(Dummy, pvContainer, xAOD::BPhysHelper::PV_MIN_A0);
127 }
128
129 if(doZ0) {
130 FillBPhysHelper(vtx, Dummy, pvContainer, xAOD::BPhysHelper::PV_MIN_Z0, 0);
131 if(SetOrignal) vtx.setOrigPv(Dummy, pvContainer, xAOD::BPhysHelper::PV_MIN_Z0);
132 }
133
134 if(doZ0BA) {
135 FillBPhysHelper(vtx, Dummy, pvContainer, xAOD::BPhysHelper::PV_MIN_Z0_BA, 0);
136 if(SetOrignal) vtx.setOrigPv(Dummy, pvContainer, xAOD::BPhysHelper::PV_MIN_Z0_BA);
137 }
138 }
139}
140
141void DerivationFramework::BPhysPVTools::DecorateWithNULL(xAOD::VertexContainer* vtxContainer,
142 const xAOD::VertexContainer* pvContainer, int DoVertexType) const {
143 const bool doPt = (DoVertexType & 1) != 0;
144 const bool doA0 = (DoVertexType & 2) != 0;
145 const bool doZ0 = (DoVertexType & 4) != 0;
146 const bool doZ0BA = (DoVertexType & 8) != 0;
147 xAOD::VertexContainer::iterator vtxItr = vtxContainer->begin();
148 for(; vtxItr!=vtxContainer->end(); ++vtxItr) {
149 xAOD::BPhysHelper vtx(*vtxItr);
150
151 // 1) pT error
152 double ptErr = m_v0Tools->pTError( vtx.vtx() );
153 BPHYS_CHECK( vtx.setPtErr(ptErr) );
154 if(doPt) {
155 // 2.a) the first PV with the largest sum pT.
156 FillBPhysHelperNULL(vtx, pvContainer, xAOD::BPhysHelper::PV_MAX_SUM_PT2, m_3dCalc);
157 }
158
159 if(doA0) {
160 // 2.b) the closest in 3D:
161 FillBPhysHelperNULL(vtx, pvContainer, xAOD::BPhysHelper::PV_MIN_A0, m_3dCalc);
162 }
163
164 if(doZ0) {
165 FillBPhysHelperNULL(vtx, pvContainer, xAOD::BPhysHelper::PV_MIN_Z0, m_3dCalc);
166 }
167 if(doZ0BA) {
168 FillBPhysHelperNULL(vtx, pvContainer, xAOD::BPhysHelper::PV_MIN_Z0_BA, m_3dCalc);
169 }
170 }
171}
172
173StatusCode DerivationFramework::BPhysPVTools::FillCandExistingVertices(xAOD::VertexContainer* vtxContainer,
174 const xAOD::VertexContainer* pvContainer, int DoVertexType) {
175
176
177
178 //----------------------------------------------------
179 // decorate the vertex
180 //----------------------------------------------------
181 // loop over candidates -- Don't apply PV_minNTracks requirement here
182 // because it may result in exclusion of the high-pt PV.
183 const std::vector<const xAOD::Vertex*> GoodPVs = GetGoodPV(pvContainer);
184
185
186 if(GoodPVs.empty() == false) {
187
188 const bool doPt = (DoVertexType & 1) != 0;
189 const bool doA0 = (DoVertexType & 2) != 0;
190 const bool doZ0 = (DoVertexType & 4) != 0;
191 const bool doZ0BA = (DoVertexType & 8) != 0;
192
193 xAOD::VertexContainer::iterator vtxItr = vtxContainer->begin();
194 for(; vtxItr!=vtxContainer->end(); ++vtxItr) {
195 xAOD::BPhysHelper vtx(*vtxItr);
196
197 // 1) pT error
198 double ptErr = m_v0Tools->pTError( vtx.vtx() );
199 BPHYS_CHECK( vtx.setPtErr(ptErr) );
200
201 // 2) refit the primary vertex and set the related decorations.
202 if(doPt) {
203 size_t highPtindex = FindHighPtIndex(GoodPVs); //Should be 0 in PV ordering
204 // 2.a) the first PV with the largest sum pT.
205 FillBPhysHelper(vtx, GoodPVs[highPtindex], pvContainer, xAOD::BPhysHelper::PV_MAX_SUM_PT2, 0);
206 }
207
208 if(doA0) {
209 // 2.b) the closest in 3D:
210 size_t lowA0 = FindLowA0Index(vtx, GoodPVs, m_PV_minNTracks);
211 FillBPhysHelper(vtx, GoodPVs[lowA0], pvContainer, xAOD::BPhysHelper::PV_MIN_A0, 0);
212 }
213
214 if(doZ0) {
215 size_t lowZ = FindLowZIndex(vtx, GoodPVs, m_PV_minNTracks);
216 FillBPhysHelper(vtx, GoodPVs[lowZ], pvContainer, xAOD::BPhysHelper::PV_MIN_Z0, 0);
217 }
218
219 if(doZ0BA) {
220 size_t lowZBA = FindLowZ0BAIndex(vtx, GoodPVs, m_PV_minNTracks);
221 if ( lowZBA < GoodPVs.size() ) { // safety against vector index out-of-bounds
222 FillBPhysHelper(vtx, GoodPVs[lowZBA], pvContainer, xAOD::BPhysHelper::PV_MIN_Z0_BA, 0);
223 } else {
224 // nothing found -- fill nullptr
225 FillBPhysHelperNULL(vtx, pvContainer, xAOD::BPhysHelper::PV_MIN_Z0_BA, m_3dCalc);
226 }
227 }
228
229 }// end of loop over vertices
230 } //end of check for vertices
231 else {
232 // cout << "Warning: DerivationFramework::BPhysPVTools::FillCandExistingVertices No Primary Vertices Found trying to decorate wilth dummy \n";
233 if(pvContainer->empty()) return StatusCode::FAILURE;
234 const xAOD::Vertex* dummy = pvContainer->at(0); //No good vertices so last vertex must be dummy
235 DecorateWithDummyVertex(vtxContainer, pvContainer, dummy, DoVertexType, false);
236 }
237 return StatusCode::SUCCESS;
238}
239
240
241StatusCode DerivationFramework::BPhysPVTools::FillCandwithRefittedVertices(xAOD::VertexContainer* vtxContainer,
242 const xAOD::VertexContainer* pvContainer, xAOD::VertexContainer* refPvContainer,
243 const Analysis::PrimaryVertexRefitter *pvRefitter, size_t in_PV_max, int DoVertexType) {
244
245
246 //----------------------------------------------------
247 // decorate the vertex
248 //----------------------------------------------------
249 // loop over candidates -- Don't apply PV_minNTracks requirement here
250 // because it may result in exclusion of the high-pt PV.
251 std::vector<const xAOD::Vertex*> goodPrimaryVertices = GetGoodPV(pvContainer);
252
253 /*
254 cout << "BPhysPVTools::FillCandwithRefittedVertices: #PVs: all: "
255 << pvContainer->size() << " ref: " << refPvContainer->size()
256 << " good: " << goodPrimaryVertices.size()
257 << " PV_minNTracks: " << m_PV_minNTracks << endl;
258 */
259 if(goodPrimaryVertices.empty() == false) {
260
261 size_t pVmax =std::min(in_PV_max, goodPrimaryVertices.size());
262 std::vector<const xAOD::Vertex*> refPVvertexes;
263 std::vector<xAOD::Vertex*> refPVvertexes_toDelete;
264 std::vector<int> exitCode;
265 refPVvertexes.reserve(pVmax);
266 refPVvertexes_toDelete.reserve(pVmax);
267 exitCode.reserve(pVmax);
268
269 bool doPt = (DoVertexType & 1) != 0;
270 bool doA0 = (DoVertexType & 2) != 0;
271 bool doZ0 = (DoVertexType & 4) != 0;
272 bool doZ0BA = (DoVertexType & 8) != 0;
273
274 xAOD::VertexContainer::iterator vtxItr = vtxContainer->begin();
275 for(; vtxItr!=vtxContainer->end(); ++vtxItr) {
276 xAOD::BPhysHelper vtx(*vtxItr);
277
278 // 1) pT error
279 double ptErr = m_v0Tools->pTError( vtx.vtx() );
280 BPHYS_CHECK( vtx.setPtErr(ptErr) );
281
282 for(size_t i =0; i < pVmax ; i++) {
283 const xAOD::Vertex* oldPV = goodPrimaryVertices.at(i);
284 //when set to false this will return nullptr when a new vertex is not required
285 int exit =0;
286 xAOD::Vertex* refPV = pvRefitter->refitVertex(oldPV, vtx.vtx(), false, &exit);
287 exitCode.push_back(exit);
288 //I want positioning to match the goodPrimaryVertices
289 if(refPV == nullptr){
290 refPVvertexes.push_back(oldPV);
291 refPVvertexes_toDelete.push_back(nullptr);
292 }else{
293 refPVvertexes.push_back(refPV);
294 refPVvertexes_toDelete.push_back(refPV);
295 }
296 }
297
298 // 2) refit the primary vertex and set the related decorations.
299
300 size_t highPtindex = doPt ? FindHighPtIndex(refPVvertexes) : 9999999; //Should be 0 in PV ordering
301 size_t lowA0 = doA0 ?
302 FindLowA0Index(vtx, refPVvertexes, m_PV_minNTracks) : 9999998;
303 size_t lowZ = doZ0 ?
304 FindLowZIndex(vtx, refPVvertexes, m_PV_minNTracks) : 9999997;
305 size_t lowZBA = doZ0BA ?
306 FindLowZ0BAIndex(vtx, refPVvertexes, m_PV_minNTracks) : 9999996;
307 /*
308 cout << "BPhysPVTools::FillCandwithRefittedVertices: in_PV_max/pVMax = "
309 << in_PV_max << ", " << pVmax << endl;
310 cout << "BPhysPVTools::FillCandwithRefittedVertices: m_PV_minNTracks = "
311 << m_PV_minNTracks << endl;
312 cout << "BPhysPVTools::FillCandwithRefittedVertices: hPt,lowA0/Z/ZBA = "
313 << highPtindex << ", "
314 << lowA0 << ", " << lowZ << ", " << lowZBA << " "
315 << (lowA0 != lowZ ? "1!" : " ")
316 << (lowA0 != lowZBA ? "2!" : " ")
317 << (lowZ != lowZBA ? "3!" : " ")
318 << (highPtindex != lowA0 ? "4!" : " ")
319 << (highPtindex != lowZ ? "5!" : " ")
320 << (highPtindex != lowZBA ? "6!" : " ")
321 << endl;
322 */
323 if(doPt) {
324 //Choose old PV container if not refitted
325 const xAOD::VertexContainer* ParentContainer =
326 (refPVvertexes_toDelete.at(highPtindex)) ? refPvContainer : pvContainer;
327 if(ParentContainer == refPvContainer) //if refitted add to refitted container
328 refPvContainer->push_back(refPVvertexes_toDelete.at(highPtindex)); // store the new vertex
329
330 FillBPhysHelper(vtx, refPVvertexes[highPtindex],
331 ParentContainer, xAOD::BPhysHelper::PV_MAX_SUM_PT2, exitCode[highPtindex]);
332 vtx.setOrigPv(goodPrimaryVertices[highPtindex], pvContainer, xAOD::BPhysHelper::PV_MAX_SUM_PT2);
333 }
334
335 if(doA0) {
336 const xAOD::VertexContainer* ParentContainer =
337 (refPVvertexes_toDelete.at(lowA0)) ? refPvContainer : pvContainer;
338 if(ParentContainer == refPvContainer && highPtindex!=lowA0)
339 refPvContainer->push_back(refPVvertexes_toDelete.at(lowA0)); // store the new vertex
340
341 FillBPhysHelper(vtx, refPVvertexes[lowA0],
342 ParentContainer, xAOD::BPhysHelper::PV_MIN_A0, exitCode[lowA0]);
343 vtx.setOrigPv(goodPrimaryVertices[lowA0], pvContainer, xAOD::BPhysHelper::PV_MIN_A0);
344 }
345
346
347 // 2.c) the closest in Z:
348 if(doZ0) {
349
350 const xAOD::VertexContainer* ParentContainer =
351 (refPVvertexes_toDelete.at(lowZ)) ? refPvContainer : pvContainer;
352 if(ParentContainer == refPvContainer && highPtindex!=lowZ && lowZ!=lowA0)
353 refPvContainer->push_back(refPVvertexes_toDelete.at(lowZ)); // store the new vertex
354
355 FillBPhysHelper(vtx, refPVvertexes[lowZ],
356 ParentContainer, xAOD::BPhysHelper::PV_MIN_Z0, exitCode[lowZ]);
357 vtx.setOrigPv(goodPrimaryVertices[lowZ], pvContainer, xAOD::BPhysHelper::PV_MIN_Z0);
358 }
359
360 // 2.d) the closest in Z (DOCA w.r.t. beam axis):
361 if (doZ0BA) {
362 if ( lowZBA < pVmax ) { // safety for vector indices
363 const xAOD::VertexContainer* ParentContainer =
364 (refPVvertexes_toDelete.at(lowZBA)) ?
365 refPvContainer : pvContainer;
366 if (ParentContainer == refPvContainer && highPtindex!=lowZBA
367 && lowZBA!=lowA0 && lowZBA != lowZ) {
368 // store the new vertex
369 refPvContainer->push_back(refPVvertexes_toDelete.at(lowZBA));
370 }
371 FillBPhysHelper(vtx, refPVvertexes[lowZBA],
372 ParentContainer, xAOD::BPhysHelper::PV_MIN_Z0_BA,
373 exitCode[lowZBA]);
374 vtx.setOrigPv(goodPrimaryVertices[lowZBA], pvContainer,
375 xAOD::BPhysHelper::PV_MIN_Z0_BA);
376 } else {
377 // nothing found -- fill nullptr
378 FillBPhysHelperNULL(vtx, pvContainer, xAOD::BPhysHelper::PV_MIN_Z0_BA, m_3dCalc);
379 // nothing found -- fill dummy vertex (type-0 vertex)
380 // if(pvContainer->empty()) return StatusCode::FAILURE;
381 // const xAOD::Vertex* dummy = pvContainer->at(pvContainer->size()-1); //No good vertices so last vertex must be dummy
382 // FillBPhysHelper(vtx, dummy, pvContainer, xAOD::BPhysHelper::PV_MIN_Z0_BA, 0);
383 // vtx.setOrigPv(Dummy, pvContainer, xAOD::BPhysHelper::PV_MIN_Z0_BA);
384 }
385 }
386
387 //nullptrify ptrs we want to keep so these won't get deleted
388 //"delete nullptr" is valid in C++ and does nothing so this is quicker than a lot of if statements
389 if(doPt) refPVvertexes_toDelete[highPtindex] = nullptr;
390 if(doA0) refPVvertexes_toDelete[lowA0] = nullptr;
391 if(doZ0) refPVvertexes_toDelete[lowZ] = nullptr;
392 if(doZ0BA && lowZBA < pVmax) refPVvertexes_toDelete[lowZBA] = nullptr;
393 //Loop over toDELETE container, anything that is used or was not refitted is nullptr
394 //This cleans up all extra vertices that were created and not used
395 for(const xAOD::Vertex* ptr : refPVvertexes_toDelete) {
396 delete ptr;
397 }
398 refPVvertexes.clear();// Clear lists of now dangling ptrs
399 refPVvertexes_toDelete.clear();
400 exitCode.clear();
401 } // end of loop over vertices
402
403 } else {
404// cout << "Warning: DerivationFramework::BPhysPVTools::FillCandwithRefittedVertices No Primary Vertices Found trying to decorate wilth dummy \n";
405 if(pvContainer->empty()) return StatusCode::FAILURE;
406 const xAOD::Vertex* dummy = pvContainer->at(0); //No good vertices so last vertex must be dummy
407 DecorateWithDummyVertex(vtxContainer, pvContainer, dummy, DoVertexType, true);
408 }
409
410 return StatusCode::SUCCESS;
411}
412
413size_t DerivationFramework::BPhysPVTools::FindHighPtIndex(const std::vector<const xAOD::Vertex*> &PVlist) const {
414 // it SHOULD be the first one in the collection but it shouldn't take long to do a quick check
415 for(size_t i =0; i<PVlist.size(); i++) {
416 if(PVlist[i]->vertexType() == xAOD::VxType::PriVtx) return i;
417 }
418 ATH_MSG_ERROR("High Pt Primary vertex not found - this should not happen");
419 return std::numeric_limits<std::size_t>::max(); //This should not happen
420}
421
422size_t DerivationFramework::BPhysPVTools::FindLowA0Index(const xAOD::BPhysHelper &Obj,
423 const std::vector<const xAOD::Vertex*> &PVlist,
424 const size_t PV_minNTracks) const {
425 size_t lowA0 = 0;
426 if(PVlist.empty()) {
427 lowA0=std::numeric_limits<std::size_t>::max();
428 return lowA0;
429 }
430 size_t size = PVlist.size();
431 double lowA0calc = m_v0Tools->a0(Obj.vtx(), PVlist[0]);
432 for(size_t i =1; i<size; i++) {
433 if ( PVlist[i]->nTrackParticles() >= PV_minNTracks ) {
434 double a0 = m_v0Tools->a0(Obj.vtx(), PVlist[i]);
435 if(a0 < lowA0calc) {
436 lowA0calc = a0;
437 lowA0 =i;
438 }
439 }
440 }
441 return lowA0;
442}
443
444vector<const xAOD::Vertex*> DerivationFramework::BPhysPVTools::GetGoodPV(const xAOD::VertexContainer* pvContainer) {
445 typedef xAOD::VxType::VertexType VertexType;
446 VertexType Pvtx = xAOD::VxType::PriVtx;
447 VertexType Pileupvtx = xAOD::VxType::PileUp;
448 std::vector<const xAOD::Vertex*> goodPrimaryVertices;
449 goodPrimaryVertices.reserve(pvContainer->size());
450
451 for (auto ptr = pvContainer->begin(); ptr!= pvContainer->end(); ++ptr) {
452 VertexType thistype = (*ptr)->vertexType();
453 if ( thistype == Pileupvtx || thistype == Pvtx ) {
454 goodPrimaryVertices.push_back(*ptr);
455 } else {
456// cout << "vertex type " << thistype << endl;
457 }
458 }
459 return goodPrimaryVertices;
460}
461//-----------------------------------------------------------------------------
462// added by WW:
463//
464void DerivationFramework::BPhysPVTools::SetMinNTracksInPV(size_t PV_minNTracks)
465{
466
467 m_PV_minNTracks = PV_minNTracks;
468}
469//-----------------------------------------------------------------------------
470// added by WW:
471//
472Amg::Vector3D DerivationFramework::BPhysPVTools::GetBeamSpot() const {
473
474 if(m_EvtData) return Amg::Vector3D(m_EvtData->beamPosX(), m_EvtData->beamPosY(), m_EvtData->beamPosZ());
475 else {
476 static const Amg::Vector3D defaultBS(-10000.,-10000.,-10000.);
477 return defaultBS;
478 }
479}
480//-----------------------------------------------------------------------------
481// added by WW:
482//
483size_t DerivationFramework::BPhysPVTools::FindLowZ0BAIndex(xAOD::BPhysHelper &obj,
484 const std::vector<const xAOD::Vertex*> &PVlist,
485 const size_t PV_minNTracks) const {
486
487 size_t ilowZ0BA = std::numeric_limits<std::size_t>::max();
488 double lowZ0BAcalc = std::numeric_limits<double>::max();
489 for (size_t i = 0; i<PVlist.size(); ++i) {
490 if ( PVlist[i]->nTrackParticles() >= PV_minNTracks ) {
491 double z0BA = m_v0Tools->a0(obj.vtx(), PVlist[i]);
492 if (z0BA < lowZ0BAcalc) {
493 lowZ0BAcalc = z0BA;
494 ilowZ0BA = i;
495 }
496 }
497 }
498 return ilowZ0BA;
499}
500//-----------------------------------------------------------------------------
501// added by WW:
502//
503double DerivationFramework::BPhysPVTools::DistInZtoDOCA(xAOD::BPhysHelper &obj, const xAOD::Vertex* vertex) const {
504
505 Amg::Vector3D pv = vertex->position();
506 Amg::Vector3D xDOCA = DocaExtrapToBeamSpot(obj);
507 Amg::Vector3D vec = pv - xDOCA;
508 return vec.z();
509}
510//-----------------------------------------------------------------------------
511// added by WW:
512//
513Amg::Vector3D DerivationFramework::BPhysPVTools::DocaExtrapToBeamSpot(xAOD::BPhysHelper& obj) const {
514
515 Amg::Vector3D xDOCA(-99999., -99999., -99999.);
516 TVector3 totP(obj.totalP());
517 Amg::Vector3D pSV(totP.X(), totP.Y(), totP.Z());
518 Amg::Vector3D pT(pSV.x(), pSV.y(), 0.);
519 if ( pT.mag2() > 0 ) {
520 Amg::Vector3D xBS = GetBeamSpot();
521 Amg::Vector3D xSV = m_v0Tools->vtx(obj.vtx());
522 Amg::Vector3D xT(xSV.x()-xBS.x(), xSV.y()-xBS.y(), 0.);
523 xDOCA = xSV - pSV*pT.dot(xT)/pT.mag2();
524 } else {
525 ATH_MSG_WARNING("DocaExtrapToBeamSpot: pT == 0.");
526 }
527 return xDOCA;
528}
529
530void DerivationFramework::BPhysPVTools::PrepareVertexLinks(xAOD::Vertex* theResult,
531 const xAOD::TrackParticleContainer* importedTrackCollection)
532{
533 std::vector<ElementLink<DataVector<xAOD::TrackParticle> > > newLinkVector;
534 const auto &trkprtl = theResult->trackParticleLinks();
535 for(unsigned int i=0; i< trkprtl.size(); i++)
536 {
537 ElementLink<DataVector<xAOD::TrackParticle> > mylink=trkprtl[i]; //makes a copy (non-const)
538 mylink.setStorableObject(*importedTrackCollection, true);
539 newLinkVector.push_back( mylink );
540 }
541 theResult->clearTracks();
542 theResult->setTrackParticleLinks( newLinkVector );
543}
544
545
546//-----------------------------------------------------------------------------
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition AthMsgStreamMacros.h:33
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition AthMsgStreamMacros.h:32
BPhysHelper.h
: B-physics xAOD helpers.
BPHYS_CHECK
#define BPHYS_CHECK(EXP)
Useful CHECK macro.
Definition BPhysHelper.h:738
vec
std::vector< size_t > vec
Definition CombinationsGeneratorTest.cxx:9
Analysis::PrimaryVertexRefitter::refitVertex
xAOD::Vertex * refitVertex(const xAOD::Vertex *vertex, const xAOD::Vertex *excludeVertex, bool ReturnCopy=true, int *exitcode=nullptr) const
Definition PrimaryVertexRefitter.cxx:40
AthMessaging::AthMessaging
AthMessaging(IMessageSvc *msgSvc, const std::string &name)
Constructor.
Definition AthMessaging.cxx:13
DataVector::at
const T * at(size_type n) const
Access an element, as an rvalue.
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
DataVector< xAOD::Vertex_v1 >::iterator
DataModel_detail::iterator< DataVector > iterator
Definition DataVector.h:842
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
DataVector::empty
bool empty() const noexcept
Returns true if the collection is empty.
DerivationFramework::BPhysPVTools::m_EvtData
const xAOD::EventInfo * m_EvtData
Definition BPhysPVTools.h:29
DerivationFramework::BPhysPVTools::FindLowZ0BAIndex
size_t FindLowZ0BAIndex(xAOD::BPhysHelper &obj, const std::vector< const xAOD::Vertex * > &PVlist, const size_t PV_minNTracks=0) const
Find the index for the PV with the lowest distance in z of the SV's DOCA point w.r....
Definition BPhysPVTools.cxx:483
DerivationFramework::BPhysPVTools::m_PV_minNTracks
size_t m_PV_minNTracks
minimum number of tracks required in PVs considered
Definition BPhysPVTools.h:32
DerivationFramework::BPhysPVTools::DistInZtoDOCA
double DistInZtoDOCA(xAOD::BPhysHelper &obj, const xAOD::Vertex *vertex) const
Calculate the distance along z axis between the PV and SV's DOCA point w.r.t.
Definition BPhysPVTools.cxx:503
DerivationFramework::BPhysPVTools::DocaExtrapToBeamSpot
Amg::Vector3D DocaExtrapToBeamSpot(xAOD::BPhysHelper &obj) const
Point of DOCA w.r.t.
Definition BPhysPVTools.cxx:513
DerivationFramework::BPhysPVTools::FindLowZIndex
size_t FindLowZIndex(const xAOD::BPhysHelper &Obj, const std::vector< const xAOD::Vertex * > &PVlist, const size_t PV_minNTracks=0) const
Returns the index integer of the vertex with the lowest Z in relation to the given vertex.
Definition BPhysPVTools.cxx:80
DerivationFramework::BPhysPVTools::BPhysPVTools
BPhysPVTools(const Trk::V0Tools *v0Tools)
Definition BPhysPVTools.cxx:18
DerivationFramework::BPhysPVTools::FillCandExistingVertices
StatusCode FillCandExistingVertices(xAOD::VertexContainer *vtxContainer, const xAOD::VertexContainer *pvContainer, int DoVertexType)
Definition BPhysPVTools.cxx:173
DerivationFramework::BPhysPVTools::FindLowA0Index
size_t FindLowA0Index(const xAOD::BPhysHelper &Obj, const std::vector< const xAOD::Vertex * > &PVlist, const size_t PV_minNTracks=0) const
Returns the index integer of the vertex with the lowest A0 in relation to the given vertex.
Definition BPhysPVTools.cxx:422
DerivationFramework::BPhysPVTools::FillCandwithRefittedVertices
StatusCode FillCandwithRefittedVertices(xAOD::VertexContainer *vtxContainer, const xAOD::VertexContainer *pvContainer, xAOD::VertexContainer *refPvContainer, const Analysis::PrimaryVertexRefitter *, size_t in_PV_max, int DoVertexType)
Definition BPhysPVTools.cxx:241
DerivationFramework::BPhysPVTools::FillBPhysHelperNULL
void FillBPhysHelperNULL(xAOD::BPhysHelper &vtx, const xAOD::VertexContainer *PvContainer, xAOD::BPhysHelper::pv_type pvtype, bool do3d=false) const
Definition BPhysPVTools.cxx:57
DerivationFramework::BPhysPVTools::m_v0Tools
const Trk::V0Tools * m_v0Tools
Definition BPhysPVTools.h:28
DerivationFramework::BPhysPVTools::GetBeamSpot
Amg::Vector3D GetBeamSpot() const
Get the current beamspot position either from cache or from BeamCondSvc.
Definition BPhysPVTools.cxx:472
DerivationFramework::BPhysPVTools::SetMinNTracksInPV
void SetMinNTracksInPV(size_t PV_minNTracks)
Set the minimum number of tracks required for primary vertices to be considered for primary vertex as...
Definition BPhysPVTools.cxx:464
DerivationFramework::BPhysPVTools::DecorateWithNULL
void DecorateWithNULL(xAOD::VertexContainer *vtxContainer, const xAOD::VertexContainer *pvContainer, int DoVertexType) const
Definition BPhysPVTools.cxx:141
DerivationFramework::BPhysPVTools::PrepareVertexLinks
static void PrepareVertexLinks(xAOD::Vertex *theResult, const xAOD::TrackParticleContainer *importedTrackCollection)
Definition BPhysPVTools.cxx:530
DerivationFramework::BPhysPVTools::FindHighPtIndex
size_t FindHighPtIndex(const std::vector< const xAOD::Vertex * > &PVlist) const
Definition BPhysPVTools.cxx:413
DerivationFramework::BPhysPVTools::FillBPhysHelper
void FillBPhysHelper(xAOD::BPhysHelper &vtx, const xAOD::Vertex *refPV, const xAOD::VertexContainer *refPvContainer, xAOD::BPhysHelper::pv_type pvtype, int) const
Fills the BPhysHelper object with the standard parameters.
Definition BPhysPVTools.cxx:32
DerivationFramework::BPhysPVTools::DecorateWithDummyVertex
void DecorateWithDummyVertex(xAOD::VertexContainer *vtxContainer, const xAOD::VertexContainer *pvContainer, const xAOD::Vertex *Dummy, int DoVertexType, bool SetOrignal) const
Definition BPhysPVTools.cxx:102
DerivationFramework::BPhysPVTools::GetGoodPV
static std::vector< const xAOD::Vertex * > GetGoodPV(const xAOD::VertexContainer *pvContainer)
Static method call with DerivationFramework::BPhysDerHelpers::GetGoodPV Returns a std::vector contain...
Definition BPhysPVTools.cxx:444
xAOD::BPhysHelper::setPtErr
bool setPtErr(const float val)
Set pT error.
Definition BPhysHelper.cxx:436
xAOD::BPhysHelper::setZ0
float setZ0(const float val, const pv_type vertexType=BPhysHelper::PV_MIN_A0)
longitudinal impact parameter
Definition BPhysHelper.cxx:1067
xAOD::BPhysHelper::setLxyErr
bool setLxyErr(const float val, const pv_type vertexType=BPhysHelper::PV_MIN_A0)
its error
Definition BPhysHelper.cxx:899
xAOD::BPhysHelper::setLxy
bool setLxy(const float val, const pv_type vertexType=BPhysHelper::PV_MIN_A0)
Set the transverse decay distance and its error measured between the refitted primary vertex of type ...
Definition BPhysHelper.cxx:888
xAOD::BPhysHelper::setZ0Err
float setZ0Err(const float val, const pv_type vertexType=BPhysHelper::PV_MIN_A0)
longitudinal impact parameter error
Definition BPhysHelper.cxx:1078
xAOD::BPhysHelper::vtx
const xAOD::Vertex * vtx() const
Getter method for the cached xAOD::Vertex.
Definition BPhysHelper.h:108
xAOD::BPhysHelper::setA0
float setA0(const float val, const pv_type vertexType=BPhysHelper::PV_MIN_A0)
Set the 3D and transverse impact parameters and their error.
Definition BPhysHelper.cxx:1023
xAOD::BPhysHelper::setPv
bool setPv(const xAOD::Vertex *pv, const xAOD::VertexContainer *vertexContainer, const pv_type vertexType=BPhysHelper::PV_MIN_A0)
Set the refitted collision vertex of type pv_type.
Definition BPhysHelper.cxx:831
xAOD::BPhysHelper::pv_type
pv_type
: Enum type of the PV
Definition BPhysHelper.h:475
xAOD::BPhysHelper::setA0Err
float setA0Err(const float val, const pv_type vertexType=BPhysHelper::PV_MIN_A0)
3D impact parameter error
Definition BPhysHelper.cxx:1034
xAOD::BPhysHelper::setRefitPVStatus
bool setRefitPVStatus(int code, const pv_type vertexType=BPhysHelper::PV_MIN_A0)
Set the exitCode of the refitter for vertex of type pv_type.
Definition BPhysHelper.cxx:844
xAOD::BPhysHelper::setA0xyErr
float setA0xyErr(const float val, const pv_type vertexType=BPhysHelper::PV_MIN_A0)
transverse impact parameter error
Definition BPhysHelper.cxx:1056
xAOD::BPhysHelper::setA0xy
float setA0xy(const float val, const pv_type vertexType=BPhysHelper::PV_MIN_A0)
transverse impact parameter
Definition BPhysHelper.cxx:1045
xAOD::BPhysHelper::setOrigPv
bool setOrigPv(const xAOD::Vertex *pv, const xAOD::VertexContainer *vertexContainer, const pv_type vertexType=BPhysHelper::PV_MIN_A0)
Set the original collision vertex of type pv_type.
Definition BPhysHelper.cxx:818
xAOD::BPhysHelper::setLxyz
bool setLxyz(const float val, const pv_type vertexType=BPhysHelper::PV_MIN_A0)
decay distance
Definition BPhysHelper.cxx:934
xAOD::BPhysHelper::setLxyzErr
bool setLxyzErr(const float val, const pv_type vertexType=BPhysHelper::PV_MIN_A0)
its error
Definition BPhysHelper.cxx:945
xAOD::Vertex_v1::setTrackParticleLinks
void setTrackParticleLinks(const TrackParticleLinks_t &trackParticles)
Set all track particle links at once.
xAOD::Vertex_v1::clearTracks
void clearTracks()
Remove all tracks from the vertex.
Definition Vertex_v1.cxx:331
xAOD::Vertex_v1::trackParticleLinks
const TrackParticleLinks_t & trackParticleLinks() const
Get all the particles associated with the vertex.
a0
double a0
Definition globals.cxx:27
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition GeoPrimitives.h:47
std
STL namespace.
xAOD::VxType::VertexType
VertexType
Vertex types.
Definition TrackingPrimitives.h:570
xAOD::VxType::PileUp
@ PileUp
Pile-up vertex.
Definition TrackingPrimitives.h:574
xAOD::VxType::PriVtx
@ PriVtx
Primary vertex.
Definition TrackingPrimitives.h:572
xAOD::EventInfo
EventInfo_v1 EventInfo
Definition of the latest event info version.
Definition IEventInfoCnvTool.h:18
xAOD::VertexContainer
VertexContainer_v1 VertexContainer
Definition of the current "Vertex container version".
Definition VertexContainer.h:14
xAOD::Vertex
Vertex_v1 Vertex
Define the latest version of the vertex class.
Definition Event/xAOD/xAODTracking/xAODTracking/Vertex.h:16
xAOD::TrackParticleContainer
TrackParticleContainer_v1 TrackParticleContainer
Definition of the current "TrackParticle container version".
Definition Event/xAOD/xAODTracking/xAODTracking/TrackParticleContainer.h:14
Generated on for ATLAS Offline Software by doxygen 1.14.0