ATLAS Offline Software
JpsiPlusPsiCascade.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3  Contact: Xin Chen <xin.chen@cern.ch>
4 */
5 #include "DerivationFrameworkBPhys/JpsiPlusPsiCascade.h"
6 #include "TrkVertexFitterInterfaces/IVertexFitter.h"
7 #include "TrkVKalVrtFitter/TrkVKalVrtFitter.h"
8 #include "TrkVKalVrtFitter/VxCascadeInfo.h"
9 #include "TrkVertexAnalysisUtils/V0Tools.h"
10 #include "GaudiKernel/IPartPropSvc.h"
11 #include "DerivationFrameworkBPhys/CascadeTools.h"
12 #include "DerivationFrameworkBPhys/BPhysPVCascadeTools.h"
13 #include "xAODTracking/VertexAuxContainer.h"
14 #include "xAODBPhys/BPhysHypoHelper.h"
15 #include "HepPDT/ParticleDataTable.hh"
16 #include "TruthUtils/HepMCHelpers.h"
17 #include <algorithm>
18 
19 namespace DerivationFramework {
20  typedef ElementLink<xAOD::VertexContainer> VertexLink;
21  typedef std::vector<VertexLink> VertexLinkVector;
22 
23  StatusCode JpsiPlusPsiCascade::initialize() {
24  // retrieving vertex Fitter
25  ATH_CHECK( m_iVertexFitter.retrieve() );
26 
27  // retrieve PV refitter
28  ATH_CHECK( m_pvRefitter.retrieve() );
29 
30  // retrieving the V0 tools
31  ATH_CHECK( m_V0Tools.retrieve() );
32 
33  // retrieving the Cascade tools
34  ATH_CHECK( m_CascadeTools.retrieve() );
35 
36  ATH_CHECK( m_vertexContainerKey.initialize() );
37  ATH_CHECK( m_vertexPsiContainerKey.initialize() );
38  ATH_CHECK( m_VxPrimaryCandidateName.initialize() );
39  ATH_CHECK( m_trackContainerName.initialize() );
40  ATH_CHECK( m_refPVContainerName.initialize() );
41  ATH_CHECK( m_cascadeOutputsKeys.initialize() );
42  ATH_CHECK( m_eventInfo_key.initialize() );
43 
44  IPartPropSvc* partPropSvc = nullptr;
45  ATH_CHECK( service("PartPropSvc", partPropSvc, true) );
46  auto pdt = partPropSvc->PDT();
47 
48  // retrieve particle masses
49  // https://gitlab.cern.ch/atlas/athena/-/blob/main/Generators/TruthUtils/TruthUtils/AtlasPID.h
50  if(m_mass_jpsi < 0.) m_mass_jpsi = BPhysPVCascadeTools::getParticleMass(pdt, MC::JPSI);
51  if(m_mass_jpsi2 < 0.) m_mass_jpsi2 = BPhysPVCascadeTools::getParticleMass(pdt, MC::JPSI);
52  if(m_mass_psi < 0.) m_mass_psi = BPhysPVCascadeTools::getParticleMass(pdt, MC::PSI2S);
53 
54  if(m_vtx1Daug1MassHypo < 0.) m_vtx1Daug1MassHypo = BPhysPVCascadeTools::getParticleMass(pdt, MC::MUON);
55  if(m_vtx1Daug2MassHypo < 0.) m_vtx1Daug2MassHypo = BPhysPVCascadeTools::getParticleMass(pdt, MC::MUON);
56  if(m_vtx1Daug3MassHypo < 0.) m_vtx1Daug3MassHypo = BPhysPVCascadeTools::getParticleMass(pdt, MC::PIPLUS);
57  if(m_vtx1Daug4MassHypo < 0.) m_vtx1Daug4MassHypo = BPhysPVCascadeTools::getParticleMass(pdt, MC::PIPLUS);
58  if(m_vtx2Daug1MassHypo < 0.) m_vtx2Daug1MassHypo = BPhysPVCascadeTools::getParticleMass(pdt, MC::MUON);
59  if(m_vtx2Daug2MassHypo < 0.) m_vtx2Daug2MassHypo = BPhysPVCascadeTools::getParticleMass(pdt, MC::MUON);
60 
61  return StatusCode::SUCCESS;
62  }
63 
64  StatusCode JpsiPlusPsiCascade::addBranches() const {
65  if (m_vtx1Daug_num != 3 && m_vtx1Daug_num != 4) {
66  ATH_MSG_FATAL("Incorrect number of Psi daughters (should be 3 or 4)");
67  return StatusCode::FAILURE;
68  }
69 
70  constexpr int topoN = 3;
71  if(m_cascadeOutputsKeys.size() != topoN) {
72  ATH_MSG_FATAL("Incorrect number of VtxContainers");
73  return StatusCode::FAILURE;
74  }
75  std::array<SG::WriteHandle<xAOD::VertexContainer>, topoN> VtxWriteHandles; int ikey(0);
76  for(const SG::WriteHandleKey<xAOD::VertexContainer>& key : m_cascadeOutputsKeys) {
77  VtxWriteHandles[ikey] = SG::WriteHandle<xAOD::VertexContainer>(key);
78  ATH_CHECK( VtxWriteHandles[ikey].record(std::make_unique<xAOD::VertexContainer>(), std::make_unique<xAOD::VertexAuxContainer>()) );
79  ikey++;
80  }
81 
82  //----------------------------------------------------
83  // retrieve primary vertices
84  //----------------------------------------------------
85  SG::ReadHandle<xAOD::VertexContainer> pvContainer(m_VxPrimaryCandidateName);
86  ATH_CHECK( pvContainer.isValid() );
87  if (pvContainer.cptr()->size()==0) {
88  ATH_MSG_WARNING("You have no primary vertices: " << pvContainer.cptr()->size());
89  return StatusCode::RECOVERABLE;
90  }
91 
92  //----------------------------------------------------
93  // Record refitted primary vertices
94  //----------------------------------------------------
95  SG::WriteHandle<xAOD::VertexContainer> refPvContainer;
96  if(m_refitPV) {
97  refPvContainer = SG::WriteHandle<xAOD::VertexContainer>(m_refPVContainerName);
98  ATH_CHECK( refPvContainer.record(std::make_unique<xAOD::VertexContainer>(), std::make_unique<xAOD::VertexAuxContainer>()) );
99  }
100 
101  std::vector<Trk::VxCascadeInfo*> cascadeinfoContainer;
102  std::vector<Trk::VxCascadeInfo*> cascadeinfoContainer_noConstr;
103  ATH_CHECK(performSearch(&cascadeinfoContainer,&cascadeinfoContainer_noConstr));
104 
105  SG::ReadHandle<xAOD::EventInfo> evt(m_eventInfo_key);
106  ATH_CHECK( evt.isValid() );
107  BPhysPVCascadeTools helper(&(*m_CascadeTools), evt.cptr());
108  helper.SetMinNTracksInPV(m_PV_minNTracks);
109 
110  // Decorators for the vertices
111  SG::AuxElement::Decorator<VertexLinkVector> CascadeLinksDecor("CascadeVertexLinks");
112  SG::AuxElement::Decorator<VertexLinkVector> PsiLinksDecor("PsiVertexLinks");
113  SG::AuxElement::Decorator<VertexLinkVector> JpsiLinksDecor("JpsiVertexLinks");
114  SG::AuxElement::Decorator<float> chi2_decor("ChiSquared");
115  SG::AuxElement::Decorator<int> ndof_decor("nDoF");
116  SG::AuxElement::Decorator<float> chi2_nc_decor("ChiSquared_nc");
117  SG::AuxElement::Decorator<int> ndof_nc_decor("nDoF_nc");
118  SG::AuxElement::Decorator<float> Pt_decor("Pt");
119  SG::AuxElement::Decorator<float> PtErr_decor("PtErr");
120  SG::AuxElement::Decorator<float> chi2_SV1_decor("ChiSquared_SV1");
121  SG::AuxElement::Decorator<float> chi2_nc_SV1_decor("ChiSquared_nc_SV1");
122  SG::AuxElement::Decorator<float> chi2_V1_decor("ChiSquared_V1");
123  SG::AuxElement::Decorator<int> ndof_V1_decor("nDoF_V1");
124  SG::AuxElement::Decorator<float> lxy_SV1_decor("lxy_SV1");
125  SG::AuxElement::Decorator<float> lxyErr_SV1_decor("lxyErr_SV1");
126  SG::AuxElement::Decorator<float> a0xy_SV1_decor("a0xy_SV1");
127  SG::AuxElement::Decorator<float> a0xyErr_SV1_decor("a0xyErr_SV1");
128  SG::AuxElement::Decorator<float> a0z_SV1_decor("a0z_SV1");
129  SG::AuxElement::Decorator<float> a0zErr_SV1_decor("a0zErr_SV1");
130  SG::AuxElement::Decorator<float> chi2_SV2_decor("ChiSquared_SV2");
131  SG::AuxElement::Decorator<float> chi2_nc_SV2_decor("ChiSquared_nc_SV2");
132  SG::AuxElement::Decorator<float> chi2_V2_decor("ChiSquared_V2");
133  SG::AuxElement::Decorator<int> ndof_V2_decor("nDoF_V2");
134  SG::AuxElement::Decorator<float> lxy_SV2_decor("lxy_SV2");
135  SG::AuxElement::Decorator<float> lxyErr_SV2_decor("lxyErr_SV2");
136  SG::AuxElement::Decorator<float> a0xy_SV2_decor("a0xy_SV2");
137  SG::AuxElement::Decorator<float> a0xyErr_SV2_decor("a0xyErr_SV2");
138  SG::AuxElement::Decorator<float> a0z_SV2_decor("a0z_SV2");
139  SG::AuxElement::Decorator<float> a0zErr_SV2_decor("a0zErr_SV2");
140 
141  // Get the containers and identify the input Jpsi and Psi
142  SG::ReadHandle<xAOD::VertexContainer> psiContainer(m_vertexPsiContainerKey);
143  ATH_CHECK( psiContainer.isValid() );
144  SG::ReadHandle<xAOD::VertexContainer> jpsiContainer(m_vertexContainerKey);
145  ATH_CHECK( jpsiContainer.isValid() );
146 
147  for(size_t ic=0; ic<cascadeinfoContainer.size(); ic++) {
148  Trk::VxCascadeInfo* cascade_info = cascadeinfoContainer[ic];
149  if(cascade_info==nullptr) {
150  ATH_MSG_ERROR("CascadeInfo is null");
151  continue;
152  }
153 
154  Trk::VxCascadeInfo* cascade_info_noConstr = cascadeinfoContainer_noConstr[ic];
155 
156  const std::vector<xAOD::Vertex*> &cascadeVertices = cascade_info->vertices();
157  if(cascadeVertices.size() != topoN) ATH_MSG_ERROR("Incorrect number of vertices");
158  if(cascadeVertices[0]==nullptr || cascadeVertices[1]==nullptr || cascadeVertices[2]==nullptr) ATH_MSG_ERROR("Error null vertex");
159  // Keep vertices
160  for(int i=0; i<topoN; i++) VtxWriteHandles[i].ptr()->push_back(cascadeVertices[i]);
161 
162  cascade_info->setSVOwnership(false); // Prevent Container from deleting vertices
163  const auto mainVertex = cascadeVertices[2]; // this is the mother vertex
164  const std::vector< std::vector<TLorentzVector> > &moms = cascade_info->getParticleMoms();
165 
166  // Set links to cascade vertices
167  std::vector<VertexLink> precedingVertexLinks;
168  VertexLink vertexLink1;
169  vertexLink1.setElement(cascadeVertices[0]);
170  vertexLink1.setStorableObject(*VtxWriteHandles[0].ptr());
171  if( vertexLink1.isValid() ) precedingVertexLinks.push_back( vertexLink1 );
172  VertexLink vertexLink2;
173  vertexLink2.setElement(cascadeVertices[1]);
174  vertexLink2.setStorableObject(*VtxWriteHandles[1].ptr());
175  if( vertexLink2.isValid() ) precedingVertexLinks.push_back( vertexLink2 );
176  CascadeLinksDecor(*mainVertex) = precedingVertexLinks;
177 
178  // Identify the input Jpsi
179  const xAOD::Vertex* jpsiVertex = BPhysPVCascadeTools::FindVertex<2>(jpsiContainer.cptr(), cascadeVertices[1]);
180  // Identify the input Psi
181  const xAOD::Vertex* psiVertex(0);
182  if(m_vtx1Daug_num==4) psiVertex = BPhysPVCascadeTools::FindVertex<4>(psiContainer.cptr(), cascadeVertices[0]);
183  else psiVertex = BPhysPVCascadeTools::FindVertex<3>(psiContainer.cptr(), cascadeVertices[0]);
184 
185  // Set links to input vertices
186  std::vector<const xAOD::Vertex*> jpsiVerticestoLink;
187  if(jpsiVertex) jpsiVerticestoLink.push_back(jpsiVertex);
188  else ATH_MSG_WARNING("Could not find linking Jpsi");
189  if(!BPhysPVCascadeTools::LinkVertices(JpsiLinksDecor, jpsiVerticestoLink, jpsiContainer.cptr(), mainVertex)) ATH_MSG_ERROR("Error decorating with Jpsi vertex");
190 
191  std::vector<const xAOD::Vertex*> psiVerticestoLink;
192  if(psiVertex) psiVerticestoLink.push_back(psiVertex);
193  else ATH_MSG_WARNING("Could not find linking Psi");
194  if(!BPhysPVCascadeTools::LinkVertices(PsiLinksDecor, psiVerticestoLink, psiContainer.cptr(), mainVertex)) ATH_MSG_ERROR("Error decorating with Psi vertex");
195 
196  xAOD::BPhysHypoHelper vtx(m_hypoName, mainVertex);
197 
198  // Get refitted track momenta from all vertices, charged tracks only
199  BPhysPVCascadeTools::SetVectorInfo(vtx, cascade_info);
200  vtx.setPass(true);
201 
202  //
203  // Decorate main vertex
204  //
205  // mass, mass error
206  // https://gitlab.cern.ch/atlas/athena/-/blob/21.2/Tracking/TrkVertexFitter/TrkVKalVrtFitter/TrkVKalVrtFitter/VxCascadeInfo.h
207  BPHYS_CHECK( vtx.setMass(m_CascadeTools->invariantMass(moms[2])) );
208  BPHYS_CHECK( vtx.setMassErr(m_CascadeTools->invariantMassError(moms[2],cascade_info->getCovariance()[2])) );
209  // pt and pT error (the default pt of mainVertex is != the pt of the full cascade fit!)
210  Pt_decor(*mainVertex) = m_CascadeTools->pT(moms[2]);
211  PtErr_decor(*mainVertex) = m_CascadeTools->pTError(moms[2],cascade_info->getCovariance()[2]);
212  // chi2 and ndof (the default chi2 of mainVertex is != the chi2 of the full cascade fit!)
213  chi2_decor(*mainVertex) = cascade_info->fitChi2();
214  ndof_decor(*mainVertex) = cascade_info->nDoF();
215  chi2_nc_decor(*mainVertex) = cascade_info_noConstr ? cascade_info_noConstr->fitChi2() : -999999.;
216  ndof_nc_decor(*mainVertex) = cascade_info_noConstr ? cascade_info_noConstr->nDoF() : -1;
217 
218  // decorate the Psi vertex
219  chi2_SV1_decor(*cascadeVertices[0]) = m_V0Tools->chisq(cascadeVertices[0]);
220  chi2_nc_SV1_decor(*cascadeVertices[0]) = cascade_info_noConstr ? m_V0Tools->chisq(cascade_info_noConstr->vertices()[0]) : -999999.;
221  chi2_V1_decor(*cascadeVertices[0]) = m_V0Tools->chisq(psiVertex);
222  ndof_V1_decor(*cascadeVertices[0]) = m_V0Tools->ndof(psiVertex);
223  lxy_SV1_decor(*cascadeVertices[0]) = m_CascadeTools->lxy(moms[0],cascadeVertices[0],mainVertex);
224  lxyErr_SV1_decor(*cascadeVertices[0]) = m_CascadeTools->lxyError(moms[0],cascade_info->getCovariance()[0],cascadeVertices[0],mainVertex);
225  a0z_SV1_decor(*cascadeVertices[0]) = m_CascadeTools->a0z(moms[0],cascadeVertices[0],mainVertex);
226  a0zErr_SV1_decor(*cascadeVertices[0]) = m_CascadeTools->a0zError(moms[0],cascade_info->getCovariance()[0],cascadeVertices[0],mainVertex);
227  a0xy_SV1_decor(*cascadeVertices[0]) = m_CascadeTools->a0xy(moms[0],cascadeVertices[0],mainVertex);
228  a0xyErr_SV1_decor(*cascadeVertices[0]) = m_CascadeTools->a0xyError(moms[0],cascade_info->getCovariance()[0],cascadeVertices[0],mainVertex);
229 
230  // decorate the Jpsi vertex
231  chi2_SV2_decor(*cascadeVertices[1]) = m_V0Tools->chisq(cascadeVertices[1]);
232  chi2_nc_SV2_decor(*cascadeVertices[1]) = cascade_info_noConstr ? m_V0Tools->chisq(cascade_info_noConstr->vertices()[1]) : -999999.;
233  chi2_V2_decor(*cascadeVertices[1]) = m_V0Tools->chisq(jpsiVertex);
234  ndof_V2_decor(*cascadeVertices[1]) = m_V0Tools->ndof(jpsiVertex);
235  lxy_SV2_decor(*cascadeVertices[1]) = m_CascadeTools->lxy(moms[1],cascadeVertices[1],mainVertex);
236  lxyErr_SV2_decor(*cascadeVertices[1]) = m_CascadeTools->lxyError(moms[1],cascade_info->getCovariance()[1],cascadeVertices[1],mainVertex);
237  a0z_SV2_decor(*cascadeVertices[1]) = m_CascadeTools->a0z(moms[1],cascadeVertices[1],mainVertex);
238  a0zErr_SV2_decor(*cascadeVertices[1]) = m_CascadeTools->a0zError(moms[1],cascade_info->getCovariance()[1],cascadeVertices[1],mainVertex);
239  a0xy_SV2_decor(*cascadeVertices[1]) = m_CascadeTools->a0xy(moms[1],cascadeVertices[1],mainVertex);
240  a0xyErr_SV2_decor(*cascadeVertices[1]) = m_CascadeTools->a0xyError(moms[1],cascade_info->getCovariance()[1],cascadeVertices[1],mainVertex);
241 
242  double Mass_Moth = m_CascadeTools->invariantMass(moms[2]); //size=2
243  ATH_CHECK(helper.FillCandwithRefittedVertices(m_refitPV, pvContainer.cptr(), m_refitPV ? refPvContainer.ptr() : 0, &(*m_pvRefitter), m_PV_max, m_DoVertexType, cascade_info, 2, Mass_Moth, vtx));
244  } // loop over cascadeinfoContainer
245 
246  // Deleting cascadeinfo since this won't be stored.
247  // Vertices have been kept in m_cascadeOutputs and should be owned by their container
248  for (auto cascade_info : cascadeinfoContainer) delete cascade_info;
249  for (auto cascade_info_noConstr : cascadeinfoContainer_noConstr) delete cascade_info_noConstr;
250 
251  return StatusCode::SUCCESS;
252  }
253 
254  JpsiPlusPsiCascade::JpsiPlusPsiCascade(const std::string& type, const std::string& name, const IInterface* parent) : AthAlgTool(type,name,parent),
255  m_vertexContainerKey(""),
256  m_vertexPsiContainerKey(""),
257  m_cascadeOutputsKeys({"JpsiPlusPsiCascadeVtx1", "JpsiPlusPsiCascadeVtx2", "JpsiPlusPsiCascadeVtx3"}),
258  m_VxPrimaryCandidateName("PrimaryVertices"),
259  m_trackContainerName("InDetTrackParticles"),
260  m_eventInfo_key("EventInfo"),
261  m_jpsiMassLower(0.0),
262  m_jpsiMassUpper(20000.0),
263  m_diTrackMassLower(-1.0),
264  m_diTrackMassUpper(-1.0),
265  m_psiMassLower(0.0),
266  m_psiMassUpper(25000.0),
267  m_jpsi2MassLower(0.0),
268  m_jpsi2MassUpper(20000.0),
269  m_MassLower(0.0),
270  m_MassUpper(31000.0),
271  m_vtx1Daug_num(4),
272  m_vtx1Daug1MassHypo(-1),
273  m_vtx1Daug2MassHypo(-1),
274  m_vtx1Daug3MassHypo(-1),
275  m_vtx1Daug4MassHypo(-1),
276  m_vtx2Daug1MassHypo(-1),
277  m_vtx2Daug2MassHypo(-1),
278  m_mass_jpsi(-1),
279  m_mass_diTrk(-1),
280  m_mass_psi(-1),
281  m_mass_jpsi2(-1),
282  m_constrPsi(false),
283  m_constrJpsi(false),
284  m_constrDiTrk(false),
285  m_constrJpsi2(false),
286  m_chi2cut_Psi(-1.0),
287  m_chi2cut_Jpsi(-1.0),
288  m_chi2cut(-1.0),
289  m_maxCandidates(0),
290  m_iVertexFitter("Trk::TrkVKalVrtFitter"),
291  m_pvRefitter("Analysis::PrimaryVertexRefitter", this),
292  m_V0Tools("Trk::V0Tools"),
293  m_CascadeTools("DerivationFramework::CascadeTools")
294  {
295  declareProperty("JpsiVertices", m_vertexContainerKey);
296  declareProperty("PsiVertices", m_vertexPsiContainerKey);
297  declareProperty("JpsiVtxHypoNames", m_vertexJpsiHypoNames);
298  declareProperty("PsiVtxHypoNames", m_vertexPsiHypoNames);
299  declareProperty("VxPrimaryCandidateName", m_VxPrimaryCandidateName);
300  declareProperty("TrackContainerName", m_trackContainerName);
301  declareProperty("RefPVContainerName", m_refPVContainerName = "RefittedPrimaryVertices");
302  declareProperty("JpsiMassLowerCut", m_jpsiMassLower);
303  declareProperty("JpsiMassUpperCut", m_jpsiMassUpper);
304  declareProperty("DiTrackMassLower", m_diTrackMassLower); // only effective when m_vtx1Daug_num=4
305  declareProperty("DiTrackMassUpper", m_diTrackMassUpper); // only effective when m_vtx1Daug_num=4
306  declareProperty("PsiMassLowerCut", m_psiMassLower);
307  declareProperty("PsiMassUpperCut", m_psiMassUpper);
308  declareProperty("Jpsi2MassLowerCut", m_jpsi2MassLower);
309  declareProperty("Jpsi2MassUpperCut", m_jpsi2MassUpper);
310  declareProperty("MassLowerCut", m_MassLower);
311  declareProperty("MassUpperCut", m_MassUpper);
312  declareProperty("HypothesisName", m_hypoName = "TQ");
313  declareProperty("NumberOfPsiDaughters", m_vtx1Daug_num); // 3 or 4 only
314  declareProperty("Vtx1Daug1MassHypo", m_vtx1Daug1MassHypo);
315  declareProperty("Vtx1Daug2MassHypo", m_vtx1Daug2MassHypo);
316  declareProperty("Vtx1Daug3MassHypo", m_vtx1Daug3MassHypo);
317  declareProperty("Vtx1Daug4MassHypo", m_vtx1Daug4MassHypo);
318  declareProperty("Vtx2Daug1MassHypo", m_vtx2Daug1MassHypo);
319  declareProperty("Vtx2Daug2MassHypo", m_vtx2Daug2MassHypo);
320  declareProperty("JpsiMass", m_mass_jpsi);
321  declareProperty("DiTrackMass", m_mass_diTrk);
322  declareProperty("PsiMass", m_mass_psi);
323  declareProperty("Jpsi2Mass", m_mass_jpsi2);
324  declareProperty("ApplyJpsiMassConstraint", m_constrJpsi);
325  declareProperty("ApplyDiTrackMassConstraint", m_constrDiTrk); // only effective when m_vtx1Daug_num=4
326  declareProperty("ApplyPsiMassConstraint", m_constrPsi);
327  declareProperty("ApplyJpsi2MassConstraint", m_constrJpsi2);
328  declareProperty("Chi2CutPsi", m_chi2cut_Psi);
329  declareProperty("Chi2CutJpsi", m_chi2cut_Jpsi);
330  declareProperty("Chi2Cut", m_chi2cut);
331  declareProperty("MaxCandidates", m_maxCandidates);
332  declareProperty("RefitPV", m_refitPV = true);
333  declareProperty("MaxnPV", m_PV_max = 1000);
334  declareProperty("MinNTracksInPV", m_PV_minNTracks = 0);
335  declareProperty("DoVertexType", m_DoVertexType = 7);
336  declareProperty("TrkVertexFitterTool", m_iVertexFitter);
337  declareProperty("PVRefitter", m_pvRefitter);
338  declareProperty("V0Tools", m_V0Tools);
339  declareProperty("CascadeTools", m_CascadeTools);
340  declareProperty("CascadeVertexCollections", m_cascadeOutputsKeys);
341  }
342 
343  StatusCode JpsiPlusPsiCascade::performSearch(std::vector<Trk::VxCascadeInfo*> *cascadeinfoContainer, std::vector<Trk::VxCascadeInfo*> *cascadeinfoContainer_noConstr) const {
344  ATH_MSG_DEBUG( "JpsiPlusPsiCascade::performSearch" );
345  assert(cascadeinfoContainer!=nullptr && cascadeinfoContainer_noConstr!=nullptr);
346 
347  // Get TrackParticle container (for setting links to the original tracks)
348  SG::ReadHandle<xAOD::TrackParticleContainer> trackContainer(m_trackContainerName);
349  ATH_CHECK( trackContainer.isValid() );
350 
351  std::vector<const xAOD::TrackParticle*> tracksJpsi;
352  std::vector<const xAOD::TrackParticle*> tracksDiTrk;
353  std::vector<const xAOD::TrackParticle*> tracksPsi;
354  std::vector<const xAOD::TrackParticle*> tracksJpsi2;
355  std::vector<double> massesPsi;
356  massesPsi.push_back(m_vtx1Daug1MassHypo);
357  massesPsi.push_back(m_vtx1Daug2MassHypo);
358  massesPsi.push_back(m_vtx1Daug3MassHypo);
359  if(m_vtx1Daug_num==4) massesPsi.push_back(m_vtx1Daug4MassHypo);
360  std::array<double,2> massesJpsi2{m_vtx2Daug1MassHypo, m_vtx2Daug2MassHypo};
361 
362  // Get Psi container
363  SG::ReadHandle<xAOD::VertexContainer> psiContainer(m_vertexPsiContainerKey);
364  ATH_CHECK( psiContainer.isValid() );
365 
366  // Get Jpsi container
367  SG::ReadHandle<xAOD::VertexContainer> jpsiContainer(m_vertexContainerKey);
368  ATH_CHECK( jpsiContainer.isValid() );
369 
370  // Select the J/psi candidates before calling cascade fit
371  std::vector<const xAOD::Vertex*> selectedJpsiCandidates;
372  for(auto vxcItr=jpsiContainer.cptr()->cbegin(); vxcItr!=jpsiContainer.cptr()->cend(); ++vxcItr) {
373  // Check the passed flag first
374  const xAOD::Vertex* vtx = *vxcItr;
375  bool passed = false;
376  for(size_t i=0; i<m_vertexJpsiHypoNames.size(); i++) {
377  SG::AuxElement::Accessor<Char_t> flagAcc("passed_"+m_vertexJpsiHypoNames[i]);
378  if(flagAcc.isAvailable(*vtx) && flagAcc(*vtx)) {
379  passed |= 1;
380  }
381  }
382  if(m_vertexJpsiHypoNames.size() && !passed) continue;
383 
384  // Check Jpsi candidate invariant mass and skip if need be
385  double mass_jpsi2 = m_V0Tools->invariantMass(*vxcItr, massesJpsi2);
386  if (mass_jpsi2 < m_jpsi2MassLower || mass_jpsi2 > m_jpsi2MassUpper) continue;
387 
388  double chi2DOF = (*vxcItr)->chiSquared()/(*vxcItr)->numberDoF();
389  if(m_chi2cut_Jpsi>0 && chi2DOF>m_chi2cut_Jpsi) continue;
390 
391  selectedJpsiCandidates.push_back(*vxcItr);
392  }
393  if(selectedJpsiCandidates.size()==0) return StatusCode::SUCCESS;
394 
395  // Select the Psi candidates before calling cascade fit
396  std::vector<const xAOD::Vertex*> selectedPsiCandidates;
397  for(auto vxcItr=psiContainer.cptr()->cbegin(); vxcItr!=psiContainer.cptr()->cend(); ++vxcItr) {
398  // Check the passed flag first
399  const xAOD::Vertex* vtx = *vxcItr;
400  bool passed = false;
401  for(size_t i=0; i<m_vertexPsiHypoNames.size(); i++) {
402  SG::AuxElement::Accessor<Char_t> flagAcc("passed_"+m_vertexPsiHypoNames[i]);
403  if(flagAcc.isAvailable(*vtx) && flagAcc(*vtx)) {
404  passed |= 1;
405  }
406  }
407  if(m_vertexPsiHypoNames.size() && !passed) continue;
408 
409  // Check Psi candidate invariant mass and skip if need be
410  double mass_psi = m_V0Tools->invariantMass(*vxcItr,massesPsi);
411  if(mass_psi < m_psiMassLower || mass_psi > m_psiMassUpper) continue;
412 
413  // Add loose cut on Jpsi mass from Psi -> Jpsi pi+ pi-, or on phi mass from Ds+ -> phi pi+
414  TLorentzVector p4_mu1, p4_mu2;
415  p4_mu1.SetPtEtaPhiM( (*vxcItr)->trackParticle(0)->pt(),
416  (*vxcItr)->trackParticle(0)->eta(),
417  (*vxcItr)->trackParticle(0)->phi(), m_vtx1Daug1MassHypo);
418  p4_mu2.SetPtEtaPhiM( (*vxcItr)->trackParticle(1)->pt(),
419  (*vxcItr)->trackParticle(1)->eta(),
420  (*vxcItr)->trackParticle(1)->phi(), m_vtx1Daug2MassHypo);
421  double mass_jpsi = (p4_mu1 + p4_mu2).M();
422  if (mass_jpsi < m_jpsiMassLower || mass_jpsi > m_jpsiMassUpper) continue;
423 
424  if(m_vtx1Daug_num==4 && m_diTrackMassLower>=0 && m_diTrackMassUpper>=0) {
425  TLorentzVector p4_trk1, p4_trk2;
426  p4_trk1.SetPtEtaPhiM( (*vxcItr)->trackParticle(2)->pt(),
427  (*vxcItr)->trackParticle(2)->eta(),
428  (*vxcItr)->trackParticle(2)->phi(), m_vtx1Daug3MassHypo);
429  p4_trk2.SetPtEtaPhiM( (*vxcItr)->trackParticle(3)->pt(),
430  (*vxcItr)->trackParticle(3)->eta(),
431  (*vxcItr)->trackParticle(3)->phi(), m_vtx1Daug4MassHypo);
432  double mass_diTrk = (p4_trk1 + p4_trk2).M();
433  if (mass_diTrk < m_diTrackMassLower || mass_diTrk > m_diTrackMassUpper) continue;
434  }
435 
436  double chi2DOF = (*vxcItr)->chiSquared()/(*vxcItr)->numberDoF();
437  if(m_chi2cut_Psi>0 && chi2DOF>m_chi2cut_Psi) continue;
438 
439  selectedPsiCandidates.push_back(*vxcItr);
440  }
441  if(selectedPsiCandidates.size()==0) return StatusCode::SUCCESS;
442 
443  std::vector<std::pair<const xAOD::Vertex*, const xAOD::Vertex*> > candidatePairs;
444  for(auto jpsiItr=selectedJpsiCandidates.cbegin(); jpsiItr!=selectedJpsiCandidates.cend(); ++jpsiItr) {
445  tracksJpsi2.clear();
446  for(size_t i=0; i<(*jpsiItr)->nTrackParticles(); i++) tracksJpsi2.push_back((*jpsiItr)->trackParticle(i));
447  for(auto psiItr=selectedPsiCandidates.cbegin(); psiItr!=selectedPsiCandidates.cend(); ++psiItr) {
448  bool skip = false;
449  for(size_t j=0; j<(*psiItr)->nTrackParticles(); j++) {
450  if(std::find(tracksJpsi2.cbegin(), tracksJpsi2.cend(), (*psiItr)->trackParticle(j)) != tracksJpsi2.cend()) { skip = true; break; }
451  }
452  if(skip) continue;
453  candidatePairs.push_back(std::pair<const xAOD::Vertex*, const xAOD::Vertex*>(*jpsiItr,*psiItr));
454  }
455  }
456 
457  std::sort( candidatePairs.begin(), candidatePairs.end(), [](std::pair<const xAOD::Vertex*, const xAOD::Vertex*> a, std::pair<const xAOD::Vertex*, const xAOD::Vertex*> b) { return a.first->chiSquared()/a.first->numberDoF()+a.second->chiSquared()/a.second->numberDoF() < b.first->chiSquared()/b.first->numberDoF()+b.second->chiSquared()/b.second->numberDoF(); } );
458  if(m_maxCandidates>0 && candidatePairs.size()>m_maxCandidates) {
459  candidatePairs.erase(candidatePairs.begin()+m_maxCandidates, candidatePairs.end());
460  }
461 
462  for(size_t ic=0; ic<candidatePairs.size(); ic++) {
463  const xAOD::Vertex* jpsiVertex = candidatePairs[ic].first;
464  const xAOD::Vertex* psiVertex = candidatePairs[ic].second;
465 
466  tracksJpsi2.clear();
467  for(size_t it=0; it<jpsiVertex->nTrackParticles(); it++) tracksJpsi2.push_back(jpsiVertex->trackParticle(it));
468  if (tracksJpsi2.size() != 2 || massesJpsi2.size() != 2) {
469  ATH_MSG_ERROR("Problems with Jpsi input: number of tracks or track mass inputs is not 2!");
470  }
471  tracksPsi.clear();
472  for(size_t it=0; it<psiVertex->nTrackParticles(); it++) tracksPsi.push_back(psiVertex->trackParticle(it));
473  if (tracksPsi.size() != massesPsi.size()) {
474  ATH_MSG_ERROR("Problems with Psi input: number of tracks or track mass inputs is not correct!");
475  }
476 
477  tracksJpsi.clear();
478  tracksJpsi.push_back(psiVertex->trackParticle(0));
479  tracksJpsi.push_back(psiVertex->trackParticle(1));
480  tracksDiTrk.clear();
481  if(m_vtx1Daug_num==4) {
482  tracksDiTrk.push_back(psiVertex->trackParticle(2));
483  tracksDiTrk.push_back(psiVertex->trackParticle(3));
484  }
485 
486  TLorentzVector p4_moth;
487  TLorentzVector tmp;
488  for(size_t it=0; it<jpsiVertex->nTrackParticles(); it++) {
489  tmp.SetPtEtaPhiM(jpsiVertex->trackParticle(it)->pt(),jpsiVertex->trackParticle(it)->eta(),jpsiVertex->trackParticle(it)->phi(),massesJpsi2[it]);
490  p4_moth += tmp;
491  }
492  for(size_t it=0; it<psiVertex->nTrackParticles(); it++) {
493  tmp.SetPtEtaPhiM(psiVertex->trackParticle(it)->pt(),psiVertex->trackParticle(it)->eta(),psiVertex->trackParticle(it)->phi(),massesPsi[it]);
494  p4_moth += tmp;
495  }
496  if (p4_moth.M() < m_MassLower || p4_moth.M() > m_MassUpper) continue;
497 
498  // Apply the user's settings to the fitter
499  std::unique_ptr<Trk::IVKalState> state = m_iVertexFitter->makeState();
500  // Robustness: http://cdsweb.cern.ch/record/685551
501  int robustness = 0;
502  m_iVertexFitter->setRobustness(robustness, *state);
503  // Build up the topology
504  // Vertex list
505  std::vector<Trk::VertexID> vrtList;
506  // Psi vertex
507  Trk::VertexID vID1;
508  // https://gitlab.cern.ch/atlas/athena/-/blob/21.2/Tracking/TrkVertexFitter/TrkVKalVrtFitter/TrkVKalVrtFitter/IVertexCascadeFitter.h
509  if (m_constrPsi) {
510  vID1 = m_iVertexFitter->startVertex(tracksPsi,massesPsi,*state,m_mass_psi);
511  } else {
512  vID1 = m_iVertexFitter->startVertex(tracksPsi,massesPsi,*state);
513  }
514  vrtList.push_back(vID1);
515  // Jpsi vertex
516  Trk::VertexID vID2;
517  if (m_constrJpsi2) {
518  vID2 = m_iVertexFitter->nextVertex(tracksJpsi2,massesJpsi2,*state,m_mass_jpsi2);
519  } else {
520  vID2 = m_iVertexFitter->nextVertex(tracksJpsi2,massesJpsi2,*state);
521  }
522  vrtList.push_back(vID2);
523  // Mother vertex including Jpsi and Psi
524  std::vector<const xAOD::TrackParticle*> tp; tp.clear();
525  std::vector<double> tp_masses; tp_masses.clear();
526  m_iVertexFitter->nextVertex(tp,tp_masses,vrtList,*state);
527  if (m_constrJpsi) {
528  std::vector<Trk::VertexID> cnstV; cnstV.clear();
529  if ( !m_iVertexFitter->addMassConstraint(vID1,tracksJpsi,cnstV,*state,m_mass_jpsi).isSuccess() ) {
530  ATH_MSG_WARNING("addMassConstraint for Jpsi failed");
531  }
532  }
533  if (m_constrDiTrk && m_vtx1Daug_num==4 && m_mass_diTrk>0) {
534  std::vector<Trk::VertexID> cnstV; cnstV.clear();
535  if ( !m_iVertexFitter->addMassConstraint(vID1,tracksDiTrk,cnstV,*state,m_mass_diTrk).isSuccess() ) {
536  ATH_MSG_WARNING("addMassConstraint for DiTrk failed");
537  }
538  }
539  // Do the work
540  std::unique_ptr<Trk::VxCascadeInfo> result(m_iVertexFitter->fitCascade(*state));
541 
542  bool pass = false;
543  if (result != nullptr) {
544  for(auto v : result->vertices()) {
545  if(v->nTrackParticles()==0) {
546  std::vector<ElementLink<xAOD::TrackParticleContainer> > nullLinkVector;
547  v->setTrackParticleLinks(nullLinkVector);
548  }
549  }
550  // reset links to original tracks
551  BPhysPVCascadeTools::PrepareVertexLinks(result.get(), trackContainer.cptr());
552 
553  // necessary to prevent memory leak
554  result->setSVOwnership(true);
555 
556  // Chi2/DOF cut
557  double chi2DOF = result->fitChi2()/result->nDoF();
558  bool chi2CutPassed = (m_chi2cut <= 0.0 || chi2DOF < m_chi2cut);
559 
560  if(chi2CutPassed) {
561  cascadeinfoContainer->push_back(result.release());
562  pass = true;
563  }
564  }
565 
566  // do cascade fit again without any mass constraints
567  if(pass) {
568  if(m_constrJpsi || m_constrPsi || m_constrJpsi2 || (m_constrDiTrk && m_vtx1Daug_num==4 && m_mass_diTrk>0)) {
569  std::unique_ptr<Trk::IVKalState> state (m_iVertexFitter->makeState());
570  m_iVertexFitter->setRobustness(robustness, *state);
571  std::vector<Trk::VertexID> vrtList_nc;
572  // Psi vertex
573  Trk::VertexID vID1_nc = m_iVertexFitter->startVertex(tracksPsi,massesPsi,*state);
574  vrtList_nc.push_back(vID1_nc);
575  Trk::VertexID vID2_nc = m_iVertexFitter->nextVertex(tracksJpsi2,massesJpsi2,*state);
576  vrtList_nc.push_back(vID2_nc);
577  // Mother vertex including Jpsi and Psi
578  std::vector<const xAOD::TrackParticle*> tp; tp.clear();
579  std::vector<double> tp_masses; tp_masses.clear();
580  m_iVertexFitter->nextVertex(tp,tp_masses,vrtList_nc,*state);
581  // Do the work
582  std::unique_ptr<Trk::VxCascadeInfo> result_nc(m_iVertexFitter->fitCascade(*state));
583 
584  if (result_nc != nullptr) {
585  for(auto v : result_nc->vertices()) {
586  if(v->nTrackParticles()==0) {
587  std::vector<ElementLink<xAOD::TrackParticleContainer> > nullLinkVector;
588  v->setTrackParticleLinks(nullLinkVector);
589  }
590  }
591  // reset links to original tracks
592  BPhysPVCascadeTools::PrepareVertexLinks(result_nc.get(), trackContainer.cptr());
593 
594  // necessary to prevent memory leak
595  result_nc->setSVOwnership(true);
596  cascadeinfoContainer_noConstr->push_back(result_nc.release());
597  }
598  else cascadeinfoContainer_noConstr->push_back(0);
599  }
600  else cascadeinfoContainer_noConstr->push_back(0);
601  }
602  } //Iterate over candidatePairs
603 
604  return StatusCode::SUCCESS;
605  }
606 }
xAOD::BPhysHypoHelper::setMass
bool setMass(const float val)
Set given invariant mass and its error.
Definition: BPhysHypoHelper.cxx:49
DerivationFramework::JpsiPlusPsiCascade::m_vtx1Daug3MassHypo
double m_vtx1Daug3MassHypo
Definition: JpsiPlusPsiCascade.h:66
xAOD::TrackParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: TrackParticle_v1.cxx:73
Trk::VxSecVertexInfo::setSVOwnership
void setSVOwnership(bool Ownership)
Definition: VxSecVertexInfo.h:118
V0Tools.h
DerivationFramework::JpsiPlusPsiCascade::m_mass_diTrk
double m_mass_diTrk
Definition: JpsiPlusPsiCascade.h:72
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
get_generator_info.result
result
Definition: get_generator_info.py:21
xAOD::Vertex_v1::nTrackParticles
size_t nTrackParticles() const
Get the number of tracks associated with this vertex.
Definition: Vertex_v1.cxx:270
Trk::VxCascadeInfo
Definition: VxCascadeInfo.h:75
Trk::VertexID
int VertexID
Definition: IVertexCascadeFitter.h:23
TrigCompositeUtils::passed
bool passed(DecisionID id, const DecisionIDContainer &idSet)
checks if required decision ID is in the set of IDs in the container
Definition: TrigCompositeUtilsRoot.cxx:117
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
SG::ReadHandle::cptr
const_pointer_type cptr()
Dereference the pointer.
DerivationFramework::JpsiPlusPsiCascade::m_mass_jpsi
double m_mass_jpsi
Definition: JpsiPlusPsiCascade.h:71
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
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
xAOD::TrackParticle_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition: TrackParticle_v1.cxx:77
DerivationFramework::BPhysPVCascadeTools::getParticleMass
static double getParticleMass(const HepPDT::ParticleDataTable *pdt, int pdg)
Definition: BPhysPVCascadeTools.cxx:491
DerivationFramework::JpsiPlusPsiCascade::m_chi2cut_Jpsi
double m_chi2cut_Jpsi
Definition: JpsiPlusPsiCascade.h:80
DerivationFramework::JpsiPlusPsiCascade::m_diTrackMassLower
double m_diTrackMassLower
Definition: JpsiPlusPsiCascade.h:55
Trk::VxSecVertexInfo::vertices
const std::vector< xAOD::Vertex * > & vertices() const
Definition: VxSecVertexInfo.cxx:100
DerivationFramework::JpsiPlusPsiCascade::m_maxCandidates
unsigned int m_maxCandidates
Definition: JpsiPlusPsiCascade.h:82
skel.it
it
Definition: skel.GENtoEVGEN.py:423
ParticleTest.tp
tp
Definition: ParticleTest.py:25
DataVector::cend
const_iterator cend() const noexcept
Return a const_iterator pointing past the end of the collection.
DerivationFramework::JpsiPlusPsiCascade::m_vtx1Daug4MassHypo
double m_vtx1Daug4MassHypo
Definition: JpsiPlusPsiCascade.h:67
LArG4FSStartPointFilter.evt
evt
Definition: LArG4FSStartPointFilter.py:42
DerivationFramework::JpsiPlusPsiCascade::m_iVertexFitter
ToolHandle< Trk::TrkVKalVrtFitter > m_iVertexFitter
Definition: JpsiPlusPsiCascade.h:84
DerivationFramework::JpsiPlusPsiCascade::m_vertexPsiContainerKey
SG::ReadHandleKey< xAOD::VertexContainer > m_vertexPsiContainerKey
Definition: JpsiPlusPsiCascade.h:45
DerivationFramework::JpsiPlusPsiCascade::m_vtx1Daug2MassHypo
double m_vtx1Daug2MassHypo
Definition: JpsiPlusPsiCascade.h:65
Trk::VxCascadeInfo::nDoF
int nDoF() const
Definition: VxCascadeInfo.h:133
Trk::VxCascadeInfo::getCovariance
const std::vector< Amg::MatrixX > & getCovariance() const
Definition: VxCascadeInfo.h:132
DerivationFramework::JpsiPlusPsiCascade::m_PV_max
int m_PV_max
Definition: JpsiPlusPsiCascade.h:92
DerivationFramework::JpsiPlusPsiCascade::m_vtx2Daug2MassHypo
double m_vtx2Daug2MassHypo
Definition: JpsiPlusPsiCascade.h:69
TrkVKalVrtFitter.h
runBeamSpotCalibration.helper
helper
Definition: runBeamSpotCalibration.py:112
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::JpsiPlusPsiCascade::m_constrJpsi
bool m_constrJpsi
Definition: JpsiPlusPsiCascade.h:76
DerivationFramework::JpsiPlusPsiCascade::m_jpsiMassUpper
double m_jpsiMassUpper
Definition: JpsiPlusPsiCascade.h:54
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
SG::WriteHandleKey
Property holding a SG store/key/clid from which a WriteHandle is made.
Definition: StoreGate/StoreGate/WriteHandleKey.h:40
DerivationFramework::JpsiPlusPsiCascade::performSearch
StatusCode performSearch(std::vector< Trk::VxCascadeInfo * > *cascadeinfoContainer, std::vector< Trk::VxCascadeInfo * > *cascadeinfoContainer_noConstr) const
Definition: JpsiPlusPsiCascade.cxx:343
SG::Decorator
Helper class to provide type-safe access to aux data.
Definition: Decorator.h:58
DerivationFramework::JpsiPlusPsiCascade::m_eventInfo_key
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfo_key
Definition: JpsiPlusPsiCascade.h:51
DerivationFramework::JpsiPlusPsiCascade::m_DoVertexType
int m_DoVertexType
Definition: JpsiPlusPsiCascade.h:93
lumiFormat.i
int i
Definition: lumiFormat.py:92
xAOD::BPhysHypoHelper::setPass
bool setPass(bool passVal)
get the pass flag for this hypothesis
Definition: BPhysHypoHelper.cxx:364
DerivationFramework::JpsiPlusPsiCascade::m_vertexJpsiHypoNames
std::vector< std::string > m_vertexJpsiHypoNames
Definition: JpsiPlusPsiCascade.h:46
DerivationFramework::JpsiPlusPsiCascade::m_cascadeOutputsKeys
SG::WriteHandleKeyArray< xAOD::VertexContainer > m_cascadeOutputsKeys
Definition: JpsiPlusPsiCascade.h:48
DerivationFramework::JpsiPlusPsiCascade::m_MassLower
double m_MassLower
Definition: JpsiPlusPsiCascade.h:61
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
SG::WriteHandle::ptr
pointer_type ptr()
Dereference the pointer.
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
BPhysHypoHelper.h
: B-physcis xAOD helpers.
DerivationFramework::JpsiPlusPsiCascade::m_vtx1Daug_num
int m_vtx1Daug_num
Definition: JpsiPlusPsiCascade.h:63
DerivationFramework::JpsiPlusPsiCascade::m_mass_psi
double m_mass_psi
Definition: JpsiPlusPsiCascade.h:73
DerivationFramework::JpsiPlusPsiCascade::m_constrJpsi2
bool m_constrJpsi2
Definition: JpsiPlusPsiCascade.h:78
Trk::VxCascadeInfo::fitChi2
double fitChi2() const
Definition: VxCascadeInfo.h:134
test_pyathena.parent
parent
Definition: test_pyathena.py:15
DerivationFramework::BPhysPVCascadeTools::PrepareVertexLinks
static void PrepareVertexLinks(Trk::VxCascadeInfo *result, const xAOD::TrackParticleContainer *importedTrackCollection)
Definition: BPhysPVCascadeTools.cxx:204
DerivationFramework::JpsiPlusPsiCascade::m_V0Tools
ToolHandle< Trk::V0Tools > m_V0Tools
Definition: JpsiPlusPsiCascade.h:86
MUON
xAOD::Muon MUON
D3PD INCLUDES.
Definition: TileCellFillerTool.h:37
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::JpsiPlusPsiCascade::m_VxPrimaryCandidateName
SG::ReadHandleKey< xAOD::VertexContainer > m_VxPrimaryCandidateName
Name of primary vertex container.
Definition: JpsiPlusPsiCascade.h:49
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
DerivationFramework::JpsiPlusPsiCascade::m_refPVContainerName
SG::WriteHandleKey< xAOD::VertexContainer > m_refPVContainerName
Definition: JpsiPlusPsiCascade.h:90
DeMoUpdate.tmp
string tmp
Definition: DeMoUpdate.py:1167
DerivationFramework::JpsiPlusPsiCascade::m_vertexPsiHypoNames
std::vector< std::string > m_vertexPsiHypoNames
Definition: JpsiPlusPsiCascade.h:47
DerivationFramework::JpsiPlusPsiCascade::JpsiPlusPsiCascade
JpsiPlusPsiCascade(const std::string &t, const std::string &n, const IInterface *p)
Definition: JpsiPlusPsiCascade.cxx:254
DerivationFramework::JpsiPlusPsiCascade::m_diTrackMassUpper
double m_diTrackMassUpper
Definition: JpsiPlusPsiCascade.h:56
BPhysPVCascadeTools.h
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
DerivationFramework::JpsiPlusPsiCascade::m_trackContainerName
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_trackContainerName
Definition: JpsiPlusPsiCascade.h:50
grepfile.ic
int ic
Definition: grepfile.py:33
DerivationFramework::JpsiPlusPsiCascade::m_jpsi2MassUpper
double m_jpsi2MassUpper
Definition: JpsiPlusPsiCascade.h:60
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:77
DerivationFramework::JpsiPlusPsiCascade::m_CascadeTools
ToolHandle< DerivationFramework::CascadeTools > m_CascadeTools
Definition: JpsiPlusPsiCascade.h:87
DerivationFramework::BPhysPVCascadeTools
Definition: BPhysPVCascadeTools.h:34
DerivationFramework::JpsiPlusPsiCascade::initialize
virtual StatusCode initialize() override
Definition: JpsiPlusPsiCascade.cxx:23
CascadeTools.h
Trk::VxCascadeInfo::getParticleMoms
const std::vector< std::vector< TLorentzVector > > & getParticleMoms() const
Definition: VxCascadeInfo.h:131
IVertexFitter.h
VxCascadeInfo.h
DerivationFramework::JpsiPlusPsiCascade::m_refitPV
bool m_refitPV
Definition: JpsiPlusPsiCascade.h:89
DerivationFramework::JpsiPlusPsiCascade::m_MassUpper
double m_MassUpper
Definition: JpsiPlusPsiCascade.h:62
DerivationFramework::JpsiPlusPsiCascade::m_pvRefitter
ToolHandle< Analysis::PrimaryVertexRefitter > m_pvRefitter
Definition: JpsiPlusPsiCascade.h:85
python.PyAthena.v
v
Definition: PyAthena.py:157
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:76
DerivationFramework::VertexLinkVector
std::vector< VertexLink > VertexLinkVector
Definition: Cascade3Plus1.cxx:24
DerivationFramework::JpsiPlusPsiCascade::m_constrDiTrk
bool m_constrDiTrk
Definition: JpsiPlusPsiCascade.h:77
a
TList * a
Definition: liststreamerinfos.cxx:10
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
SG::WriteHandle::record
StatusCode record(std::unique_ptr< T > data)
Record a const object to the store.
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
JpsiPlusPsiCascade.h
DerivationFramework::JpsiPlusPsiCascade::m_vtx1Daug1MassHypo
double m_vtx1Daug1MassHypo
Definition: JpsiPlusPsiCascade.h:64
DerivationFramework::JpsiPlusPsiCascade::m_PV_minNTracks
size_t m_PV_minNTracks
Definition: JpsiPlusPsiCascade.h:94
DerivationFramework::JpsiPlusPsiCascade::m_hypoName
std::string m_hypoName
Definition: JpsiPlusPsiCascade.h:91
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.
DerivationFramework::JpsiPlusPsiCascade::m_vtx2Daug1MassHypo
double m_vtx2Daug1MassHypo
Definition: JpsiPlusPsiCascade.h:68
DataVector::cbegin
const_iterator cbegin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
DerivationFramework::JpsiPlusPsiCascade::m_mass_jpsi2
double m_mass_jpsi2
Definition: JpsiPlusPsiCascade.h:74
DerivationFramework::JpsiPlusPsiCascade::m_constrPsi
bool m_constrPsi
Definition: JpsiPlusPsiCascade.h:75
skip
bool skip
Definition: TrigGlobEffCorrValidation.cxx:190
AthAlgTool
Definition: AthAlgTool.h:26
DerivationFramework::JpsiPlusPsiCascade::m_chi2cut_Psi
double m_chi2cut_Psi
Definition: JpsiPlusPsiCascade.h:79
DerivationFramework::JpsiPlusPsiCascade::addBranches
virtual StatusCode addBranches() const override
Pass the thinning service
Definition: JpsiPlusPsiCascade.cxx:64
DerivationFramework::JpsiPlusPsiCascade::m_vertexContainerKey
SG::ReadHandleKey< xAOD::VertexContainer > m_vertexContainerKey
Definition: JpsiPlusPsiCascade.h:44
DerivationFramework::JpsiPlusPsiCascade::m_chi2cut
double m_chi2cut
Definition: JpsiPlusPsiCascade.h:81
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
HepMCHelpers.h
xAOD::BPhysHypoHelper::setMassErr
bool setMassErr(const float val)
invariant mass error
Definition: BPhysHypoHelper.cxx:54
VertexAuxContainer.h
xAOD::TrackParticle_v1::phi
virtual double phi() const override final
The azimuthal angle ( ) of the particle (has range to .)
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
DerivationFramework::JpsiPlusPsiCascade::m_psiMassUpper
double m_psiMassUpper
Definition: JpsiPlusPsiCascade.h:58
Generated on Tue Jul 2 2024 21:19:08 for ATLAS Offline Software by   doxygen 1.8.18