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