ATLAS Offline Software
JpsiPlusDs1Cascade.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
3 */
5 // JpsiPlusDs1Cascade.cxx, (c) ATLAS Detector software
7 #include "DerivationFrameworkBPhys/JpsiPlusDs1Cascade.h"
8 #include "TrkVertexFitterInterfaces/IVertexFitter.h"
9 #include "TrkVKalVrtFitter/TrkVKalVrtFitter.h"
10 #include "TrkVertexAnalysisUtils/V0Tools.h"
11 #include "GaudiKernel/IPartPropSvc.h"
12 #include "HepPDT/ParticleDataTable.hh"
13 #include "DerivationFrameworkBPhys/CascadeTools.h"
14 #include "DerivationFrameworkBPhys/BPhysPVCascadeTools.h"
15 #include "xAODTracking/VertexAuxContainer.h"
16 #include "xAODBPhys/BPhysHypoHelper.h"
17 #include <algorithm>
18 #include "xAODTracking/VertexContainer.h"
19 
20 #include "TrkVKalVrtFitter/VxCascadeInfo.h"
21 #include "TruthUtils/HepMCHelpers.h"
22 
23 namespace DerivationFramework {
24  typedef ElementLink<xAOD::VertexContainer> VertexLink;
25  typedef std::vector<VertexLink> VertexLinkVector;
26  typedef std::vector<const xAOD::TrackParticle*> TrackBag;
27 
28  double JpsiPlusDs1Cascade::getParticleMass(int pdgcode) const{
29  auto ptr = m_particleDataTable->particle( pdgcode );
30  return ptr ? ptr->mass() : 0.;
31  }
32 
33  StatusCode JpsiPlusDs1Cascade::initialize() {
34 
35  // retrieving vertex Fitter
36  ATH_CHECK( m_iVertexFitter.retrieve());
37 
38  // retrieving the V0 tools
39  ATH_CHECK( m_V0Tools.retrieve());
40 
41  // retrieving the Cascade tools
42  ATH_CHECK( m_CascadeTools.retrieve());
43 
44  // Get the beam spot service
45  ATH_CHECK(m_eventInfo_key.initialize());
46 
47  IPartPropSvc* partPropSvc = nullptr;
48  ATH_CHECK( service("PartPropSvc", partPropSvc, true) );
49  m_particleDataTable = partPropSvc->PDT();
50 
51  // retrieve particle masses
52  if(m_mass_jpsi < 0. ) m_mass_jpsi = getParticleMass(MC::JPSI);
53  if(m_vtx0MassHypo < 0.) m_vtx0MassHypo = getParticleMass(MC::BCPLUS);
54  if(m_vtx1MassHypo < 0.) m_vtx1MassHypo = getParticleMass(MC::D0);
55  if(m_vtx2MassHypo < 0.) m_vtx2MassHypo = getParticleMass(MC::K0S);
56 
57  if(m_vtx0Daug1MassHypo < 0.) m_vtx0Daug1MassHypo = getParticleMass(MC::MUON);
58  if(m_vtx0Daug2MassHypo < 0.) m_vtx0Daug2MassHypo = getParticleMass(MC::MUON);
59  if(m_vtx0Daug3MassHypo < 0.) m_vtx0Daug3MassHypo = getParticleMass(MC::PIPLUS);
60  if(m_vtx1Daug1MassHypo < 0.) m_vtx1Daug1MassHypo = getParticleMass(MC::PIPLUS);
61  if(m_vtx1Daug2MassHypo < 0.) m_vtx1Daug2MassHypo = getParticleMass(MC::KPLUS);
62  if(m_vtx2Daug1MassHypo < 0.) m_vtx2Daug1MassHypo = getParticleMass(MC::PIPLUS);
63  if(m_vtx2Daug2MassHypo < 0.) m_vtx2Daug2MassHypo = getParticleMass(MC::PIPLUS);
64 
65  return StatusCode::SUCCESS;
66  }
67 
68 
69  StatusCode JpsiPlusDs1Cascade::addBranches() const
70  {
71  std::vector<Trk::VxCascadeInfo*> cascadeinfoContainer;
72  constexpr int topoN = 3;
73  std::array<xAOD::VertexContainer*, topoN> Vtxwritehandles;
74  std::array<xAOD::VertexAuxContainer*, topoN> Vtxwritehandlesaux;
75  if(m_cascadeOutputsKeys.size() !=topoN) { ATH_MSG_FATAL("Incorrect number of VtxContainers"); return StatusCode::FAILURE; }
76 
77  for(int i =0; i<topoN;i++){
78  Vtxwritehandles[i] = new xAOD::VertexContainer();
79  Vtxwritehandlesaux[i] = new xAOD::VertexAuxContainer();
80  Vtxwritehandles[i]->setStore(Vtxwritehandlesaux[i]);
81  ATH_CHECK(evtStore()->record(Vtxwritehandles[i] , m_cascadeOutputsKeys[i] ));
82  ATH_CHECK(evtStore()->record(Vtxwritehandlesaux[i], m_cascadeOutputsKeys[i] + "Aux."));
83  }
84 
85  //----------------------------------------------------
86  // retrieve primary vertices
87  //----------------------------------------------------
88  const xAOD::Vertex * primaryVertex(nullptr);
89  const xAOD::VertexContainer *pvContainer(nullptr);
90  ATH_CHECK(evtStore()->retrieve(pvContainer, m_VxPrimaryCandidateName));
91  ATH_MSG_DEBUG("Found " << m_VxPrimaryCandidateName << " in StoreGate!");
92 
93  if (pvContainer->size()==0){
94  ATH_MSG_WARNING("You have no primary vertices: " << pvContainer->size());
95  return StatusCode::RECOVERABLE;
96  } else {
97  primaryVertex = (*pvContainer)[0];
98  }
99 
100  //----------------------------------------------------
101  // Try to retrieve refitted primary vertices
102  //----------------------------------------------------
103  xAOD::VertexContainer* refPvContainer = nullptr;
104  xAOD::VertexAuxContainer* refPvAuxContainer = nullptr;
105  if (m_refitPV) {
106  if (evtStore()->contains<xAOD::VertexContainer>(m_refPVContainerName)) {
107  // refitted PV container exists. Get it from the store gate
108  ATH_CHECK(evtStore()->retrieve(refPvContainer , m_refPVContainerName ));
109  ATH_CHECK(evtStore()->retrieve(refPvAuxContainer, m_refPVContainerName + "Aux."));
110  } else {
111  // refitted PV container does not exist. Create a new one.
112  refPvContainer = new xAOD::VertexContainer;
113  refPvAuxContainer = new xAOD::VertexAuxContainer;
114  refPvContainer->setStore(refPvAuxContainer);
115  ATH_CHECK(evtStore()->record(refPvContainer , m_refPVContainerName));
116  ATH_CHECK(evtStore()->record(refPvAuxContainer, m_refPVContainerName+"Aux."));
117  }
118  }
119 
120  ATH_CHECK(performSearch(&cascadeinfoContainer));
121 
122  SG::ReadHandle<xAOD::EventInfo> evt(m_eventInfo_key);
123  if(not evt.isValid()) ATH_MSG_ERROR("Cannot Retrieve " << m_eventInfo_key.key() );
124  BPhysPVCascadeTools helper(&(*m_CascadeTools), evt.cptr());
125  helper.SetMinNTracksInPV(m_PV_minNTracks);
126 
127  // Decorators for the main vertex: chi2, ndf, pt and pt error, plus the D0, K0 vertex variables
128  SG::AuxElement::Decorator<VertexLinkVector> CascadeV1LinksDecor("CascadeVertex1Links");
129  SG::AuxElement::Decorator<VertexLinkVector> CascadeV2LinksDecor("CascadeVertex2Links");
130  SG::AuxElement::Decorator<VertexLinkVector> JpsipiLinksDecor("JpsipiVertexLinks");
131  SG::AuxElement::Decorator<VertexLinkVector> D0LinksDecor("D0VertexLinks");
132  SG::AuxElement::Decorator<VertexLinkVector> K0LinksDecor("K0VertexLinks");
133  SG::AuxElement::Decorator<float> chi2_decor("ChiSquared");
134  SG::AuxElement::Decorator<float> ndof_decor("NumberDoF");
135  SG::AuxElement::Decorator<float> Pt_decor("Pt");
136  SG::AuxElement::Decorator<float> PtErr_decor("PtErr");
137  SG::AuxElement::Decorator<float> Mass_svdecor("D0_mass");
138  SG::AuxElement::Decorator<float> MassErr_svdecor("D0_massErr");
139  SG::AuxElement::Decorator<float> Pt_svdecor("D0_Pt");
140  SG::AuxElement::Decorator<float> PtErr_svdecor("D0_PtErr");
141  SG::AuxElement::Decorator<float> Lxy_svdecor("D0_Lxy");
142  SG::AuxElement::Decorator<float> LxyErr_svdecor("D0_LxyErr");
143  SG::AuxElement::Decorator<float> Tau_svdecor("D0_Tau");
144  SG::AuxElement::Decorator<float> TauErr_svdecor("D0_TauErr");
145 
146  SG::AuxElement::Decorator<float> Mass_sv2decor("K0_mass");
147  SG::AuxElement::Decorator<float> MassErr_sv2decor("K0_massErr");
148  SG::AuxElement::Decorator<float> Pt_sv2decor("K0_Pt");
149  SG::AuxElement::Decorator<float> PtErr_sv2decor("K0_PtErr");
150  SG::AuxElement::Decorator<float> Lxy_sv2decor("K0_Lxy");
151  SG::AuxElement::Decorator<float> LxyErr_sv2decor("K0_LxyErr");
152  SG::AuxElement::Decorator<float> Tau_sv2decor("K0_Tau");
153  SG::AuxElement::Decorator<float> TauErr_sv2decor("K0_TauErr");
154 
155  SG::AuxElement::Decorator<float> MassJpsi_decor("Jpsi_mass");
156  SG::AuxElement::Decorator<float> MassPiD0_decor("PiD0_mass");
157  SG::AuxElement::Decorator<float> MassPiD0K0_decor("PiD0K0_mass");
158 
159  SG::AuxElement::Decorator<float> MassMumu_decor("Mumu_mass");
160  SG::AuxElement::Decorator<float> MassKpi_svdecor("Kpi_mass");
161  SG::AuxElement::Decorator<float> MassPipi_sv2decor("Pipi_mass");
162 
163  ATH_MSG_DEBUG("cascadeinfoContainer size " << cascadeinfoContainer.size());
164 
165  // Get Jpsi+pi container and identify the input Jpsi+pi
166  const xAOD::VertexContainer *jpsipiContainer(nullptr);
167  ATH_CHECK(evtStore()->retrieve(jpsipiContainer , m_vertexContainerKey ));
168  // Get D0 container and identify the input D0
169  const xAOD::VertexContainer *d0Container(nullptr);
170  ATH_CHECK(evtStore()->retrieve(d0Container , m_vertexD0ContainerKey ));
171  // Get K0 container and identify the input K0
172  const xAOD::VertexContainer *k0Container(nullptr);
173  ATH_CHECK(evtStore()->retrieve(k0Container , m_vertexK0ContainerKey ));
174 
175  for (Trk::VxCascadeInfo* x : cascadeinfoContainer) {
176  if(x==nullptr) {
177  ATH_MSG_ERROR("cascadeinfoContainer is null");
178  //x is dereferenced if we pass this
179  return StatusCode::FAILURE;
180  }
181 
182  // the cascade fitter returns:
183  // std::vector<xAOD::Vertex*>, each xAOD::Vertex contains the refitted track parameters (perigee at the vertex position)
184  // vertices[iv] the links to the original TPs and a covariance of size 3+5*NTRK; the chi2 of the total fit
185  // is split between the cascade vertices as per track contribution
186  // std::vector< std::vector<TLorentzVector> >, each std::vector<TLorentzVector> contains the refitted momenta (TLorentzVector)
187  // momenta[iv][...] of all tracks in the corresponding vertex, including any pseudotracks (from cascade vertices)
188  // originating in this vertex; the masses are as assigned in the cascade fit
189  // std::vector<Amg::MatrixX>, the corresponding covariance matrices in momentum space
190  // covariance[iv]
191  // int nDoF, double Chi2
192  //
193  // the invariant mass, pt, lifetime etc. errors should be calculated using the covariance matrices in momentum space as these
194  // take into account the full track-track and track-vertex correlations
195  //
196  // in the case of Jpsi+V0: vertices[0] is the V0 vertex, vertices[1] is the B/Lambda_b(bar) vertex, containing the 2 Jpsi tracks.
197  // The covariance terms between the two vertices are not stored. In momentum space momenta[0] contains the 2 V0 tracks,
198  // their momenta add up to the momentum of the 3rd track in momenta[1], the first two being the Jpsi tracks
199 
200  const std::vector<xAOD::Vertex*> &cascadeVertices = x->vertices();
201  if(cascadeVertices.size()!=topoN)
202  ATH_MSG_ERROR("Incorrect number of vertices");
203  if(cascadeVertices[0] == nullptr || cascadeVertices[1] == nullptr || cascadeVertices[2] == nullptr) ATH_MSG_ERROR("Error null vertex");
204  // Keep vertices (bear in mind that they come in reverse order!)
205  for(int i =0;i<topoN;i++) Vtxwritehandles[i]->push_back(cascadeVertices[i]);
206 
207  x->setSVOwnership(false); // Prevent Container from deleting vertices
208  const auto mainVertex = cascadeVertices[2]; // this is the B_c+/- vertex
209  const std::vector< std::vector<TLorentzVector> > &moms = x->getParticleMoms();
210 
211  // Set links to cascade vertices
212  std::vector<const xAOD::Vertex*> verticestoLink;
213  verticestoLink.push_back(cascadeVertices[0]);
214  //if(Vtxwritehandles[1] == nullptr) ATH_MSG_ERROR("Vtxwritehandles[1] is null");
215  if(Vtxwritehandles[2] == nullptr) ATH_MSG_ERROR("Vtxwritehandles[2] is null");
216  if(!BPhysPVCascadeTools::LinkVertices(CascadeV1LinksDecor, verticestoLink, Vtxwritehandles[0], cascadeVertices[2]))
217  ATH_MSG_ERROR("Error decorating with cascade vertices");
218 
219  verticestoLink.clear();
220  verticestoLink.push_back(cascadeVertices[1]);
221  if(!BPhysPVCascadeTools::LinkVertices(CascadeV2LinksDecor, verticestoLink, Vtxwritehandles[1], cascadeVertices[2]))
222  ATH_MSG_ERROR("Error decorating with cascade vertices");
223 
224  // Identify the input Jpsi+pi
225  const xAOD::Vertex* jpsipiVertex = BPhysPVCascadeTools::FindVertex<3>(jpsipiContainer, cascadeVertices[2]);
226  ATH_MSG_DEBUG("1 pt Jpsi+pi tracks " << cascadeVertices[2]->trackParticle(0)->pt() << ", " << cascadeVertices[2]->trackParticle(1)->pt() << ", " << cascadeVertices[2]->trackParticle(2)->pt());
227  if (jpsipiVertex) ATH_MSG_DEBUG("2 pt Jpsi+pi tracks " << jpsipiVertex->trackParticle(0)->pt() << ", " << jpsipiVertex->trackParticle(1)->pt() << ", " << jpsipiVertex->trackParticle(2)->pt());
228 
229  // Identify the input D0
230  const xAOD::Vertex* d0Vertex = BPhysPVCascadeTools::FindVertex<2>(d0Container, cascadeVertices[1]);;
231  ATH_MSG_DEBUG("1 pt D0 tracks " << cascadeVertices[1]->trackParticle(0)->pt() << ", " << cascadeVertices[1]->trackParticle(1)->pt());
232  if (d0Vertex) ATH_MSG_DEBUG("2 pt D0 tracks " << d0Vertex->trackParticle(0)->pt() << ", " << d0Vertex->trackParticle(1)->pt());
233 
234  // Identify the input K_S0
235  const xAOD::Vertex* k0Vertex = BPhysPVCascadeTools::FindVertex<2>(k0Container, cascadeVertices[0]);;
236  ATH_MSG_DEBUG("1 pt K_S0 tracks " << cascadeVertices[0]->trackParticle(0)->pt() << ", " << cascadeVertices[0]->trackParticle(1)->pt());
237  if (k0Vertex) ATH_MSG_DEBUG("2 pt K_S0 tracks " << k0Vertex->trackParticle(0)->pt() << ", " << k0Vertex->trackParticle(1)->pt());
238 
239  // Set links to input vertices
240  std::vector<const xAOD::Vertex*> jpsipiVerticestoLink;
241  if (jpsipiVertex) jpsipiVerticestoLink.push_back(jpsipiVertex);
242  else ATH_MSG_WARNING("Could not find linking Jpsi+pi");
243  if(!BPhysPVCascadeTools::LinkVertices(JpsipiLinksDecor, jpsipiVerticestoLink, jpsipiContainer, cascadeVertices[2]))
244  ATH_MSG_ERROR("Error decorating with Jpsi+pi vertices");
245 
246  std::vector<const xAOD::Vertex*> d0VerticestoLink;
247  if (d0Vertex) d0VerticestoLink.push_back(d0Vertex);
248  else ATH_MSG_WARNING("Could not find linking D0");
249  if(!BPhysPVCascadeTools::LinkVertices(D0LinksDecor, d0VerticestoLink, d0Container, cascadeVertices[2]))
250  ATH_MSG_ERROR("Error decorating with D0 vertices");
251 
252  std::vector<const xAOD::Vertex*> k0VerticestoLink;
253  if (k0Vertex) k0VerticestoLink.push_back(k0Vertex);
254  else ATH_MSG_WARNING("Could not find linking K_S0");
255  if(!BPhysPVCascadeTools::LinkVertices(K0LinksDecor, k0VerticestoLink, k0Container, cascadeVertices[2]))
256  ATH_MSG_ERROR("Error decorating with K_S0 vertices");
257 
258  bool tagD0(true);
259  if (jpsipiVertex){
260  if(abs(m_Dx_pid)==421 && (jpsipiVertex->trackParticle(2)->charge()==-1)) tagD0 = false;
261  }
262 
263  double mass_b = m_vtx0MassHypo;
264  double mass_d0 = m_vtx1MassHypo;
265  double mass_k0 = m_vtx2MassHypo;
266  std::vector<double> massesJpsipi;
267  massesJpsipi.push_back(m_vtx0Daug1MassHypo);
268  massesJpsipi.push_back(m_vtx0Daug2MassHypo);
269  massesJpsipi.push_back(m_vtx0Daug3MassHypo);
270  std::vector<double> massesD0;
271  if(tagD0){
272  massesD0.push_back(m_vtx1Daug1MassHypo);
273  massesD0.push_back(m_vtx1Daug2MassHypo);
274  }else{ // Change the oreder of masses for D*-->D0bar pi-, D0bar->K+pi-
275  massesD0.push_back(m_vtx1Daug2MassHypo);
276  massesD0.push_back(m_vtx1Daug1MassHypo);
277  }
278  std::vector<double> massesK0;
279  massesK0.push_back(m_vtx2Daug1MassHypo);
280  massesK0.push_back(m_vtx2Daug2MassHypo);
281  std::vector<double> Masses;
282  Masses.push_back(m_vtx0Daug1MassHypo);
283  Masses.push_back(m_vtx0Daug2MassHypo);
284  Masses.push_back(m_vtx0Daug3MassHypo);
285  Masses.push_back(m_vtx1MassHypo);
286  Masses.push_back(m_vtx2MassHypo);
287 
288  // loop over candidates -- Don't apply PV_minNTracks requirement here
289  // because it may result in exclusion of the high-pt PV.
290  // get good PVs
291 
292  xAOD::BPhysHypoHelper vtx(m_hypoName, mainVertex);
293 
294  BPhysPVCascadeTools::SetVectorInfo(vtx, x);
295 
296  // Decorate main vertex
297  //
298  // 1.a) mass, mass error
299  BPHYS_CHECK( vtx.setMass(m_CascadeTools->invariantMass(moms[2])) );
300  BPHYS_CHECK( vtx.setMassErr(m_CascadeTools->invariantMassError(moms[2],x->getCovariance()[2])) );
301  // 1.b) pt and pT error (the default pt of mainVertex is != the pt of the full cascade fit!)
302  Pt_decor(*mainVertex) = m_CascadeTools->pT(moms[2]);
303  PtErr_decor(*mainVertex) = m_CascadeTools->pTError(moms[2],x->getCovariance()[2]);
304  // 1.c) chi2 and ndof (the default chi2 of mainVertex is != the chi2 of the full cascade fit!)
305  chi2_decor(*mainVertex) = x->fitChi2();
306  ndof_decor(*mainVertex) = x->nDoF();
307 
308  float massMumu = 0.;
309  if (jpsipiVertex) {
310  TLorentzVector p4_mu1, p4_mu2;
311  p4_mu1.SetPtEtaPhiM(jpsipiVertex->trackParticle(0)->pt(),
312  jpsipiVertex->trackParticle(0)->eta(),
313  jpsipiVertex->trackParticle(0)->phi(), m_vtx0Daug1MassHypo);
314  p4_mu2.SetPtEtaPhiM(jpsipiVertex->trackParticle(1)->pt(),
315  jpsipiVertex->trackParticle(1)->eta(),
316  jpsipiVertex->trackParticle(1)->phi(), m_vtx0Daug2MassHypo);
317  massMumu = (p4_mu1 + p4_mu2).M();
318  }
319  MassMumu_decor(*mainVertex) = massMumu;
320 
321  float massKpi = 0.;
322  if (d0Vertex) {
323  TLorentzVector p4_ka, p4_pi;
324  if(tagD0){
325  p4_pi.SetPtEtaPhiM(d0Vertex->trackParticle(0)->pt(),
326  d0Vertex->trackParticle(0)->eta(),
327  d0Vertex->trackParticle(0)->phi(), m_vtx1Daug1MassHypo);
328  p4_ka.SetPtEtaPhiM(d0Vertex->trackParticle(1)->pt(),
329  d0Vertex->trackParticle(1)->eta(),
330  d0Vertex->trackParticle(1)->phi(), m_vtx1Daug2MassHypo);
331  }else{ // Change the oreder of masses for D*-->D0bar pi-, D0bar->K+pi-
332  p4_pi.SetPtEtaPhiM(d0Vertex->trackParticle(1)->pt(),
333  d0Vertex->trackParticle(1)->eta(),
334  d0Vertex->trackParticle(1)->phi(), m_vtx1Daug1MassHypo);
335  p4_ka.SetPtEtaPhiM(d0Vertex->trackParticle(0)->pt(),
336  d0Vertex->trackParticle(0)->eta(),
337  d0Vertex->trackParticle(0)->phi(), m_vtx1Daug2MassHypo);
338  }
339  massKpi = (p4_ka + p4_pi).M();
340  }
341  MassKpi_svdecor(*mainVertex) = massKpi;
342 
343  float massPipi = 0.;
344  if (k0Vertex) {
345  TLorentzVector p4_pip, p4_pim;
346  p4_pip.SetPtEtaPhiM(k0Vertex->trackParticle(0)->pt(),
347  k0Vertex->trackParticle(0)->eta(),
348  k0Vertex->trackParticle(0)->phi(), m_vtx2Daug1MassHypo);
349  p4_pim.SetPtEtaPhiM(k0Vertex->trackParticle(1)->pt(),
350  k0Vertex->trackParticle(1)->eta(),
351  k0Vertex->trackParticle(1)->phi(), m_vtx2Daug2MassHypo);
352  massPipi = (p4_pip + p4_pim).M();
353  }
354  MassPipi_sv2decor(*mainVertex) = massPipi;
355 
356  MassJpsi_decor(*mainVertex) = (moms[2][0] + moms[2][1]).M();
357  MassPiD0_decor(*mainVertex) = (moms[2][2] + moms[2][4]).M();
358  MassPiD0K0_decor(*mainVertex) = (moms[2][2] + moms[2][4] + moms[2][3]).M();
359 
360  ATH_CHECK(helper.FillCandwithRefittedVertices(m_refitPV, pvContainer,
361  refPvContainer, &(*m_pvRefitter), m_PV_max, m_DoVertexType, x, 2, mass_b, vtx));
362 
363  // 4) decorate the main vertex with D0 vertex mass, pt, lifetime and lxy values (plus errors)
364  // D0 points to the main vertex, so lifetime and lxy are w.r.t the main vertex
365  Mass_svdecor(*mainVertex) = m_CascadeTools->invariantMass(moms[1]);
366  MassErr_svdecor(*mainVertex) = m_CascadeTools->invariantMassError(moms[1],x->getCovariance()[1]);
367  Pt_svdecor(*mainVertex) = m_CascadeTools->pT(moms[1]);
368  PtErr_svdecor(*mainVertex) = m_CascadeTools->pTError(moms[1],x->getCovariance()[1]);
369  Lxy_svdecor(*mainVertex) = m_CascadeTools->lxy(moms[1],cascadeVertices[1],cascadeVertices[2]);
370  LxyErr_svdecor(*mainVertex) = m_CascadeTools->lxyError(moms[1],x->getCovariance()[1],cascadeVertices[1],cascadeVertices[2]);
371  Tau_svdecor(*mainVertex) = m_CascadeTools->tau(moms[1],cascadeVertices[1],cascadeVertices[2]);
372  TauErr_svdecor(*mainVertex) = m_CascadeTools->tauError(moms[1],x->getCovariance()[1],cascadeVertices[1],cascadeVertices[2]);
373 
374  // 5) decorate the main vertex with K_S0 vertex mass, pt, lifetime and lxy values (plus errors)
375  // K_S0 points to the main vertex, so lifetime and lxy are w.r.t the main vertex
376  Mass_sv2decor(*mainVertex) = m_CascadeTools->invariantMass(moms[0]);
377  MassErr_sv2decor(*mainVertex) = m_CascadeTools->invariantMassError(moms[0],x->getCovariance()[0]);
378  Pt_sv2decor(*mainVertex) = m_CascadeTools->pT(moms[0]);
379  PtErr_sv2decor(*mainVertex) = m_CascadeTools->pTError(moms[0],x->getCovariance()[0]);
380  Lxy_sv2decor(*mainVertex) = m_CascadeTools->lxy(moms[0],cascadeVertices[0],cascadeVertices[2]);
381  LxyErr_sv2decor(*mainVertex) = m_CascadeTools->lxyError(moms[0],x->getCovariance()[0],cascadeVertices[0],cascadeVertices[2]);
382  Tau_sv2decor(*mainVertex) = m_CascadeTools->tau(moms[0],cascadeVertices[0],cascadeVertices[2]);
383  TauErr_sv2decor(*mainVertex) = m_CascadeTools->tauError(moms[0],x->getCovariance()[0],cascadeVertices[0],cascadeVertices[2]);
384 
385  // Some checks in DEBUG mode
386  ATH_MSG_DEBUG("chi2 " << x->fitChi2()
387  << " chi2_1 " << m_V0Tools->chisq(cascadeVertices[0])
388  << " chi2_2 " << m_V0Tools->chisq(cascadeVertices[1])
389  << " chi2_3 " << m_V0Tools->chisq(cascadeVertices[2])
390  << " vprob " << m_CascadeTools->vertexProbability(x->nDoF(),x->fitChi2()));
391  ATH_MSG_DEBUG("ndf " << x->nDoF() << " ndf_1 " << m_V0Tools->ndof(cascadeVertices[0]) << " ndf_2 " << m_V0Tools->ndof(cascadeVertices[1]) << " ndf_3 " << m_V0Tools->ndof(cascadeVertices[2]));
392  ATH_MSG_DEBUG("V0Tools mass_k0 " << m_V0Tools->invariantMass(cascadeVertices[0],massesK0)
393  << " error " << m_V0Tools->invariantMassError(cascadeVertices[0],massesK0)
394  << " mass_d0 " << m_V0Tools->invariantMass(cascadeVertices[1],massesD0)
395  << " error " << m_V0Tools->invariantMassError(cascadeVertices[1],massesD0)
396  << " mass_J " << m_V0Tools->invariantMass(cascadeVertices[2],massesJpsipi)
397  << " error " << m_V0Tools->invariantMassError(cascadeVertices[2],massesJpsipi));
398  // masses and errors, using track masses assigned in the fit
399  double Mass_B = m_CascadeTools->invariantMass(moms[2]);
400  double Mass_D0 = m_CascadeTools->invariantMass(moms[1]);
401  double Mass_K0 = m_CascadeTools->invariantMass(moms[0]);
402  double Mass_B_err = m_CascadeTools->invariantMassError(moms[2],x->getCovariance()[2]);
403  double Mass_D0_err = m_CascadeTools->invariantMassError(moms[1],x->getCovariance()[1]);
404  double Mass_K0_err = m_CascadeTools->invariantMassError(moms[0],x->getCovariance()[0]);
405  ATH_MSG_DEBUG("Mass_B " << Mass_B << " Mass_D0 " << Mass_D0 << " Mass_K0 " << Mass_K0);
406  ATH_MSG_DEBUG("Mass_B_err " << Mass_B_err << " Mass_D0_err " << Mass_D0_err << " Mass_K0_err " << Mass_K0_err);
407  double mprob_B = m_CascadeTools->massProbability(mass_b,Mass_B,Mass_B_err);
408  double mprob_D0 = m_CascadeTools->massProbability(mass_d0,Mass_D0,Mass_D0_err);
409  double mprob_K0 = m_CascadeTools->massProbability(mass_k0,Mass_K0,Mass_K0_err);
410  ATH_MSG_DEBUG("mprob_B " << mprob_B << " mprob_D0 " << mprob_D0 << " mprob_K0 " << mprob_K0);
411  // masses and errors, assigning user defined track masses
412  ATH_MSG_DEBUG("Mass_b " << m_CascadeTools->invariantMass(moms[2],Masses)
413  << " Mass_d0 " << m_CascadeTools->invariantMass(moms[1],massesD0)
414  << " Mass_k0 " << m_CascadeTools->invariantMass(moms[0],massesD0));
415  ATH_MSG_DEBUG("Mass_b_err " << m_CascadeTools->invariantMassError(moms[2],x->getCovariance()[2],Masses)
416  << " Mass_d0_err " << m_CascadeTools->invariantMassError(moms[1],x->getCovariance()[1],massesD0)
417  << " Mass_k0_err " << m_CascadeTools->invariantMassError(moms[0],x->getCovariance()[0],massesK0));
418  ATH_MSG_DEBUG("pt_b " << m_CascadeTools->pT(moms[2])
419  << " pt_d " << m_CascadeTools->pT(moms[1])
420  << " pt_d0 " << m_V0Tools->pT(cascadeVertices[1])
421  << " pt_k " << m_CascadeTools->pT(moms[0])
422  << " pt_k0 " << m_V0Tools->pT(cascadeVertices[0]));
423  ATH_MSG_DEBUG("ptErr_b " << m_CascadeTools->pTError(moms[2],x->getCovariance()[2])
424  << " ptErr_d " << m_CascadeTools->pTError(moms[1],x->getCovariance()[1])
425  << " ptErr_d0 " << m_V0Tools->pTError(cascadeVertices[1])
426  << " ptErr_k " << m_CascadeTools->pTError(moms[0],x->getCovariance()[0])
427  << " ptErr_k0 " << m_V0Tools->pTError(cascadeVertices[0]));
428  ATH_MSG_DEBUG("lxy_B " << m_V0Tools->lxy(cascadeVertices[2],primaryVertex) << " lxy_D " << m_V0Tools->lxy(cascadeVertices[1],cascadeVertices[2]) << " lxy_K " << m_V0Tools->lxy(cascadeVertices[0],cascadeVertices[2]));
429  ATH_MSG_DEBUG("lxy_b " << m_CascadeTools->lxy(moms[2],cascadeVertices[2],primaryVertex) << " lxy_d " << m_CascadeTools->lxy(moms[1],cascadeVertices[1],cascadeVertices[2]) << " lxy_k " << m_CascadeTools->lxy(moms[0],cascadeVertices[0],cascadeVertices[2]));
430  ATH_MSG_DEBUG("lxyErr_b " << m_CascadeTools->lxyError(moms[2],x->getCovariance()[2],cascadeVertices[2],primaryVertex)
431  << " lxyErr_d " << m_CascadeTools->lxyError(moms[1],x->getCovariance()[1],cascadeVertices[1],cascadeVertices[2])
432  << " lxyErr_d0 " << m_V0Tools->lxyError(cascadeVertices[1],cascadeVertices[2])
433  << " lxyErr_k " << m_CascadeTools->lxyError(moms[0],x->getCovariance()[0],cascadeVertices[0],cascadeVertices[2])
434  << " lxyErr_k0 " << m_V0Tools->lxyError(cascadeVertices[0],cascadeVertices[2]));
435  ATH_MSG_DEBUG("tau_B " << m_CascadeTools->tau(moms[2],cascadeVertices[2],primaryVertex,mass_b)
436  << " tau_d0 " << m_V0Tools->tau(cascadeVertices[1],cascadeVertices[2],massesD0)
437  << " tau_k0 " << m_V0Tools->tau(cascadeVertices[0],cascadeVertices[2],massesK0));
438  ATH_MSG_DEBUG("tau_b " << m_CascadeTools->tau(moms[2],cascadeVertices[2],primaryVertex)
439  << " tau_d " << m_CascadeTools->tau(moms[1],cascadeVertices[1],cascadeVertices[2])
440  << " tau_D " << m_CascadeTools->tau(moms[1],cascadeVertices[1],cascadeVertices[2],mass_d0)
441  << " tau_k " << m_CascadeTools->tau(moms[0],cascadeVertices[0],cascadeVertices[2])
442  << " tau_K " << m_CascadeTools->tau(moms[0],cascadeVertices[0],cascadeVertices[2],mass_k0));
443  ATH_MSG_DEBUG("tauErr_b " << m_CascadeTools->tauError(moms[2],x->getCovariance()[2],cascadeVertices[2],primaryVertex)
444  << " tauErr_d " << m_CascadeTools->tauError(moms[1],x->getCovariance()[1],cascadeVertices[1],cascadeVertices[2])
445  << " tauErr_d0 " << m_V0Tools->tauError(cascadeVertices[1],cascadeVertices[2],massesD0)
446  << " tauErr_k " << m_CascadeTools->tauError(moms[0],x->getCovariance()[0],cascadeVertices[0],cascadeVertices[2])
447  << " tauErr_k0 " << m_V0Tools->tauError(cascadeVertices[0],cascadeVertices[2],massesK0));
448  ATH_MSG_DEBUG("TauErr_b " << m_CascadeTools->tauError(moms[2],x->getCovariance()[2],cascadeVertices[2],primaryVertex,mass_b)
449  << " TauErr_d " << m_CascadeTools->tauError(moms[1],x->getCovariance()[1],cascadeVertices[1],cascadeVertices[2],mass_d0)
450  << " TauErr_d0 " << m_V0Tools->tauError(cascadeVertices[1],cascadeVertices[2],massesD0,mass_d0)
451  << " TauErr_k " << m_CascadeTools->tauError(moms[0],x->getCovariance()[0],cascadeVertices[0],cascadeVertices[2],mass_k0)
452  << " TauErr_k0 " << m_V0Tools->tauError(cascadeVertices[0],cascadeVertices[2],massesD0,mass_k0));
453 
454  ATH_MSG_DEBUG("CascadeTools main vert wrt PV " << " CascadeTools SV " << " V0Tools SV");
455  ATH_MSG_DEBUG("a0z " << m_CascadeTools->a0z(moms[2],cascadeVertices[2],primaryVertex)
456  << ", " << m_CascadeTools->a0z(moms[1],cascadeVertices[1],cascadeVertices[2])
457  << ", " << m_CascadeTools->a0z(moms[0],cascadeVertices[0],cascadeVertices[2])
458  << ", " << m_V0Tools->a0z(cascadeVertices[1],cascadeVertices[2])
459  << ", " << m_V0Tools->a0z(cascadeVertices[0],cascadeVertices[2]));
460  ATH_MSG_DEBUG("a0zErr " << m_CascadeTools->a0zError(moms[2],x->getCovariance()[2],cascadeVertices[2],primaryVertex)
461  << ", " << m_CascadeTools->a0zError(moms[1],x->getCovariance()[1],cascadeVertices[1],cascadeVertices[2])
462  << ", " << m_CascadeTools->a0zError(moms[0],x->getCovariance()[0],cascadeVertices[0],cascadeVertices[2])
463  << ", " << m_V0Tools->a0zError(cascadeVertices[1],cascadeVertices[2])
464  << ", " << m_V0Tools->a0zError(cascadeVertices[0],cascadeVertices[2]));
465  ATH_MSG_DEBUG("a0xy " << m_CascadeTools->a0xy(moms[2],cascadeVertices[2],primaryVertex)
466  << ", " << m_CascadeTools->a0xy(moms[1],cascadeVertices[1],cascadeVertices[2])
467  << ", " << m_CascadeTools->a0xy(moms[0],cascadeVertices[0],cascadeVertices[2])
468  << ", " << m_V0Tools->a0xy(cascadeVertices[1],cascadeVertices[2])
469  << ", " << m_V0Tools->a0xy(cascadeVertices[0],cascadeVertices[2]));
470  ATH_MSG_DEBUG("a0xyErr " << m_CascadeTools->a0xyError(moms[2],x->getCovariance()[2],cascadeVertices[2],primaryVertex)
471  << ", " << m_CascadeTools->a0xyError(moms[1],x->getCovariance()[1],cascadeVertices[1],cascadeVertices[2])
472  << ", " << m_CascadeTools->a0xyError(moms[0],x->getCovariance()[0],cascadeVertices[0],cascadeVertices[2])
473  << ", " << m_V0Tools->a0xyError(cascadeVertices[1],cascadeVertices[2])
474  << ", " << m_V0Tools->a0xyError(cascadeVertices[0],cascadeVertices[2]));
475  ATH_MSG_DEBUG("a0 " << m_CascadeTools->a0(moms[2],cascadeVertices[2],primaryVertex)
476  << ", " << m_CascadeTools->a0(moms[1],cascadeVertices[1],cascadeVertices[2])
477  << ", " << m_CascadeTools->a0(moms[0],cascadeVertices[0],cascadeVertices[2])
478  << ", " << m_V0Tools->a0(cascadeVertices[1],cascadeVertices[2])
479  << ", " << m_V0Tools->a0(cascadeVertices[0],cascadeVertices[2]));
480  ATH_MSG_DEBUG("a0Err " << m_CascadeTools->a0Error(moms[2],x->getCovariance()[2],cascadeVertices[2],primaryVertex)
481  << ", " << m_CascadeTools->a0Error(moms[1],x->getCovariance()[1],cascadeVertices[1],cascadeVertices[2])
482  << ", " << m_CascadeTools->a0Error(moms[0],x->getCovariance()[0],cascadeVertices[0],cascadeVertices[2])
483  << ", " << m_V0Tools->a0Error(cascadeVertices[1],cascadeVertices[2])
484  << ", " << m_V0Tools->a0Error(cascadeVertices[0],cascadeVertices[2]));
485  ATH_MSG_DEBUG("x0 " << m_V0Tools->vtx(cascadeVertices[0]).x() << " y0 " << m_V0Tools->vtx(cascadeVertices[0]).y() << " z0 " << m_V0Tools->vtx(cascadeVertices[0]).z());
486  ATH_MSG_DEBUG("x1 " << m_V0Tools->vtx(cascadeVertices[1]).x() << " y1 " << m_V0Tools->vtx(cascadeVertices[1]).y() << " z1 " << m_V0Tools->vtx(cascadeVertices[1]).z());
487  ATH_MSG_DEBUG("x2 " << m_V0Tools->vtx(cascadeVertices[2]).x() << " y2 " << m_V0Tools->vtx(cascadeVertices[2]).y() << " z2 " << m_V0Tools->vtx(cascadeVertices[2]).z());
488  ATH_MSG_DEBUG("X0 " << primaryVertex->x() << " Y0 " << primaryVertex->y() << " Z0 " << primaryVertex->z());
489  ATH_MSG_DEBUG("rxy0 " << m_V0Tools->rxy(cascadeVertices[0]) << " rxyErr0 " << m_V0Tools->rxyError(cascadeVertices[0]));
490  ATH_MSG_DEBUG("rxy1 " << m_V0Tools->rxy(cascadeVertices[1]) << " rxyErr1 " << m_V0Tools->rxyError(cascadeVertices[1]));
491  ATH_MSG_DEBUG("rxy2 " << m_V0Tools->rxy(cascadeVertices[2]) << " rxyErr2 " << m_V0Tools->rxyError(cascadeVertices[2]));
492  ATH_MSG_DEBUG("Rxy0 wrt PV " << m_V0Tools->rxy(cascadeVertices[0],primaryVertex) << " RxyErr0 wrt PV " << m_V0Tools->rxyError(cascadeVertices[0],primaryVertex));
493  ATH_MSG_DEBUG("Rxy1 wrt PV " << m_V0Tools->rxy(cascadeVertices[1],primaryVertex) << " RxyErr1 wrt PV " << m_V0Tools->rxyError(cascadeVertices[1],primaryVertex));
494  ATH_MSG_DEBUG("Rxy2 wrt PV " << m_V0Tools->rxy(cascadeVertices[2],primaryVertex) << " RxyErr2 wrt PV " << m_V0Tools->rxyError(cascadeVertices[2],primaryVertex));
495  ATH_MSG_DEBUG("number of covariance matrices " << (x->getCovariance()).size());
496  } // loop over cascadeinfoContainer
497 
498  // Deleting cascadeinfo since this won't be stored.
499  // Vertices have been kept in m_cascadeOutputs and should be owned by their container
500  for (auto x : cascadeinfoContainer) delete x;
501 
502  return StatusCode::SUCCESS;
503  }
504 
505 
506  JpsiPlusDs1Cascade::JpsiPlusDs1Cascade(const std::string& t, const std::string& n, const IInterface* p) : AthAlgTool(t,n,p),
507  m_vertexContainerKey(""),
508  m_vertexD0ContainerKey(""),
509  m_vertexK0ContainerKey(""),
510  m_cascadeOutputsKeys{ "JpsiPlusDs1CascadeVtx1", "JpsiPlusDs1CascadeVtx2", "JpsiPlusDs1CascadeVtx3" },
511  m_VxPrimaryCandidateName("PrimaryVertices"),
512  m_jpsiMassLower(0.0),
513  m_jpsiMassUpper(10000.0),
514  m_jpsipiMassLower(0.0),
515  m_jpsipiMassUpper(10000.0),
516  m_D0MassLower(0.0),
517  m_D0MassUpper(10000.0),
518  m_K0MassLower(0.0),
519  m_K0MassUpper(10000.0),
520  m_DstMassLower(0.0),
521  m_DstMassUpper(10000.0),
522  m_MassLower(0.0),
523  m_MassUpper(20000.0),
524  m_vtx0MassHypo(-1),
525  m_vtx1MassHypo(-1),
526  m_vtx2MassHypo(-1),
527  m_vtx0Daug1MassHypo(-1),
528  m_vtx0Daug2MassHypo(-1),
529  m_vtx0Daug3MassHypo(-1),
530  m_vtx1Daug1MassHypo(-1),
531  m_vtx1Daug2MassHypo(-1),
532  m_vtx2Daug1MassHypo(-1),
533  m_vtx2Daug2MassHypo(-1),
534  m_particleDataTable(nullptr),
535  m_mass_jpsi(-1),
536  m_Dx_pid(421),
537  m_constrD0(true),
538  m_constrK0(true),
539  m_constrJpsi(true),
540  m_chi2cut(-1.0),
541  m_iVertexFitter("Trk::TrkVKalVrtFitter"),
542  m_pvRefitter("Analysis::PrimaryVertexRefitter"),
543  m_V0Tools("Trk::V0Tools"),
544  m_CascadeTools("DerivationFramework::CascadeTools")
545  {
546  declareProperty("JpsipiVertices", m_vertexContainerKey);
547  declareProperty("D0Vertices", m_vertexD0ContainerKey);
548  declareProperty("K0Vertices", m_vertexK0ContainerKey);
549  declareProperty("VxPrimaryCandidateName", m_VxPrimaryCandidateName);
550  declareProperty("RefPVContainerName", m_refPVContainerName = "RefittedPrimaryVertices");
551  declareProperty("JpsiMassLowerCut", m_jpsiMassLower);
552  declareProperty("JpsiMassUpperCut", m_jpsiMassUpper);
553  declareProperty("JpsipiMassLowerCut", m_jpsipiMassLower);
554  declareProperty("JpsipiMassUpperCut", m_jpsipiMassUpper);
555  declareProperty("D0MassLowerCut", m_D0MassLower);
556  declareProperty("D0MassUpperCut", m_D0MassUpper);
557  declareProperty("K0MassLowerCut", m_K0MassLower);
558  declareProperty("K0MassUpperCut", m_K0MassUpper);
559  declareProperty("DstMassLowerCut", m_DstMassLower);
560  declareProperty("DstMassUpperCut", m_DstMassUpper);
561  declareProperty("MassLowerCut", m_MassLower);
562  declareProperty("MassUpperCut", m_MassUpper);
563  declareProperty("HypothesisName", m_hypoName = "Bc");
564  declareProperty("Vtx0MassHypo", m_vtx0MassHypo);
565  declareProperty("Vtx1MassHypo", m_vtx1MassHypo);
566  declareProperty("Vtx2MassHypo", m_vtx2MassHypo);
567  declareProperty("Vtx0Daug1MassHypo", m_vtx0Daug1MassHypo);
568  declareProperty("Vtx0Daug2MassHypo", m_vtx0Daug2MassHypo);
569  declareProperty("Vtx0Daug3MassHypo", m_vtx0Daug3MassHypo);
570  declareProperty("Vtx1Daug1MassHypo", m_vtx1Daug1MassHypo);
571  declareProperty("Vtx1Daug2MassHypo", m_vtx1Daug2MassHypo);
572  declareProperty("Vtx2Daug1MassHypo", m_vtx2Daug1MassHypo);
573  declareProperty("Vtx2Daug2MassHypo", m_vtx2Daug2MassHypo);
574  declareProperty("JpsiMass", m_mass_jpsi);
575  declareProperty("DxHypothesis", m_Dx_pid);
576  declareProperty("ApplyD0MassConstraint", m_constrD0);
577  declareProperty("ApplyK0MassConstraint", m_constrK0);
578  declareProperty("ApplyJpsiMassConstraint", m_constrJpsi);
579  declareProperty("Chi2Cut", m_chi2cut);
580  declareProperty("RefitPV", m_refitPV = true);
581  declareProperty("MaxnPV", m_PV_max = 999);
582  declareProperty("MinNTracksInPV", m_PV_minNTracks = 0);
583  declareProperty("DoVertexType", m_DoVertexType = 7);
584  declareProperty("TrkVertexFitterTool", m_iVertexFitter);
585  declareProperty("PVRefitter", m_pvRefitter);
586  declareProperty("V0Tools", m_V0Tools);
587  declareProperty("CascadeTools", m_CascadeTools);
588  declareProperty("CascadeVertexCollections", m_cascadeOutputsKeys);
589  }
590 
591  JpsiPlusDs1Cascade::~JpsiPlusDs1Cascade(){ }
592 
593  StatusCode JpsiPlusDs1Cascade::performSearch(std::vector<Trk::VxCascadeInfo*> *cascadeinfoContainer) const
594  {
595  ATH_MSG_DEBUG( "JpsiPlusDs1Cascade::performSearch" );
596  assert(cascadeinfoContainer!=nullptr);
597 
598  // Get TrackParticle container (for setting links to the original tracks)
599  const xAOD::TrackParticleContainer *trackContainer(nullptr);
600  ATH_CHECK(evtStore()->retrieve(trackContainer , "InDetTrackParticles" ));
601 
602  // Get Jpsi+pi container
603  const xAOD::VertexContainer *jpsipiContainer(nullptr);
604  ATH_CHECK(evtStore()->retrieve(jpsipiContainer , m_vertexContainerKey ));
605 
606  // Get D0 container
607  const xAOD::VertexContainer *d0Container(nullptr);
608  ATH_CHECK(evtStore()->retrieve(d0Container , m_vertexD0ContainerKey ));
609 
610  // Get K_S0 container
611  const xAOD::VertexContainer *k0Container(nullptr);
612  ATH_CHECK(evtStore()->retrieve(k0Container , m_vertexK0ContainerKey ));
613 
614  double mass_d0 = m_vtx1MassHypo;
615  double mass_k0 = m_vtx2MassHypo;
616  std::vector<const xAOD::TrackParticle*> tracksJpsipi;
617  std::vector<const xAOD::TrackParticle*> tracksJpsi;
618  std::vector<const xAOD::TrackParticle*> tracksD0;
619  std::vector<const xAOD::TrackParticle*> tracksK0;
620  std::vector<const xAOD::TrackParticle*> tracksBc;
621  std::vector<double> massesJpsipi;
622  massesJpsipi.push_back(m_vtx0Daug1MassHypo);
623  massesJpsipi.push_back(m_vtx0Daug2MassHypo);
624  massesJpsipi.push_back(m_vtx0Daug3MassHypo);
625  std::vector<double> massesD0;
626  massesD0.push_back(m_vtx1Daug1MassHypo);
627  massesD0.push_back(m_vtx1Daug2MassHypo);
628  std::vector<double> massesD0b; // Change the oreder of masses for D*-->D0bar pi-, D0bar->K+pi-
629  massesD0b.push_back(m_vtx1Daug2MassHypo);
630  massesD0b.push_back(m_vtx1Daug1MassHypo);
631  std::vector<double> massesK0;
632  massesK0.push_back(m_vtx2Daug1MassHypo);
633  massesK0.push_back(m_vtx2Daug2MassHypo);
634  std::vector<double> Masses;
635  Masses.push_back(m_vtx0Daug1MassHypo);
636  Masses.push_back(m_vtx0Daug2MassHypo);
637  Masses.push_back(m_vtx0Daug3MassHypo);
638  Masses.push_back(m_vtx1MassHypo);
639  Masses.push_back(m_vtx2MassHypo);
640 
641  // Select J/psi pi+ candidates before calling cascade fit
642  std::vector<const xAOD::Vertex*> selectedJpsipiCandidates;
643  for(auto vxcItr=jpsipiContainer->cbegin(); vxcItr!=jpsipiContainer->cend(); ++vxcItr) {
644 
645  // Check the passed flag first
646  const xAOD::Vertex* vtx = *vxcItr;
647  SG::AuxElement::Accessor<Char_t> flagAcc1("passed_Jpsipi");
648  if(flagAcc1.isAvailable(*vtx)){
649  if(!flagAcc1(*vtx)) continue;
650  }
651 
652  // Check J/psi candidate invariant mass and skip if need be
653  TLorentzVector p4Mup_in, p4Mum_in;
654  p4Mup_in.SetPtEtaPhiM((*vxcItr)->trackParticle(0)->pt(),
655  (*vxcItr)->trackParticle(0)->eta(),
656  (*vxcItr)->trackParticle(0)->phi(), m_vtx0Daug1MassHypo);
657  p4Mum_in.SetPtEtaPhiM((*vxcItr)->trackParticle(1)->pt(),
658  (*vxcItr)->trackParticle(1)->eta(),
659  (*vxcItr)->trackParticle(1)->phi(), m_vtx0Daug2MassHypo);
660  double mass_Jpsi = (p4Mup_in + p4Mum_in).M();
661  ATH_MSG_DEBUG("Jpsi mass " << mass_Jpsi);
662  if (mass_Jpsi < m_jpsiMassLower || mass_Jpsi > m_jpsiMassUpper) {
663  ATH_MSG_DEBUG(" Original Jpsi candidate rejected by the mass cut: mass = "
664  << mass_Jpsi << " != (" << m_jpsiMassLower << ", " << m_jpsiMassUpper << ")" );
665  continue;
666  }
667 
668  // Check J/psi pi+ candidate invariant mass and skip if need be
669  double mass_Jpsipi = m_V0Tools->invariantMass(*vxcItr, massesJpsipi);
670  ATH_MSG_DEBUG("Jpsipi mass " << mass_Jpsipi);
671  if (mass_Jpsipi < m_jpsipiMassLower || mass_Jpsipi > m_jpsipiMassUpper) {
672  ATH_MSG_DEBUG(" Original Jpsipi candidate rejected by the mass cut: mass = "
673  << mass_Jpsipi << " != (" << m_jpsipiMassLower << ", " << m_jpsipiMassUpper << ")" );
674  continue;
675  }
676 
677  selectedJpsipiCandidates.push_back(*vxcItr);
678  }
679  if(selectedJpsipiCandidates.size()<1) return StatusCode::SUCCESS;
680 
681  // Select the D0/D0b candidates before calling cascade fit
682  std::vector<const xAOD::Vertex*> selectedD0Candidates;
683  for(auto vxcItr=d0Container->cbegin(); vxcItr!=d0Container->cend(); ++vxcItr) {
684 
685  // Check the passed flag first
686  const xAOD::Vertex* vtx = *vxcItr;
687  SG::AuxElement::Accessor<Char_t> flagAcc1("passed_D0");
688  SG::AuxElement::Accessor<Char_t> flagAcc2("passed_D0b");
689  bool isD0(true);
690  bool isD0b(true);
691  if(flagAcc1.isAvailable(*vtx)){
692  if(!flagAcc1(*vtx)) isD0 = false;
693  }
694  if(flagAcc2.isAvailable(*vtx)){
695  if(!flagAcc2(*vtx)) isD0b = false;
696  }
697  if(!(isD0||isD0b)) continue;
698 
699  // Ensure the total charge is correct
700  if ((*vxcItr)->trackParticle(0)->charge() != 1 || (*vxcItr)->trackParticle(1)->charge() != -1) {
701  ATH_MSG_DEBUG(" Original D0/D0-bar candidate rejected by the charge requirement: "
702  << (*vxcItr)->trackParticle(0)->charge() << ", " << (*vxcItr)->trackParticle(1)->charge() );
703  continue;
704  }
705 
706  // Check D0/D0bar candidate invariant mass and skip if need be
707  double mass_D0 = m_V0Tools->invariantMass(*vxcItr,massesD0);
708  double mass_D0b = m_V0Tools->invariantMass(*vxcItr,massesD0b);
709  ATH_MSG_DEBUG("D0 mass " << mass_D0 << ", D0b mass "<<mass_D0b);
710  if ((mass_D0 < m_D0MassLower || mass_D0 > m_D0MassUpper) && (mass_D0b < m_D0MassLower || mass_D0b > m_D0MassUpper)) {
711  ATH_MSG_DEBUG(" Original D0 candidate rejected by the mass cut: mass = "
712  << mass_D0 << " != (" << m_D0MassLower << ", " << m_D0MassUpper << ") "
713  << mass_D0b << " != (" << m_D0MassLower << ", " << m_D0MassUpper << ") " );
714  continue;
715  }
716 
717  selectedD0Candidates.push_back(*vxcItr);
718  }
719  if(selectedD0Candidates.size()<1) return StatusCode::SUCCESS;
720 
721  // Select the D0/D0b candidates before calling cascade fit
722  std::vector<const xAOD::Vertex*> selectedK0Candidates;
723  for(auto vxcItr=k0Container->cbegin(); vxcItr!=k0Container->cend(); ++vxcItr) {
724 
725  // Check the passed flag first
726  const xAOD::Vertex* vtx = *vxcItr;
727  SG::AuxElement::Accessor<Char_t> flagAcc1("passed_K0");
728  if(flagAcc1.isAvailable(*vtx)){
729  if(!flagAcc1(*vtx)) continue;
730  }
731 
732  // Check K_S0 candidate invariant mass and skip if need be
733  double mass_K0 = m_V0Tools->invariantMass(*vxcItr, massesK0);
734  ATH_MSG_DEBUG("K_S0 mass " << mass_K0);
735  if (mass_K0 < m_K0MassLower || mass_K0 > m_K0MassUpper) {
736  ATH_MSG_DEBUG(" Original K_S0 candidate rejected by the mass cut: mass = "
737  << mass_K0 << " != (" << m_K0MassLower << ", " << m_K0MassUpper << ")" );
738  continue;
739  }
740 
741  selectedK0Candidates.push_back(*vxcItr);
742  }
743  if(selectedK0Candidates.size()<1) return StatusCode::SUCCESS;
744 
745  // Select J/psi D*+ candidates
746  // Iterate over Jpsi+pi vertices
747  for(auto jpsipiItr=selectedJpsipiCandidates.cbegin(); jpsipiItr!=selectedJpsipiCandidates.cend(); ++jpsipiItr) {
748 
749  size_t jpsipiTrkNum = (*jpsipiItr)->nTrackParticles();
750  tracksJpsipi.clear();
751  tracksJpsi.clear();
752  for( unsigned int it=0; it<jpsipiTrkNum; it++) tracksJpsipi.push_back((*jpsipiItr)->trackParticle(it));
753  for( unsigned int it=0; it<jpsipiTrkNum-1; it++) tracksJpsi.push_back((*jpsipiItr)->trackParticle(it));
754 
755  if (tracksJpsipi.size() != 3 || massesJpsipi.size() != 3 ) {
756  ATH_MSG_INFO("problems with Jpsi+pi input");
757  }
758 
759  bool tagD0(true);
760  if(abs(m_Dx_pid)==421 && (*jpsipiItr)->trackParticle(2)->charge()==-1) tagD0 = false;
761 
762  TLorentzVector p4_pi1; // Momentum of soft pion
763  p4_pi1.SetPtEtaPhiM((*jpsipiItr)->trackParticle(2)->pt(),
764  (*jpsipiItr)->trackParticle(2)->eta(),
765  (*jpsipiItr)->trackParticle(2)->phi(), m_vtx0Daug3MassHypo);
766 
767  // Iterate over D0/D0bar vertices
768  for(auto d0Itr=selectedD0Candidates.cbegin(); d0Itr!=selectedD0Candidates.cend(); ++d0Itr) {
769 
770  // Check identical tracks in input
771  if(std::find(tracksJpsipi.cbegin(), tracksJpsipi.cend(), (*d0Itr)->trackParticle(0)) != tracksJpsipi.cend()) continue;
772  if(std::find(tracksJpsipi.cbegin(), tracksJpsipi.cend(), (*d0Itr)->trackParticle(1)) != tracksJpsipi.cend()) continue;
773 
774  TLorentzVector p4_ka, p4_pi2;
775  if(tagD0){ // for D*+
776  p4_pi2.SetPtEtaPhiM((*d0Itr)->trackParticle(0)->pt(),
777  (*d0Itr)->trackParticle(0)->eta(),
778  (*d0Itr)->trackParticle(0)->phi(), m_vtx1Daug1MassHypo);
779  p4_ka.SetPtEtaPhiM( (*d0Itr)->trackParticle(1)->pt(),
780  (*d0Itr)->trackParticle(1)->eta(),
781  (*d0Itr)->trackParticle(1)->phi(), m_vtx1Daug2MassHypo);
782  }else{ // change the order in the case of D*-
783  p4_pi2.SetPtEtaPhiM((*d0Itr)->trackParticle(1)->pt(),
784  (*d0Itr)->trackParticle(1)->eta(),
785  (*d0Itr)->trackParticle(1)->phi(), m_vtx1Daug1MassHypo);
786  p4_ka.SetPtEtaPhiM( (*d0Itr)->trackParticle(0)->pt(),
787  (*d0Itr)->trackParticle(0)->eta(),
788  (*d0Itr)->trackParticle(0)->phi(), m_vtx1Daug2MassHypo);
789  }
790  // Check D*+/- candidate invariant mass and skip if need be
791  double mass_Dst= (p4_pi1 + p4_ka + p4_pi2).M();
792  ATH_MSG_DEBUG("D*+/- mass " << mass_Dst);
793  if (mass_Dst < m_DstMassLower || mass_Dst > m_DstMassUpper) {
794  ATH_MSG_DEBUG(" Original D*+/- candidate rejected by the mass cut: mass = "
795  << mass_Dst << " != (" << m_DstMassLower << ", " << m_DstMassUpper << ")" );
796  continue;
797  }
798 
799  size_t d0TrkNum = (*d0Itr)->nTrackParticles();
800  tracksD0.clear();
801  for( unsigned int it=0; it<d0TrkNum; it++) tracksD0.push_back((*d0Itr)->trackParticle(it));
802  if (tracksD0.size() != 2 || massesD0.size() != 2 ) {
803  ATH_MSG_INFO("problems with D0 input");
804  }
805 
806  // Iterate over K0 vertices
807  for(auto k0Itr=selectedK0Candidates.cbegin(); k0Itr!=selectedK0Candidates.cend(); ++k0Itr) {
808 
809  // Check identical tracks in input
810  if(std::find(tracksJpsipi.cbegin(), tracksJpsipi.cend(), (*k0Itr)->trackParticle(0)) != tracksJpsipi.cend()) continue;
811  if(std::find(tracksJpsipi.cbegin(), tracksJpsipi.cend(), (*k0Itr)->trackParticle(1)) != tracksJpsipi.cend()) continue;
812  if(std::find(tracksD0.cbegin(), tracksD0.cend(), (*k0Itr)->trackParticle(0)) != tracksD0.cend()) continue;
813  if(std::find(tracksD0.cbegin(), tracksD0.cend(), (*k0Itr)->trackParticle(1)) != tracksD0.cend()) continue;
814 
815  size_t k0TrkNum = (*k0Itr)->nTrackParticles();
816  tracksK0.clear();
817  for( unsigned int it=0; it<k0TrkNum; it++) tracksK0.push_back((*k0Itr)->trackParticle(it));
818  if (tracksK0.size() != 2 || massesK0.size() != 2 ) {
819  ATH_MSG_INFO("problems with K0 input");
820  }
821 
822  ATH_MSG_DEBUG("using tracks" << tracksJpsipi[0] << ", " << tracksJpsipi[1] << ", " << tracksJpsipi[2] << ", " << tracksD0[0] << ", " << tracksD0[1] << ", " << tracksK0[0] << ", " << tracksK0[1]);
823 
824  tracksBc.clear();
825  for( unsigned int it=0; it<jpsipiTrkNum; it++) tracksBc.push_back((*jpsipiItr)->trackParticle(it));
826  for( unsigned int it=0; it<d0TrkNum; it++) tracksBc.push_back((*d0Itr)->trackParticle(it));
827  for( unsigned int it=0; it<k0TrkNum; it++) tracksBc.push_back((*k0Itr)->trackParticle(it));
828 
829 
830  // Apply the user's settings to the fitter
831  // Reset
832  std::unique_ptr<Trk::IVKalState> state (m_iVertexFitter->makeState());
833  // Robustness
834  int robustness = 0;
835  m_iVertexFitter->setRobustness(robustness, *state);
836  // Build up the topology
837  // Vertex list
838  std::vector<Trk::VertexID> vrtList;
839  // K_S0 vertex
840  Trk::VertexID vK0ID;
841  if (m_constrK0) {
842  vK0ID = m_iVertexFitter->startVertex(tracksK0,massesK0, *state, mass_k0);
843  } else {
844  vK0ID = m_iVertexFitter->startVertex(tracksK0,massesK0, *state);
845  }
846  vrtList.push_back(vK0ID);
847  // D0 vertex
848  Trk::VertexID vD0ID;
849  if (m_constrD0) {
850  if(tagD0) vD0ID = m_iVertexFitter->nextVertex(tracksD0,massesD0, *state, mass_d0);
851  else vD0ID = m_iVertexFitter->nextVertex(tracksD0,massesD0b, *state, mass_d0);
852  } else {
853  if(tagD0) vD0ID = m_iVertexFitter->nextVertex(tracksD0,massesD0, *state);
854  else vD0ID = m_iVertexFitter->nextVertex(tracksD0,massesD0b, *state);
855  }
856  vrtList.push_back(vD0ID);
857  // B vertex including Jpsi+pi
858  Trk::VertexID vBcID = m_iVertexFitter->nextVertex(tracksJpsipi,massesJpsipi,vrtList, *state);
859  if (m_constrJpsi) {
860  std::vector<Trk::VertexID> cnstV;
861  cnstV.clear();
862  if ( !m_iVertexFitter->addMassConstraint(vBcID,tracksJpsi,cnstV, *state, m_mass_jpsi).isSuccess() ) {
863  ATH_MSG_WARNING("addMassConstraint failed");
864  //return StatusCode::FAILURE;
865  }
866  }
867  // Do the work
868  std::unique_ptr<Trk::VxCascadeInfo> result(m_iVertexFitter->fitCascade(*state));
869 
870  if (result != nullptr) {
871 
872  // reset links to original tracks
873  BPhysPVCascadeTools::PrepareVertexLinks(result.get(), trackContainer);
874  ATH_MSG_DEBUG("storing tracks " << ((result->vertices())[0])->trackParticle(0) << ", "
875  << ((result->vertices())[0])->trackParticle(1) << ", "
876  << ((result->vertices())[1])->trackParticle(0) << ", "
877  << ((result->vertices())[1])->trackParticle(1) << ", "
878  << ((result->vertices())[2])->trackParticle(0) << ", "
879  << ((result->vertices())[2])->trackParticle(1) << ", "
880  << ((result->vertices())[2])->trackParticle(2));
881  // necessary to prevent memory leak
882  result->setSVOwnership(true);
883 
884  // Chi2/DOF cut
885  double bChi2DOF = result->fitChi2()/result->nDoF();
886  ATH_MSG_DEBUG("Candidate chi2/DOF is " << bChi2DOF);
887  bool chi2CutPassed = (m_chi2cut <= 0.0 || bChi2DOF < m_chi2cut);
888 
889  const std::vector< std::vector<TLorentzVector> > &moms = result->getParticleMoms();
890  double mass = m_CascadeTools->invariantMass(moms[2]);
891  if(chi2CutPassed) {
892  if (mass >= m_MassLower && mass <= m_MassUpper) {
893  cascadeinfoContainer->push_back(result.release());
894  } else {
895  ATH_MSG_DEBUG("Candidate rejected by the mass cut: mass = "
896  << mass << " != (" << m_MassLower << ", " << m_MassUpper << ")" );
897  }
898  }
899  }
900 
901  } //Iterate over K0 vertices
902 
903  } //Iterate over D0 vertices
904 
905  } //Iterate over Jpsi+pi vertices
906 
907  ATH_MSG_DEBUG("cascadeinfoContainer size " << cascadeinfoContainer->size());
908 
909  return StatusCode::SUCCESS;
910  }
911 
912 }
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
xAOD::BPhysHypoHelper::setMass
bool setMass(const float val)
Set given invariant mass and its error.
Definition: BPhysHypoHelper.cxx:49
xAOD::TrackParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: TrackParticle_v1.cxx:73
xAOD::Vertex_v1::x
float x() const
Returns the x position.
V0Tools.h
DerivationFramework::JpsiPlusDs1Cascade::m_vtx0Daug2MassHypo
double m_vtx0Daug2MassHypo
Definition: JpsiPlusDs1Cascade.h:73
DerivationFramework::JpsiPlusDs1Cascade::m_eventInfo_key
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfo_key
Definition: JpsiPlusDs1Cascade.h:88
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
get_generator_info.result
result
Definition: get_generator_info.py:21
xAOD::VertexAuxContainer_v1
Temporary container used until we have I/O for AuxStoreInternal.
Definition: VertexAuxContainer_v1.h:32
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
Trk::VxCascadeInfo
Definition: VxCascadeInfo.h:75
Trk::VertexID
int VertexID
Definition: IVertexCascadeFitter.h:23
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
DerivationFramework::JpsiPlusDs1Cascade::m_vtx2Daug1MassHypo
double m_vtx2Daug1MassHypo
Definition: JpsiPlusDs1Cascade.h:77
DerivationFramework::BPhysPVCascadeTools::LinkVertices
static bool LinkVertices(SG::AuxElement::Decorator< VertexLinkVector > &decor, const std::vector< const xAOD::Vertex * > &vertices, const xAOD::VertexContainer *vertexContainer, const xAOD::Vertex *vert)
Definition: BPhysPVCascadeTools.cxx:460
SG::Accessor
Helper class to provide type-safe access to aux data.
Definition: Control/AthContainers/AthContainers/Accessor.h:66
xAOD::TrackParticle_v1::charge
float charge() const
Returns the charge.
Definition: TrackParticle_v1.cxx:150
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
DerivationFramework::JpsiPlusDs1Cascade::m_CascadeTools
ToolHandle< DerivationFramework::CascadeTools > m_CascadeTools
Definition: JpsiPlusDs1Cascade.h:92
xAOD::TrackParticle_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition: TrackParticle_v1.cxx:77
DerivationFramework::JpsiPlusDs1Cascade::m_PV_minNTracks
size_t m_PV_minNTracks
Definition: JpsiPlusDs1Cascade.h:101
DerivationFramework::JpsiPlusDs1Cascade::m_vtx0Daug3MassHypo
double m_vtx0Daug3MassHypo
Definition: JpsiPlusDs1Cascade.h:74
DerivationFramework::JpsiPlusDs1Cascade::m_constrJpsi
bool m_constrJpsi
Definition: JpsiPlusDs1Cascade.h:85
skel.it
it
Definition: skel.GENtoEVGEN.py:423
test_pyathena.pt
pt
Definition: test_pyathena.py:11
DataVector::cend
const_iterator cend() const noexcept
Return a const_iterator pointing past the end of the collection.
DerivationFramework::JpsiPlusDs1Cascade::m_vtx1MassHypo
double m_vtx1MassHypo
Definition: JpsiPlusDs1Cascade.h:70
LArG4FSStartPointFilter.evt
evt
Definition: LArG4FSStartPointFilter.py:42
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
DerivationFramework::JpsiPlusDs1Cascade::getParticleMass
double getParticleMass(int particlecode) const
Definition: JpsiPlusDs1Cascade.cxx:28
xAOD::VertexContainer
VertexContainer_v1 VertexContainer
Definition of the current "Vertex container version".
Definition: VertexContainer.h:14
x
#define x
DerivationFramework::JpsiPlusDs1Cascade::m_VxPrimaryCandidateName
std::string m_VxPrimaryCandidateName
Name of primary vertex container.
Definition: JpsiPlusDs1Cascade.h:55
dqt_zlumi_pandas.mass
mass
Definition: dqt_zlumi_pandas.py:170
DerivationFramework::JpsiPlusDs1Cascade::m_refitPV
bool m_refitPV
Definition: JpsiPlusDs1Cascade.h:94
TrkVKalVrtFitter.h
DerivationFramework::JpsiPlusDs1Cascade::m_hypoName
std::string m_hypoName
name of the mass hypothesis.
Definition: JpsiPlusDs1Cascade.h:96
runBeamSpotCalibration.helper
helper
Definition: runBeamSpotCalibration.py:112
DerivationFramework::JpsiPlusDs1Cascade::m_jpsiMassUpper
double m_jpsiMassUpper
Definition: JpsiPlusDs1Cascade.h:58
DerivationFramework::JpsiPlusDs1Cascade::m_vertexContainerKey
std::string m_vertexContainerKey
Definition: JpsiPlusDs1Cascade.h:50
DerivationFramework::JpsiPlusDs1Cascade::m_D0MassUpper
double m_D0MassUpper
Definition: JpsiPlusDs1Cascade.h:62
AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
DerivationFramework::JpsiPlusDs1Cascade::m_V0Tools
ToolHandle< Trk::V0Tools > m_V0Tools
Definition: JpsiPlusDs1Cascade.h:91
xAOD::BPhysHypoHelper
Definition: BPhysHypoHelper.h:73
DerivationFramework::BPhysPVCascadeTools::SetVectorInfo
static void SetVectorInfo(xAOD::BPhysHelper &, const Trk::VxCascadeInfo *)
Definition: BPhysPVCascadeTools.cxx:424
BPHYS_CHECK
#define BPHYS_CHECK(EXP)
Useful CHECK macro.
Definition: BPhysHelper.h:738
DerivationFramework::JpsiPlusDs1Cascade::m_constrK0
bool m_constrK0
Definition: JpsiPlusDs1Cascade.h:84
DerivationFramework::JpsiPlusDs1Cascade::performSearch
StatusCode performSearch(std::vector< Trk::VxCascadeInfo * > *cascadeinfoContainer) const
Definition: JpsiPlusDs1Cascade.cxx:593
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
DerivationFramework::JpsiPlusDs1Cascade::m_vtx2Daug2MassHypo
double m_vtx2Daug2MassHypo
Definition: JpsiPlusDs1Cascade.h:78
SG::Decorator
Helper class to provide type-safe access to aux data.
Definition: Decorator.h:58
DerivationFramework::JpsiPlusDs1Cascade::addBranches
virtual StatusCode addBranches() const override
Pass the thinning service
Definition: JpsiPlusDs1Cascade.cxx:69
xAOD::VertexAuxContainer
VertexAuxContainer_v1 VertexAuxContainer
Definition of the current jet auxiliary container.
Definition: VertexAuxContainer.h:19
DerivationFramework::JpsiPlusDs1Cascade::m_refPVContainerName
std::string m_refPVContainerName
Definition: JpsiPlusDs1Cascade.h:95
lumiFormat.i
int i
Definition: lumiFormat.py:92
beamspotman.n
n
Definition: beamspotman.py:731
DerivationFramework::JpsiPlusDs1Cascade::m_vtx1Daug2MassHypo
double m_vtx1Daug2MassHypo
Definition: JpsiPlusDs1Cascade.h:76
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
BPhysHypoHelper.h
: B-physcis xAOD helpers.
DerivationFramework::JpsiPlusDs1Cascade::m_MassLower
double m_MassLower
Definition: JpsiPlusDs1Cascade.h:67
DerivationFramework::JpsiPlusDs1Cascade::m_cascadeOutputsKeys
std::vector< std::string > m_cascadeOutputsKeys
Definition: JpsiPlusDs1Cascade.h:53
DerivationFramework::JpsiPlusDs1Cascade::m_jpsiMassLower
double m_jpsiMassLower
Definition: JpsiPlusDs1Cascade.h:57
DerivationFramework::JpsiPlusDs1Cascade::m_DoVertexType
int m_DoVertexType
Definition: JpsiPlusDs1Cascade.h:100
DerivationFramework::BPhysPVCascadeTools::PrepareVertexLinks
static void PrepareVertexLinks(Trk::VxCascadeInfo *result, const xAOD::TrackParticleContainer *importedTrackCollection)
Definition: BPhysPVCascadeTools.cxx:204
MUON
xAOD::Muon MUON
D3PD INCLUDES.
Definition: TileCellFillerTool.h:37
DerivationFramework::JpsiPlusDs1Cascade::m_jpsipiMassLower
double m_jpsipiMassLower
Definition: JpsiPlusDs1Cascade.h:59
DerivationFramework::JpsiPlusDs1Cascade::m_chi2cut
double m_chi2cut
Definition: JpsiPlusDs1Cascade.h:86
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
xAOD::Vertex_v1::trackParticle
const TrackParticle * trackParticle(size_t i) const
Get the pointer to a given track that was used in vertex reco.
Definition: Vertex_v1.cxx:249
DerivationFramework::JpsiPlusDs1Cascade::m_DstMassLower
double m_DstMassLower
Definition: JpsiPlusDs1Cascade.h:65
DerivationFramework::TrackBag
std::vector< const xAOD::TrackParticle * > TrackBag
Definition: BPhysAddMuonBasedInvMass.h:32
xAOD::Vertex_v1::z
float z() const
Returns the z position.
DerivationFramework
THE reconstruction tool.
Definition: ParticleSortingAlg.h:24
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
DerivationFramework::VertexLink
ElementLink< xAOD::VertexContainer > VertexLink
Definition: Cascade3Plus1.cxx:23
DataVector
Derived DataVector<T>.
Definition: DataVector.h:581
BPhysPVCascadeTools.h
JpsiPlusDs1Cascade.h
DerivationFramework::BPhysPVCascadeTools
Definition: BPhysPVCascadeTools.h:34
DerivationFramework::JpsiPlusDs1Cascade::m_vertexK0ContainerKey
std::string m_vertexK0ContainerKey
Definition: JpsiPlusDs1Cascade.h:52
CascadeTools.h
DerivationFramework::JpsiPlusDs1Cascade::m_K0MassLower
double m_K0MassLower
Definition: JpsiPlusDs1Cascade.h:63
DerivationFramework::JpsiPlusDs1Cascade::m_PV_max
int m_PV_max
Definition: JpsiPlusDs1Cascade.h:99
DerivationFramework::JpsiPlusDs1Cascade::m_vtx0MassHypo
double m_vtx0MassHypo
Definition: JpsiPlusDs1Cascade.h:69
IVertexFitter.h
DerivationFramework::JpsiPlusDs1Cascade::initialize
virtual StatusCode initialize() override
Definition: JpsiPlusDs1Cascade.cxx:33
VxCascadeInfo.h
DerivationFramework::JpsiPlusDs1Cascade::m_particleDataTable
const HepPDT::ParticleDataTable * m_particleDataTable
Definition: JpsiPlusDs1Cascade.h:80
DerivationFramework::JpsiPlusDs1Cascade::JpsiPlusDs1Cascade
JpsiPlusDs1Cascade(const std::string &t, const std::string &n, const IInterface *p)
Definition: JpsiPlusDs1Cascade.cxx:506
mc.mass_b
mass_b
Definition: mc.PhPy8EG_A14NNPDF23_gg4l_example.py:21
DerivationFramework::VertexLinkVector
std::vector< VertexLink > VertexLinkVector
Definition: Cascade3Plus1.cxx:24
VertexContainer.h
DerivationFramework::JpsiPlusDs1Cascade::m_vtx1Daug1MassHypo
double m_vtx1Daug1MassHypo
Definition: JpsiPlusDs1Cascade.h:75
DerivationFramework::JpsiPlusDs1Cascade::m_pvRefitter
ToolHandle< Analysis::PrimaryVertexRefitter > m_pvRefitter
Definition: JpsiPlusDs1Cascade.h:90
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
DerivationFramework::JpsiPlusDs1Cascade::m_MassUpper
double m_MassUpper
Definition: JpsiPlusDs1Cascade.h:68
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
DerivationFramework::JpsiPlusDs1Cascade::m_vertexD0ContainerKey
std::string m_vertexD0ContainerKey
Definition: JpsiPlusDs1Cascade.h:51
DerivationFramework::JpsiPlusDs1Cascade::~JpsiPlusDs1Cascade
~JpsiPlusDs1Cascade()
Definition: JpsiPlusDs1Cascade.cxx:591
xAOD::Vertex_v1::y
float y() const
Returns the y position.
DerivationFramework::JpsiPlusDs1Cascade::m_Dx_pid
int m_Dx_pid
Definition: JpsiPlusDs1Cascade.h:82
DerivationFramework::JpsiPlusDs1Cascade::m_vtx2MassHypo
double m_vtx2MassHypo
Definition: JpsiPlusDs1Cascade.h:71
DerivationFramework::JpsiPlusDs1Cascade::m_D0MassLower
double m_D0MassLower
Definition: JpsiPlusDs1Cascade.h:61
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
SG::ConstAccessor< T, AuxAllocator_t< T > >::isAvailable
bool isAvailable(const ELT &e) const
Test to see if this variable exists in the store.
DataVector::cbegin
const_iterator cbegin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
DerivationFramework::JpsiPlusDs1Cascade::m_iVertexFitter
ToolHandle< Trk::TrkVKalVrtFitter > m_iVertexFitter
Definition: JpsiPlusDs1Cascade.h:89
AthAlgTool
Definition: AthAlgTool.h:26
DerivationFramework::JpsiPlusDs1Cascade::m_mass_jpsi
double m_mass_jpsi
Definition: JpsiPlusDs1Cascade.h:81
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
DerivationFramework::JpsiPlusDs1Cascade::m_vtx0Daug1MassHypo
double m_vtx0Daug1MassHypo
Definition: JpsiPlusDs1Cascade.h:72
DerivationFramework::JpsiPlusDs1Cascade::m_jpsipiMassUpper
double m_jpsipiMassUpper
Definition: JpsiPlusDs1Cascade.h:60
DerivationFramework::JpsiPlusDs1Cascade::m_K0MassUpper
double m_K0MassUpper
Definition: JpsiPlusDs1Cascade.h:64
DerivationFramework::JpsiPlusDs1Cascade::m_constrD0
bool m_constrD0
Definition: JpsiPlusDs1Cascade.h:83
HepMCHelpers.h
xAOD::BPhysHypoHelper::setMassErr
bool setMassErr(const float val)
invariant mass error
Definition: BPhysHypoHelper.cxx:54
DerivationFramework::JpsiPlusDs1Cascade::m_DstMassUpper
double m_DstMassUpper
Definition: JpsiPlusDs1Cascade.h:66
VertexAuxContainer.h
xAOD::TrackParticle_v1::phi
virtual double phi() const override final
The azimuthal angle ( ) of the particle (has range to .)
Generated on Sun Jun 30 2024 21:19:15 for ATLAS Offline Software by   doxygen 1.8.18