ATLAS Offline Software
JpsiPlus1Track.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 // ****************************************************************************
6 // ----------------------------------------------------------------------------
7 // JpsiPlus1Track
8 // James Catmore <James.Catmore@cern.ch>
9 // Results returned as a vector of xAOD::Vertex
10 // ----------------------------------------------------------------------------
11 // ****************************************************************************
12 
13 #include "JpsiUpsilonTools/JpsiPlus1Track.h"
14 #include "xAODBPhys/BPhysHelper.h"
15 #include "TrkVertexFitterInterfaces/IVertexFitter.h"
16 #include "TrkVKalVrtFitter/TrkVKalVrtFitter.h"
17 #include "TrkToolInterfaces/ITrackSelectorTool.h"
18 #include "xAODTracking/TrackParticle.h"
19 #include "xAODTracking/Vertex.h"
20 #include "xAODTracking/VertexContainer.h"
21 #include "AthLinks/ElementLink.h"
22 #include "xAODTracking/TrackParticleContainer.h"
23 #include "InDetConversionFinderTools/VertexPointEstimator.h"
24 #include <memory>
25 #include "JpsiUpsilonTools/JpsiUpsilonCommon.h"
26 #include "TruthUtils/ParticleConstants.h"
27 #include "xAODEgamma/ElectronContainer.h"
28 #include <limits>
29 
30 namespace Analysis {
31 
32 
33  // Set masses
34  constexpr double muMass = ParticleConstants::muonMassInMeV;
35  constexpr double kMass = ParticleConstants::chargedKaonMassInMeV;
36  constexpr double piMass = ParticleConstants::chargedPionMassInMeV;
37 
38  StatusCode JpsiPlus1Track::initialize() {
39 
40  // retrieving vertex Fitter
41  ATH_CHECK(m_iVertexFitter.retrieve());
42  m_VKVFitter = dynamic_cast<Trk::TrkVKalVrtFitter*>(&(*m_iVertexFitter));
43 
44  // Get the track selector tool from ToolSvc
45  ATH_CHECK( m_trkSelector.retrieve());
46 
47  // Get the vertex point estimator tool from ToolSvc
48  ATH_CHECK(m_jpsiCollectionKey.initialize());
49  ATH_CHECK(m_TrkParticleCollection.initialize());
50  if(m_MuonsUsedInJpsi.key() == "NONE") m_MuonsUsedInJpsi = "";//for backwards compatability
51  ATH_CHECK(m_MuonsUsedInJpsi.initialize(!m_MuonsUsedInJpsi.key().empty()));
52  ATH_CHECK(m_TrkParticleGSFCollection.initialize(!m_TrkParticleGSFCollection.key().empty()));
53  ATH_CHECK(m_electronCollectionKey.initialize(SG::AllowEmpty));
54 
55  if (m_requiredNMuons > 0 && !m_excludeJpsiMuonsOnly) {
56  ATH_MSG_FATAL("Invalid configuration");
57  return StatusCode::FAILURE;
58  }
59 
60  if(m_muonMasses.empty()){
61  m_muonMasses.assign(2, muMass);
62  }
63 
64  m_useGSFTrack.reset();
65  for(int i : m_useGSFTrackIndices) m_useGSFTrack.set(i, true);
66  ATH_MSG_DEBUG("Initialize successful");
67 
68  return StatusCode::SUCCESS;
69 
70  }
71 
72 
73  JpsiPlus1Track::JpsiPlus1Track(const std::string& t, const std::string& n, const IInterface* p) : AthAlgTool(t,n,p),
74  m_piMassHyp(false),
75  m_kMassHyp(true),
76  m_trkThresholdPt(0.0),
77  m_trkMaxEta(102.5),
78  m_BThresholdPt(0.0),
79  m_BMassUpper(0.0),
80  m_BMassLower(0.0),
81  m_jpsiCollectionKey("JpsiCandidates"),
82  m_jpsiMassUpper(0.0),
83  m_jpsiMassLower(0.0),
84  m_TrkParticleCollection("TrackParticleCandidate"),
85  m_MuonsUsedInJpsi(""),
86  m_excludeJpsiMuonsOnly(true),
87  m_excludeCrossJpsiTracks(false),
88  m_iVertexFitter("Trk::TrkVKalVrtFitter"),
89  m_trkSelector("InDet::TrackSelectorTool"),
90  m_useMassConst(true),
91  m_altMassConst(-1.0),
92  m_chi2cut(-1.0),
93  m_trkTrippletMassUpper(-1.0),
94  m_trkTrippletMassLower(-1.0),
95  m_trkTrippletPt(-1.0),
96  m_trkDeltaZ(-1.0),
97  m_TrkParticleGSFCollection(""),
98  m_electronCollectionKey(""),
99  m_candidateLimit(std::numeric_limits<size_t>::max())
100  {
101  declareInterface<JpsiPlus1Track>(this);
102  declareProperty("pionHypothesis",m_piMassHyp);
103  declareProperty("kaonHypothesis",m_kMassHyp);
104  declareProperty("trkThresholdPt",m_trkThresholdPt);
105  declareProperty("trkMaxEta",m_trkMaxEta);
106  declareProperty("BThresholdPt",m_BThresholdPt);
107  declareProperty("BMassUpper",m_BMassUpper);
108  declareProperty("BMassLower",m_BMassLower);
109  declareProperty("JpsiContainerKey",m_jpsiCollectionKey);
110  declareProperty("JpsiMassUpper",m_jpsiMassUpper);
111  declareProperty("JpsiMassLower",m_jpsiMassLower);
112  declareProperty("TrackParticleCollection",m_TrkParticleCollection);
113  declareProperty("MuonsUsedInJpsi",m_MuonsUsedInJpsi);
114  declareProperty("ExcludeJpsiMuonsOnly",m_excludeJpsiMuonsOnly);
115  declareProperty("ExcludeCrossJpsiTracks",m_excludeCrossJpsiTracks); //Essential when trying to make vertices out of multiple muons (set to false)
116  declareProperty("TrkVertexFitterTool",m_iVertexFitter);
117  declareProperty("TrackSelectorTool", m_trkSelector);
118  declareProperty("UseMassConstraint", m_useMassConst);
119  declareProperty("AlternativeMassConstraint",m_altMassConst);
120 
121  // additional cuts by Daniel Scheirich copied from 2Tracks by Adam Barton
122  declareProperty("Chi2Cut",m_chi2cut);
123  declareProperty("TrkTrippletMassUpper" ,m_trkTrippletMassUpper);
124  declareProperty("TrkTrippletMassLower" ,m_trkTrippletMassLower);
125  declareProperty("TrkQuadrupletPt" ,m_trkTrippletPt );
126  declareProperty("TrkDeltaZ" ,m_trkDeltaZ );
127  declareProperty("RequireNMuonTracks" ,m_requiredNMuons );
128  declareProperty("RequireNElectronTracks", m_requiredNElectrons );
129  declareProperty("AlternativeMassConstraintTrack", m_muonMasses );
130  declareProperty("UseGSFTrackIndices", m_useGSFTrackIndices );
131  declareProperty("GSFCollection", m_TrkParticleGSFCollection);
132  declareProperty("ElectronCollection", m_electronCollectionKey);
133  declareProperty("SkipNoElectron", m_skipNoElectron);
134  declareProperty("CandidateLimit", m_candidateLimit);
135  }
136 
137  JpsiPlus1Track::~JpsiPlus1Track() {}
138 
139  //-------------------------------------------------------------------------------------
140  // Find the candidates
141  //-------------------------------------------------------------------------------------
142  StatusCode JpsiPlus1Track::performSearch(const EventContext& ctx, xAOD::VertexContainer& bContainer) const
143  {
144  ATH_MSG_DEBUG( "JpsiPlus1Track::performSearch" );
145 
146  // Get the J/psis from StoreGate
147  const xAOD::VertexContainer* importedJpsiCollection(0);
148  SG::ReadHandle<xAOD::VertexContainer> jpsiCollectionhandle(m_jpsiCollectionKey,ctx);
149  if(!jpsiCollectionhandle.isValid()){
150  ATH_MSG_ERROR("No VertexContainer with key " << m_jpsiCollectionKey.key() << " found in StoreGate. BCandidates will be EMPTY!");
151  return StatusCode::FAILURE;
152  }else{
153  importedJpsiCollection = jpsiCollectionhandle.cptr();
154  ATH_MSG_DEBUG("Found VxCandidate container with key "<<m_jpsiCollectionKey.key());
155  }
156  ATH_MSG_DEBUG("VxCandidate container size " << importedJpsiCollection->size());
157 
158  // Get tracks
159  const xAOD::TrackParticleContainer* importedTrackCollection{nullptr};
160  SG::ReadHandle<xAOD::TrackParticleContainer> TrkParticleHandle(m_TrkParticleCollection,ctx);
161  if(!TrkParticleHandle.isValid()){
162  ATH_MSG_ERROR("No track particle collection with name " << m_TrkParticleCollection << " found in StoreGate!");
163  return StatusCode::FAILURE;
164  } else {
165  importedTrackCollection = TrkParticleHandle.cptr();
166  ATH_MSG_DEBUG("Found track particle collection " << m_TrkParticleCollection << " in StoreGate!");
167  }
168  ATH_MSG_DEBUG("Track container size "<< importedTrackCollection->size());
169 
170  const xAOD::TrackParticleContainer* importedGSFTrackCollection(nullptr);
171  if(m_useGSFTrack.any() && !m_TrkParticleGSFCollection.key().empty()){
172  SG::ReadHandle<xAOD::TrackParticleContainer> h(m_TrkParticleGSFCollection,ctx);
173  ATH_CHECK(h.isValid());
174  importedGSFTrackCollection = h.cptr();
175  }
176 
177 
178  // Get the muon collection used to build the J/psis
179  const xAOD::MuonContainer* importedMuonCollection(0);
180  if (!m_MuonsUsedInJpsi.key().empty()) {
181  SG::ReadHandle<xAOD::MuonContainer> h(m_MuonsUsedInJpsi,ctx);
182  if (!h.isValid()){
183  ATH_MSG_ERROR("No muon collection with name " << m_MuonsUsedInJpsi.key() << " found in StoreGate!");
184  return StatusCode::FAILURE;
185  } else {
186  importedMuonCollection = h.cptr();
187  ATH_MSG_DEBUG("Found muon collection " << m_MuonsUsedInJpsi.key() << " in StoreGate!");
188  }
189  ATH_MSG_DEBUG("Muon container size "<< importedMuonCollection->size());
190  }
191 
192  // Get the electrons from StoreGate
193  const xAOD::ElectronContainer* importedElectronCollection = nullptr;
194  if (!m_electronCollectionKey.empty()){
195  SG::ReadHandle<xAOD::ElectronContainer> h(m_electronCollectionKey,ctx);
196  if (!h.isValid()){
197  ATH_MSG_ERROR("No Electron collection with name " << m_electronCollectionKey.key() << " found in StoreGate!");
198  return StatusCode::FAILURE;
199  } else {
200  importedElectronCollection = h.cptr();
201  ATH_MSG_DEBUG("Found Electron collection " << m_electronCollectionKey.key() << " in StoreGate!");
202  }
203  ATH_MSG_DEBUG("Electron container size "<< importedElectronCollection->size());
204  }
205 
206 
207  // Typedef for vectors of tracks and VxCandidates
208  typedef std::vector<const xAOD::TrackParticle*> TrackBag;
209  typedef std::vector<const xAOD::Electron*> ElectronBag;
210 
211  // Select the inner detector tracks
212  const xAOD::Vertex* vx = nullptr;
213  TrackBag theIDTracksAfterSelection;
214  for (auto trkPBItr=importedTrackCollection->cbegin(); trkPBItr!=importedTrackCollection->cend(); ++trkPBItr) {
215  const xAOD::TrackParticle* tp (*trkPBItr);
216  if ( tp->pt()<m_trkThresholdPt ) continue;
217  if ( fabs(tp->eta())>m_trkMaxEta ) continue;
218  if (importedMuonCollection!=NULL && !m_excludeJpsiMuonsOnly) {
219  if (JpsiUpsilonCommon::isContainedIn(tp,importedMuonCollection)) continue;
220  }
221  if ( m_trkSelector->decision(*tp, vx) ) theIDTracksAfterSelection.push_back(tp);
222  }
223 
224  // Add GSF tracks
225  if(m_useGSFTrack.any()){
226  ATH_MSG_DEBUG("importedTrackCollection contains GSF tracks " << importedGSFTrackCollection->size());
227  for (auto trkPBItr=importedGSFTrackCollection->cbegin(); trkPBItr!=importedGSFTrackCollection->cend(); ++trkPBItr) {
228  const xAOD::TrackParticle* tp (*trkPBItr);
229  if ( tp->pt()<m_trkThresholdPt ) continue;
230  if ( fabs(tp->eta())>m_trkMaxEta ) continue;
231  if (!importedMuonCollection->empty() && !m_excludeJpsiMuonsOnly) {
232  if (JpsiUpsilonCommon::isContainedIn(tp,importedMuonCollection)) continue;
233  }
234  if (m_trkSelector->decision(*tp, vx)) theIDTracksAfterSelection.push_back(tp);
235  }
236  }
237  if (theIDTracksAfterSelection.empty()) return StatusCode::SUCCESS;
238  ATH_MSG_DEBUG("Number of tracks after ID trkSelector: " << theIDTracksAfterSelection.size());
239 
240  // Loop over J/psi candidates, select, collect up tracks used to build a J/psi
241  std::vector<const xAOD::Vertex*> selectedJpsiCandidates;
242  std::vector<const xAOD::TrackParticle*> jpsiTracks;
243  for(auto vxcItr=importedJpsiCollection->cbegin(); vxcItr!=importedJpsiCollection->cend(); ++vxcItr) {
244  // Check J/psi candidate invariant mass and skip if need be
245  if (m_jpsiMassUpper>0.0 || m_jpsiMassLower >0.0) {
246  xAOD::BPhysHelper jpsiCandidate(*vxcItr);
247  double jpsiMass = jpsiCandidate.totalP(m_muonMasses).M();
248  bool pass = JpsiUpsilonCommon::cutRange(jpsiMass, m_jpsiMassLower, m_jpsiMassUpper);
249  if (!pass) continue;
250  }
251  selectedJpsiCandidates.push_back(*vxcItr);
252 
253  // Collect up tracks
254  if(m_excludeCrossJpsiTracks){
255  // Extract tracks from J/psi
256  const xAOD::TrackParticle* jpsiTP1 = (*vxcItr)->trackParticle(0);
257  const xAOD::TrackParticle* jpsiTP2 = (*vxcItr)->trackParticle(1);
258  jpsiTracks.push_back(jpsiTP1);
259  jpsiTracks.push_back(jpsiTP2);
260  }
261  }
262 
263 
264  std::vector<double> massHypotheses;
265  if (m_kMassHyp) massHypotheses.push_back(kMass);
266  if (m_piMassHyp) massHypotheses.push_back(piMass);
267  if (!m_kMassHyp && !m_piMassHyp && m_BMassUpper>0.0) {
268  massHypotheses.push_back(kMass); massHypotheses.push_back(piMass);
269  }
270  std::vector<double> tripletMasses(m_muonMasses);
271  // Attempt to fit each track with the two tracks from the J/psi candidates
272  // Loop over J/psis
273 
274  std::vector<double> massCuts;
275 
276  TrackBag muonTracks;
277  if (importedMuonCollection && m_excludeJpsiMuonsOnly) {
278  for(auto muon : *importedMuonCollection){
279  if(!muon->inDetTrackParticleLink().isValid()) continue;
280  auto track = muon->trackParticle( xAOD::Muon::InnerDetectorTrackParticle );
281  if(track==nullptr) continue;
282  if(!JpsiUpsilonCommon::isContainedIn(track, theIDTracksAfterSelection)) continue;
283  muonTracks.push_back(track);
284  }
285  }
286 
287  TrackBag electronTracks;
288  ElectronBag theElectronsAfterSelection;
289  if (importedElectronCollection && !importedElectronCollection->empty()) {
290  for(auto electron : *importedElectronCollection) {
291  if (!electron->trackParticleLink().isValid()) continue; // No electrons without ID tracks
292  const xAOD::TrackParticle* elTrk(0);
293  elTrk = electron->trackParticleLink().cachedElement();
294  if (!elTrk) continue;
295  theElectronsAfterSelection.push_back(electron);
296  electronTracks.push_back(elTrk);
297  }
298  if (m_skipNoElectron && theElectronsAfterSelection.size() == 0) return StatusCode::SUCCESS;
299  ATH_MSG_DEBUG("Number of electrons after selection: " << theElectronsAfterSelection.size());
300  }
301 
302  std::vector<const xAOD::TrackParticle*> tracks(3, nullptr);
303 
304  for(auto jpsiItr=selectedJpsiCandidates.cbegin(); jpsiItr!=selectedJpsiCandidates.cend(); ++jpsiItr) {
305 
306  // Extract tracks from J/psi
307 
308  const xAOD::TrackParticle* jpsiTP1 = tracks[0] = (*jpsiItr)->trackParticle(0);
309  const xAOD::TrackParticle* jpsiTP2 = tracks[1] = (*jpsiItr)->trackParticle(1);
310 
311  //If requested, only exclude duplicates in the same triplet
312  if(!m_excludeCrossJpsiTracks){
313  jpsiTracks.resize(2);
314  jpsiTracks[0] = jpsiTP1;
315  jpsiTracks[1] = jpsiTP2;
316  }
317 
318  // Loop over ID tracks, call vertexing
319  for (auto trkItr=theIDTracksAfterSelection.cbegin(); trkItr!=theIDTracksAfterSelection.cend(); ++trkItr) {
320  if(bContainer.size() >= m_candidateLimit ){
321  ATH_MSG_WARNING("Hard Limit exceeded N=" << bContainer.size());
322  return StatusCode::SUCCESS;
323  }
324  if (!m_excludeJpsiMuonsOnly && JpsiUpsilonCommon::isContainedIn(*trkItr,jpsiTracks)) continue; // remove tracks which were used to build J/psi
325  int linkedMuonTrk = 0;
326  if (m_excludeJpsiMuonsOnly) {
327  linkedMuonTrk = JpsiUpsilonCommon::isContainedIn(*trkItr, muonTracks);
328  if (linkedMuonTrk) ATH_MSG_DEBUG("This id track is a muon track!");
329  if (JpsiUpsilonCommon::isContainedIn(*trkItr,jpsiTracks)) {
330  if (linkedMuonTrk) ATH_MSG_DEBUG("ID track removed: id track is slected to build Jpsi!");
331  continue;
332 
333  }
334  }
335  if(!m_electronCollectionKey.empty()){
336  int linkedElectronTrk = 0;
337  linkedElectronTrk = JpsiUpsilonCommon::isContainedIn(*trkItr, electronTracks);
338  if (linkedElectronTrk) ATH_MSG_DEBUG("This id track is an electron track!");
339  if (JpsiUpsilonCommon::isContainedIn(*trkItr,jpsiTracks)) {
340  if (linkedElectronTrk) ATH_MSG_DEBUG("ID track removed: id track is selected to build Jpsi!");
341  continue;
342  }
343  if (linkedElectronTrk < m_requiredNElectrons) {
344  ATH_MSG_DEBUG("Skipping Tracks with Electron " << linkedElectronTrk << " Limited to " << m_requiredNElectrons);
345  continue;
346  }
347  }
348 
349  // Convert to TrackParticleBase
350  const xAOD::TrackParticle* theThirdTP = tracks[2] = *trkItr;
351 
352  if (m_trkTrippletPt>0 && JpsiUpsilonCommon::getPt(jpsiTP1, jpsiTP2, theThirdTP) < m_trkTrippletPt ) continue; // track tripplet pT cut (daniel Scheirich)
353  if(m_trkDeltaZ>0 &&
354  fabs(theThirdTP->z0() + theThirdTP->vz() - (*jpsiItr)->z()) > m_trkDeltaZ )
355  continue;
356  if (linkedMuonTrk < m_requiredNMuons) {
357  ATH_MSG_DEBUG("Skipping Tracks with Muons " << linkedMuonTrk << " Limited to " << m_requiredNMuons);
358  continue;
359  }
360 
361  // apply mass cut on track tripplet if requested
362  bool passRoughMassCuts(true);
363 
364  if (m_trkTrippletMassUpper>0.0 || m_trkTrippletMassLower>0.0) {
365  massCuts.clear();
366  if(m_kMassHyp) massCuts.push_back(getInvariantMass(tracks, m_muonMasses[0], m_muonMasses[1], kMass));
367  if(m_piMassHyp) massCuts.push_back(getInvariantMass(tracks, m_muonMasses[0], m_muonMasses[1], piMass));
368  passRoughMassCuts = JpsiUpsilonCommon::cutRangeOR(massCuts, m_trkTrippletMassLower, m_trkTrippletMassUpper);
369  }
370  if (!passRoughMassCuts) continue;
371 
372 
373  //Managed pointer, "release" if you don't want it deleted. Automatically "deleted" otherwise
374  std::unique_ptr<xAOD::Vertex> bVertex( fit(tracks, importedTrackCollection, importedGSFTrackCollection));
375  if (bVertex) {
376 
377  // Chi2/DOF cut
378  double bChi2DOF = bVertex->chiSquared()/bVertex->numberDoF();
379  ATH_MSG_DEBUG("Candidate chi2/DOF is " << bChi2DOF);
380 
381  bool chi2CutPassed = (m_chi2cut <= 0.0 || bChi2DOF < m_chi2cut);
382  if(!chi2CutPassed) { ATH_MSG_DEBUG("Chi Cut failed!"); continue; }
383 
384  // create the helper class
385  xAOD::BPhysHelper bHelper(bVertex.get());
386  // setRefTrks needs to be called after BPhysHelper is created if you want to access refitted track parameters
387  bHelper.setRefTrks();
388  // Decide whether to keep the candidate
389  bool masspTpassed = true;
390  if (m_BMassUpper>0.0 || m_BThresholdPt >0.0 || m_BMassLower > 0.0) {
391  masspTpassed = false;
392  for (double masshypo3rd : massHypotheses) {
393  tripletMasses.push_back(masshypo3rd); //Add third mass
394  TLorentzVector bMomentum = bHelper.totalP(tripletMasses);//Calulcate result
395  tripletMasses.pop_back(); //Remove 3rd mass - now same as beginning
396  double bpt = bMomentum.Pt();
397  bool PtPassed = m_BThresholdPt <= 0.0 || (bpt >= m_BThresholdPt);
398  double bMass = bMomentum.M();
399  ATH_MSG_DEBUG("candidate pt/mass under track mass hypothesis of " << masshypo3rd << " is " << bpt << " / " << bMass);
400  bool masscut = JpsiUpsilonCommon::cutRange(bMass, m_BMassLower, m_BMassUpper); //( bMass >= m_BMassLower && bMass <= m_BMassUpper );
401  if(masscut && PtPassed) { masspTpassed = true; break; }
402  }
403  }
404  if (masspTpassed) {
405  // Set links to J/psi
406  std::vector<const xAOD::Vertex*> theJpsiPreceding;
407  theJpsiPreceding.push_back(*jpsiItr);
408  bHelper.setPrecedingVertices(theJpsiPreceding, importedJpsiCollection);
409  bContainer.push_back(bVertex.release());
410  } else {
411  ATH_MSG_DEBUG("Cuts failed!");
412  }
413  } else {ATH_MSG_DEBUG("Fitter failed!");}
414 
415  } // End of loop over tracks
416 
417  } // End of loop over J/psis
418  ATH_MSG_DEBUG("bContainer size " << bContainer.size());
419  return StatusCode::SUCCESS;
420 
421  }
422 
423  // *********************************************************************************
424 
425  // ---------------------------------------------------------------------------------
426  // fit - does the fit
427  // ---------------------------------------------------------------------------------
428 
429  xAOD::Vertex* JpsiPlus1Track::fit(const std::vector<const xAOD::TrackParticle*> &inputTracks, const xAOD::TrackParticleContainer* importedTrackCollection, const xAOD::TrackParticleContainer* gsfCollection) const {
430 
431  std::unique_ptr<Trk::IVKalState> state = m_VKVFitter->makeState();
432 
433  // Set the mass constraint if requested by user (default=true)
434  // Can be set by user (m_altMassConstraint) - default is -1.0.
435  // If < 0.0, uses J/psi (default)
436  // If > 0.0, uses the value provided
437  constexpr double jpsiTableMass = ParticleConstants::JpsiMassInMeV;
438 
439  if (m_useMassConst) {
440  m_VKVFitter->setMassInputParticles(m_muonMasses, *state);
441  std::array<int,2> indices = {1, 2};
442  if (m_altMassConst<0.0) m_VKVFitter->setMassForConstraint(jpsiTableMass,indices, *state);
443  if (m_altMassConst>0.0) m_VKVFitter->setMassForConstraint(m_altMassConst,indices, *state);
444  }
445 
446  // Do the fit itself.......
447  Amg::Vector3D startingPoint(0,0,0);
448  StatusCode sc=m_VKVFitter->VKalVrtFitFast(inputTracks, startingPoint, *state);
449  if(sc.isFailure()){
450  startingPoint = Amg::Vector3D(0,0,0);
451  }
452  xAOD::Vertex* theResult = m_VKVFitter->fit(inputTracks, startingPoint, *state);
453 
454  // Added by ASC
455  if(theResult != 0){
456  std::vector<ElementLink<DataVector<xAOD::TrackParticle> > > newLinkVector;
457  for(unsigned int i=0; i< theResult->trackParticleLinks().size(); i++)
458  {
459  ElementLink<DataVector<xAOD::TrackParticle> > mylink=theResult->trackParticleLinks()[i]; //makes a copy (non-const)
460  mylink.setStorableObject( m_useGSFTrack[i] ? *gsfCollection : *importedTrackCollection, true);
461  newLinkVector.push_back( mylink );
462  }
463  theResult->clearTracks();
464  theResult->setTrackParticleLinks( newLinkVector );
465  }
466 
467 
468  return theResult;
469 
470  }
471 
472 
473 
474  double JpsiPlus1Track::getInvariantMass(const std::vector<const xAOD::TrackParticle*> &trk, double mass1,
475  double mass2, double mass3)
476  {
477  const auto trk1V = trk[0]->p4();
478  double px1 = trk1V.Px();
479  double py1 = trk1V.Py();
480  double pz1 = trk1V.Pz();
481  double e1 = sqrt(px1*px1+py1*py1+pz1*pz1+mass1*mass1);
482 
483  const auto trk2V = trk[1]->p4();
484  double px2 = trk2V.Px();
485  double py2 = trk2V.Py();
486  double pz2 = trk2V.Pz();
487  double e2 = sqrt(px2*px2+py2*py2+pz2*pz2+mass2*mass2);
488 
489  const auto trk3V = trk[2]->p4();
490  double px3 = trk3V.Px();
491  double py3 = trk3V.Py();
492  double pz3 = trk3V.Pz();
493  double e3 = sqrt(px3*px3+py3*py3+pz3*pz3+mass3*mass3);
494 
495 
496  double pxSum=px1+px2+px3;
497  double pySum=py1+py2+py3;
498  double pzSum=pz1+pz2+pz3;
499  double eSum=e1+e2+e3;
500 
501  double M=sqrt((eSum*eSum)-(pxSum*pxSum)-(pySum*pySum)-(pzSum*pzSum));
502 
503  return M;
504 
505  }
506 
507 
508 } // End of namespace
509 
510 
511 
Analysis::JpsiPlus1Track::~JpsiPlus1Track
~JpsiPlus1Track()
Definition: JpsiPlus1Track.cxx:137
xAOD::muon
@ muon
Definition: TrackingPrimitives.h:196
xAOD::BPhysHelper::totalP
TVector3 totalP()
: Returns total 3-momentum calculated from the refitted tracks
Definition: BPhysHelper.cxx:374
Analysis::JpsiPlus1Track::m_requiredNMuons
int m_requiredNMuons
Definition: JpsiPlus1Track.h:84
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
xAOD::BPhysHelper
Definition: BPhysHelper.h:71
Analysis::JpsiPlus1Track::m_candidateLimit
size_t m_candidateLimit
Definition: JpsiPlus1Track.h:92
VertexPointEstimator.h
SG::ReadHandle::cptr
const_pointer_type cptr()
Dereference the pointer.
egammaEnergyPositionAllSamples::e1
double e1(const xAOD::CaloCluster &cluster)
return the uncorrected cluster energy in 1st sampling
JpsiPlus1Track.h
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
Trk::TrkVKalVrtFitter::VKalVrtFitFast
virtual StatusCode VKalVrtFitFast(std::span< const xAOD::TrackParticle *const >, Amg::Vector3D &Vertex, double &minDZ, IVKalState &istate) const
Definition: VKalVrtFitFastSvc.cxx:56
xAOD::Vertex_v1::trackParticleLinks
const TrackParticleLinks_t & trackParticleLinks() const
Get all the particles associated with the vertex.
Trk::indices
std::pair< long int, long int > indices
Definition: AlSymMatBase.h:24
ParticleConstants::PDG2011::muonMassInMeV
constexpr double muonMassInMeV
the mass of the muon (in MeV)
Definition: ParticleConstants.h:29
xAOD::TrackParticle_v1::vz
float vz() const
The z origin for the parameters.
Analysis::JpsiPlus1Track::m_useGSFTrack
std::bitset< 3 > m_useGSFTrack
Definition: JpsiPlus1Track.h:89
xAOD::TrackParticle_v1::z0
float z0() const
Returns the parameter.
ParticleConstants::PDG2011::chargedKaonMassInMeV
constexpr double chargedKaonMassInMeV
the mass of the charged kaon (in MeV)
Definition: ParticleConstants.h:50
ParticleTest.tp
tp
Definition: ParticleTest.py:25
Analysis::kMass
constexpr double kMass
Definition: JpsiPlus1Track.cxx:35
Analysis::JpsiPlus1Track::JpsiPlus1Track
JpsiPlus1Track(const std::string &t, const std::string &n, const IInterface *p)
Definition: JpsiPlus1Track.cxx:73
Analysis::JpsiPlus1Track::m_jpsiMassLower
double m_jpsiMassLower
Definition: JpsiPlus1Track.h:69
DataVector::cend
const_iterator cend() const noexcept
Return a const_iterator pointing past the end of the collection.
Analysis::JpsiPlus1Track::m_BMassUpper
double m_BMassUpper
Definition: JpsiPlus1Track.h:65
Analysis::JpsiUpsilonCommon::isContainedIn
static bool isContainedIn(const xAOD::TrackParticle *, const std::vector< const xAOD::TrackParticle * > &)
Definition: JpsiUpsilonCommon.cxx:58
xAOD::BPhysHelper::setPrecedingVertices
bool setPrecedingVertices(const std::vector< const xAOD::Vertex * > &vertices, const xAOD::VertexContainer *vertexContainer)
Sets links to preceding vertices.
Definition: BPhysHelper.cxx:641
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
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
Analysis::JpsiUpsilonCommon::cutRange
static bool cutRange(double value, double min, double max)
Definition: JpsiUpsilonCommon.cxx:72
TrkVKalVrtFitter.h
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
Analysis::JpsiPlus1Track::m_TrkParticleGSFCollection
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_TrkParticleGSFCollection
Definition: JpsiPlus1Track.h:88
ParticleConstants::PDG2011::chargedPionMassInMeV
constexpr double chargedPionMassInMeV
the mass of the charged pion (in MeV)
Definition: ParticleConstants.h:41
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
Analysis::JpsiPlus1Track::m_muonMasses
std::vector< double > m_muonMasses
Definition: JpsiPlus1Track.h:86
Analysis::JpsiPlus1Track::m_trkDeltaZ
double m_trkDeltaZ
Definition: JpsiPlus1Track.h:83
Analysis::JpsiPlus1Track::m_trkTrippletMassUpper
double m_trkTrippletMassUpper
Definition: JpsiPlus1Track.h:80
Trk::TrkVKalVrtFitter::setMassForConstraint
virtual void setMassForConstraint(double Mass, IVKalState &istate) const override final
Definition: SetFitOptions.cxx:141
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
Analysis::JpsiPlus1Track::m_BThresholdPt
double m_BThresholdPt
Definition: JpsiPlus1Track.h:64
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
CheckAppliedSFs.e3
e3
Definition: CheckAppliedSFs.py:264
ElectronContainer.h
python.TrigInDetConfig.inputTracks
inputTracks
Definition: TrigInDetConfig.py:191
ParticleConstants.h
lumiFormat.i
int i
Definition: lumiFormat.py:85
beamspotman.n
n
Definition: beamspotman.py:727
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
extractSporadic.h
list h
Definition: extractSporadic.py:96
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
xAOD::Vertex_v1::setTrackParticleLinks
void setTrackParticleLinks(const TrackParticleLinks_t &trackParticles)
Set all track particle links at once.
Analysis::JpsiPlus1Track::m_excludeJpsiMuonsOnly
bool m_excludeJpsiMuonsOnly
Definition: JpsiPlus1Track.h:72
Analysis::JpsiPlus1Track::m_jpsiMassUpper
double m_jpsiMassUpper
Definition: JpsiPlus1Track.h:68
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
Analysis::JpsiPlus1Track::m_useGSFTrackIndices
std::vector< int > m_useGSFTrackIndices
Definition: JpsiPlus1Track.h:87
JpsiUpsilonCommon.h
Analysis::JpsiPlus1Track::m_piMassHyp
bool m_piMassHyp
Definition: JpsiPlus1Track.h:60
DerivationFramework::TrackBag
std::vector< const xAOD::TrackParticle * > TrackBag
Definition: BPhysVertexTrackBase.h:52
xAOD::Vertex_v1::clearTracks
void clearTracks()
Remove all tracks from the vertex.
Definition: Vertex_v1.cxx:331
Analysis::JpsiPlus1Track::performSearch
virtual StatusCode performSearch(const EventContext &ctx, xAOD::VertexContainer &) const override
Definition: JpsiPlus1Track.cxx:142
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
Vertex.h
Analysis::JpsiPlus1Track::getInvariantMass
static double getInvariantMass(const std::vector< const xAOD::TrackParticle * > &trk, double mass1, double mass2, double mass3)
Definition: JpsiPlus1Track.cxx:474
Analysis::JpsiPlus1Track::initialize
virtual StatusCode initialize() override
Definition: JpsiPlus1Track.cxx:38
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
Analysis::JpsiPlus1Track::fit
xAOD::Vertex * fit(const std::vector< const xAOD::TrackParticle * > &, const xAOD::TrackParticleContainer *, const xAOD::TrackParticleContainer *) const
Definition: JpsiPlus1Track.cxx:429
ParticleConstants::PDG2011::JpsiMassInMeV
constexpr double JpsiMassInMeV
Definition: ParticleConstants.h:56
Analysis::JpsiPlus1Track::m_jpsiCollectionKey
SG::ReadHandleKey< xAOD::VertexContainer > m_jpsiCollectionKey
Definition: JpsiPlus1Track.h:67
Analysis::JpsiPlus1Track::m_VKVFitter
Trk::TrkVKalVrtFitter * m_VKVFitter
Definition: JpsiPlus1Track.h:76
Analysis::JpsiPlus1Track::m_BMassLower
double m_BMassLower
Definition: JpsiPlus1Track.h:66
Analysis::JpsiPlus1Track::m_trkThresholdPt
double m_trkThresholdPt
Definition: JpsiPlus1Track.h:62
Analysis::JpsiPlus1Track::m_trkTrippletMassLower
double m_trkTrippletMassLower
Definition: JpsiPlus1Track.h:81
Analysis
The namespace of all packages in PhysicsAnalysis/JetTagging.
Definition: BTaggingCnvAlg.h:20
Analysis::JpsiPlus1Track::m_TrkParticleCollection
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_TrkParticleCollection
Definition: JpsiPlus1Track.h:70
Analysis::JpsiPlus1Track::m_chi2cut
double m_chi2cut
Definition: JpsiPlus1Track.h:79
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
IVertexFitter.h
Analysis::JpsiPlus1Track::m_trkSelector
ToolHandle< Trk::ITrackSelectorTool > m_trkSelector
Definition: JpsiPlus1Track.h:75
BPhysHelper.h
: B-physics xAOD helpers.
xAOD::Vertex_v1::numberDoF
float numberDoF() const
Returns the number of degrees of freedom of the vertex fit as float.
TrackParticle.h
xAOD::BPhysHelper::setRefTrks
bool setRefTrks(std::vector< float > px, std::vector< float > py, std::vector< float > pz)
Sets refitted track momenta.
Definition: BPhysHelper.cxx:286
VertexContainer.h
xAOD::Vertex_v1::chiSquared
float chiSquared() const
Returns the of the vertex fit as float.
Analysis::JpsiPlus1Track::m_useMassConst
bool m_useMassConst
Definition: JpsiPlus1Track.h:77
h
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
egammaEnergyPositionAllSamples::e2
double e2(const xAOD::CaloCluster &cluster)
return the uncorrected cluster energy in 2nd sampling
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
xAOD::EgammaParameters::electron
@ electron
Definition: EgammaEnums.h:18
Analysis::piMass
constexpr double piMass
Definition: JpsiPlus1Track.cxx:36
Analysis::JpsiPlus1Track::m_electronCollectionKey
SG::ReadHandleKey< xAOD::ElectronContainer > m_electronCollectionKey
Definition: JpsiPlus1Track.h:90
Analysis::JpsiPlus1Track::m_altMassConst
double m_altMassConst
Definition: JpsiPlus1Track.h:78
Analysis::JpsiPlus1Track::m_iVertexFitter
ToolHandle< Trk::IVertexFitter > m_iVertexFitter
Definition: JpsiPlus1Track.h:74
Analysis::JpsiPlus1Track::m_skipNoElectron
bool m_skipNoElectron
Definition: JpsiPlus1Track.h:91
DataVector::cbegin
const_iterator cbegin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
Analysis::JpsiPlus1Track::m_requiredNElectrons
int m_requiredNElectrons
Definition: JpsiPlus1Track.h:85
xAOD::track
@ track
Definition: TrackingPrimitives.h:513
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
Trk::TrkVKalVrtFitter::fit
virtual xAOD::Vertex * fit(const std::vector< const TrackParameters * > &perigeeList, const Amg::Vector3D &startingPoint) const override final
Interface for MeasuredPerigee with starting point.
Definition: TrkVKalVrtFitter.cxx:203
AthAlgTool
Definition: AthAlgTool.h:26
Analysis::muMass
constexpr double muMass
Definition: JpsiPlus1Track.cxx:34
Analysis::JpsiPlus1Track::m_kMassHyp
bool m_kMassHyp
Definition: JpsiPlus1Track.h:61
Analysis::JpsiPlus1Track::m_MuonsUsedInJpsi
SG::ReadHandleKey< xAOD::MuonContainer > m_MuonsUsedInJpsi
Definition: JpsiPlus1Track.h:71
ITrackSelectorTool.h
Analysis::JpsiUpsilonCommon::getPt
static double getPt(const xAOD::TrackParticle *, const xAOD::TrackParticle *)
Definition: JpsiUpsilonCommon.cxx:17
SG::AllowEmpty
@ AllowEmpty
Definition: StoreGate/StoreGate/VarHandleKey.h:30
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
Analysis::JpsiPlus1Track::m_trkTrippletPt
double m_trkTrippletPt
Definition: JpsiPlus1Track.h:82
Trk::TrkVKalVrtFitter::setMassInputParticles
virtual void setMassInputParticles(const std::vector< double > &, IVKalState &istate) const override final
Definition: SetFitOptions.cxx:194
Analysis::JpsiPlus1Track::m_trkMaxEta
double m_trkMaxEta
Definition: JpsiPlus1Track.h:63
DataVector::empty
bool empty() const noexcept
Returns true if the collection is empty.
TrackParticleContainer.h
Analysis::JpsiPlus1Track::m_excludeCrossJpsiTracks
bool m_excludeCrossJpsiTracks
Definition: JpsiPlus1Track.h:73
Trk::TrkVKalVrtFitter::makeState
virtual std::unique_ptr< IVKalState > makeState(const EventContext &ctx) const override final
Definition: TrkVKalVrtFitter.cxx:58
Analysis::JpsiUpsilonCommon::cutRangeOR
static bool cutRangeOR(const std::vector< double > &values, double min, double max)
Definition: JpsiUpsilonCommon.cxx:76
Trk::TrkVKalVrtFitter
Definition: TrkVKalVrtFitter.h:67
Generated on Mon Sep 29 2025 21:12:57 for ATLAS Offline Software by   doxygen 1.8.18