ATLAS Offline Software
JpsiFinder.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 // ****************************************************************************
6 // ----------------------------------------------------------------------------
7 // JpsiFinder
8 // James Catmore <James.Catmore@cern.ch>
9 // Evelina Bouhova-Thacker <e.bouhova@cern.ch>
10 // Daniel.Scheirich <daniel.scheirich@cern.ch>
11 // Migration to xAOD
12 // ----------------------------------------------------------------------------
13 // ****************************************************************************
14 
15 #include "JpsiUpsilonTools/JpsiFinder.h"
16 #include "xAODBPhys/BPhysHelper.h"
17 #include "TrkVertexFitterInterfaces/IVertexFitter.h"
18 #include "TrkV0Fitter/TrkV0VertexFitter.h"
19 #include "InDetConversionFinderTools/VertexPointEstimator.h"
20 #include "TrkToolInterfaces/ITrackSelectorTool.h"
21 #include "GaudiKernel/IPartPropSvc.h"
22 #include "HepPDT/ParticleDataTable.hh"
23 #include "AthLinks/ElementLink.h"
24 #include "xAODTracking/Vertex.h"
25 #include "xAODTracking/VertexContainer.h"
26 #include "xAODTracking/TrackParticle.h"
27 #include "xAODTracking/TrackParticleContainer.h"
28 #include "TruthUtils/HepMCHelpers.h"
29 #include "FourMomUtils/xAODP4Helpers.h"
30 namespace Analysis {
31 
32  StatusCode JpsiFinder::initialize() {
33 
34  // retrieving vertex Fitter
35  ATH_CHECK(m_iVertexFitter.retrieve());
36 
37  // retrieving V0 Fitter
38  ATH_CHECK(m_iV0VertexFitter.retrieve(DisableTool{!m_useV0Fitter }));
39 
40  // Get the track selector tool from ToolSvc
41  ATH_CHECK(m_trkSelector.retrieve());
42 
43  // Get the vertex point estimator tool from ToolSvc
44  ATH_CHECK(m_vertexEstimator.retrieve());
45 
46 
47  ATH_CHECK(m_muonCollectionKey.initialize());
48  ATH_CHECK(m_TrkParticleCollection.initialize());
49  ATH_CHECK(m_MuonTrackKeys.initialize(m_MuonTrackKeys.size() != 0));
50 
51  // Get the Particle Properties Service
52  IPartPropSvc* partPropSvc = 0;
53  StatusCode sc = service("PartPropSvc", partPropSvc, true);
54  if (sc.isFailure()) {
55  ATH_MSG_ERROR("Could not initialize Particle Properties Service");
56  return StatusCode::SUCCESS;
57  } else {
58  auto particleDataTable = partPropSvc->PDT();
59  const HepPDT::ParticleData* pd_mu = particleDataTable->particle(MC::MUON);
60  if (m_diMuons) {m_trk1M = pd_mu->mass(); m_trk2M = pd_mu->mass();}
61  }
62 
63  if (m_doTagAndProbe) ATH_MSG_WARNING("You have requested tag and probe mode. Duplicate mu+trk pairs WILL be allowed, charge ordering WILL NOT be done. Tag track will be first in each candidate");
64 
65 
66 // // Check that the user's settings are sensible
67  bool illogicalOptions(false);
68  if ( (m_mumu && m_mutrk) || (m_mumu && m_trktrk) || (m_mutrk && m_trktrk) ) {
69  ATH_MSG_WARNING("You are requesting incompatible combinations of muons and tracks in the pairs. JpsiCandidates will be EMPTY!");
70  illogicalOptions=true;
71  };
72  if ( (m_doTagAndProbe && m_mumu) || (m_doTagAndProbe && m_trktrk) ) {
73  ATH_MSG_WARNING("You are requesting Tag and Probe analysis but have not requested mu+trk mode. This is impossible. JpsiCandidates will be EMPTY!");
74  illogicalOptions=true;
75  };
76  if ( (m_mutrk || m_trktrk ) && m_useCombMeasurement ) {
77  ATH_MSG_WARNING("You are requesting a combined muon measurement to be used with pairs involving non-muon tracks. Not permitted. JpsiCandidates will be EMPTY!");
78  illogicalOptions=true;
79  };
80  if ( (m_allMuons && m_combOnly) || (m_allMuons && m_atLeastOneComb) || (m_combOnly && m_atLeastOneComb) ) {
81  ATH_MSG_WARNING("You are requesting incompatible combinations of combined muons non-combined muons in the pairs. JpsiCandidates will be EMPTY!");
82  illogicalOptions=true;
83  };
84  if (m_atLeastOneComb && m_doTagAndProbe) {
85  ATH_MSG_WARNING("You are requesting at least one muon to be combined in a tag and probe analysis. This doesn't make sense. JpsiCandidates will be EMPTY!");
86  illogicalOptions=true;
87  };
88  if ( (m_oppChOnly && m_sameChOnly) || (m_oppChOnly && m_allChCombs) || (m_sameChOnly && m_allChCombs) ) {
89  ATH_MSG_WARNING("You are requesting incompatible combinations of charges in the pairs. JpsiCandidates will be EMPTY!");
90  illogicalOptions=true;
91  };
92  if ( (m_sameChOnly && m_doTagAndProbe) || (m_allChCombs && m_doTagAndProbe) ) {
93  if (!m_forceTagAndProbe){ //if m_forceTagAndProbe=TRUE then T&P will work with any charge combinations
94  ATH_MSG_WARNING("You are requesting same-sign or all-sign combinations in a tag and probe analysis. This doesn't make sense. JpsiCandidates will be EMPTY!");
95  illogicalOptions=true;
96  }
97  }
98  if (illogicalOptions) return StatusCode::FAILURE;;
99 
100 
101  ATH_MSG_DEBUG("Initialize successful");
102 
103  return StatusCode::SUCCESS;
104 
105  }
106 
107 
108  JpsiFinder::JpsiFinder(const std::string& t, const std::string& n, const IInterface* p) : AthAlgTool(t,n,p),
109  m_mumu(true),
110  m_mutrk(false),
111  m_trktrk(false),
112  m_allMuons(false),
113  m_combOnly(false),
114  m_atLeastOneComb(true),
115  m_useCombMeasurement(false),
116  m_useV0Fitter(false),
117  m_diMuons(true),
118  m_trk1M(105.66),
119  m_trk2M(105.66),
120  m_thresholdPt(0.0),
121  m_higherPt(0.0),
122  m_trkThresholdPt(0.0),
123  m_invMassUpper(100000.0),
124  m_invMassLower(0.0),
125  m_collAngleTheta(0.0),
126  m_collAnglePhi(0.0),
127  m_Chi2Cut(50.),
128  m_oppChOnly(true),
129  m_sameChOnly(false),
130  m_allChCombs(false),
131  m_iVertexFitter("Trk::TrkVKalVrtFitter"),
132  m_iV0VertexFitter("Trk::V0VertexFitter"),
133  m_trkSelector("InDet::TrackSelectorTool"),
134  m_vertexEstimator("InDet::VertexPointEstimator"),
135  m_mcpCuts(true),
136  m_doTagAndProbe(false),
137  m_forceTagAndProbe(false) //forcing T&P method for any charge combinations
138 
139  {
140  declareInterface<JpsiFinder>(this);
141  declareProperty("muAndMu",m_mumu);
142  declareProperty("muAndTrack",m_mutrk);
143  declareProperty("TrackAndTrack",m_trktrk);
144  declareProperty("allMuons",m_allMuons);
145  declareProperty("combOnly",m_combOnly);
146  declareProperty("atLeastOneComb",m_atLeastOneComb);
147  declareProperty("useCombinedMeasurement",m_useCombMeasurement);
148  declareProperty("useV0Fitter",m_useV0Fitter);
149  declareProperty("assumeDiMuons",m_diMuons);
150  declareProperty("track1Mass",m_trk1M);
151  declareProperty("track2Mass",m_trk2M);
152  declareProperty("muonThresholdPt",m_thresholdPt);
153  declareProperty("higherPt",m_higherPt);
154  declareProperty("trackThresholdPt",m_trkThresholdPt);
155  declareProperty("invMassUpper",m_invMassUpper);
156  declareProperty("invMassLower",m_invMassLower);
157  declareProperty("collAngleTheta",m_collAngleTheta);
158  declareProperty("collAnglePhi",m_collAnglePhi);
159  declareProperty("Chi2Cut",m_Chi2Cut);
160  declareProperty("oppChargesOnly",m_oppChOnly);
161  declareProperty("sameChargesOnly",m_sameChOnly);
162  declareProperty("allChargeCombinations",m_allChCombs);
163  declareProperty("TrkVertexFitterTool",m_iVertexFitter);
164  declareProperty("V0VertexFitterTool",m_iV0VertexFitter);
165  declareProperty("TrackSelectorTool",m_trkSelector);
166  declareProperty("VertexPointEstimator",m_vertexEstimator);
167  declareProperty("useMCPCuts",m_mcpCuts);
168  declareProperty("doTagAndProbe",m_doTagAndProbe);
169  declareProperty("forceTagAndProbe",m_forceTagAndProbe);
170  }
171 
172  JpsiFinder::~JpsiFinder() { }
173 
174  //-------------------------------------------------------------------------------------
175  // Find the candidates
176  //-------------------------------------------------------------------------------------
177  StatusCode JpsiFinder::performSearch(const EventContext& ctx, xAOD::VertexContainer& vxContainer) const
178  {
179  ATH_MSG_DEBUG( "JpsiFinder::performSearch" );
180 
181  SG::ReadHandle<xAOD::MuonContainer> muonhandle(m_muonCollectionKey,ctx);
182  if(!muonhandle.isValid()){
183  ATH_MSG_ERROR("Could not retrieve " << m_muonCollectionKey.key());
184  return StatusCode::FAILURE;
185  }
186  // Get the muons from StoreGate
187  const xAOD::MuonContainer* importedMuonCollection = muonhandle.cptr();
188  ATH_MSG_DEBUG("Muon container size "<<importedMuonCollection->size());
189 
190  // Get muon tracks if combined measurement requested
191  std::vector<const xAOD::TrackParticleContainer*> importedMuonTrackCollections;
192  if (m_useCombMeasurement) {
193 
194  for (SG::ReadHandle<xAOD::TrackParticleContainer>& handle: m_MuonTrackKeys.makeHandles(ctx)) {
195  if(!handle.isValid()){
196  ATH_MSG_WARNING("No muon TrackParticle collection with name " << handle.key() << " found in StoreGate!");
197  return StatusCode::FAILURE;
198  } else {
199  ATH_MSG_DEBUG("Found muon TrackParticle collection " << handle.key() << " in StoreGate!");
200  ATH_MSG_DEBUG("Muon TrackParticle container size "<< handle->size());
201  importedMuonTrackCollections.push_back(handle.cptr());
202  }
203  }
204  }
205 
206  // Get ID tracks
207  SG::ReadHandle<xAOD::TrackParticleContainer> handle(m_TrkParticleCollection,ctx);
208  const xAOD::TrackParticleContainer* importedTrackCollection{nullptr};
209  if(!handle.isValid()){
210  ATH_MSG_WARNING("No TrackParticle collection with name " << handle.key() << " found in StoreGate!");
211  return StatusCode::FAILURE;
212  } else {
213  importedTrackCollection = handle.cptr();
214  ATH_MSG_DEBUG("Found TrackParticle collection " << handle.key() << " in StoreGate!");
215  }
216  ATH_MSG_DEBUG("ID TrackParticle container size "<< handle->size());
217 
218  // Typedef for vectors of tracks and muons
219  typedef std::vector<const xAOD::TrackParticle*> TrackBag;
220  typedef std::vector<const xAOD::Muon*> MuonBag;
221 
222  // Select the inner detector tracks
223  const xAOD::Vertex* vx = nullptr;
224  TrackBag theIDTracksAfterSelection;
225  if (m_trktrk || m_mutrk) {
226  xAOD::TrackParticleContainer::const_iterator trkCItr;
227  for (trkCItr=importedTrackCollection->begin(); trkCItr!=importedTrackCollection->end(); ++trkCItr) {
228  const xAOD::TrackParticle* TP = (*trkCItr);
229  if ( fabs(TP->pt())<m_trkThresholdPt ) continue;
230  if ( !m_trkSelector->decision(*TP, vx) ) continue;
231  theIDTracksAfterSelection.push_back(TP);
232  }
233  if (theIDTracksAfterSelection.size() == 0) return StatusCode::SUCCESS;;
234  ATH_MSG_DEBUG("Number of tracks after ID track selection: " << theIDTracksAfterSelection.size());
235  }
236 
237  // Select the muons
238  MuonBag theMuonsAfterSelection;
239  if (m_mumu || m_mutrk) {
240  for (auto muItr=importedMuonCollection->begin(); muItr!=importedMuonCollection->end(); ++muItr) {
241  if ( *muItr == NULL ) continue;
242  if (!(*muItr)->inDetTrackParticleLink().isValid()) continue; // No muons without ID tracks
243  const xAOD::TrackParticle* muonTrk = *((*muItr)->inDetTrackParticleLink());
244  if ( muonTrk==NULL) continue;
245  if ( !m_trkSelector->decision(*muonTrk, vx) ) continue; // all ID tracks must pass basic tracking cuts
246  if ( fabs(muonTrk->pt())<m_thresholdPt ) continue; // higher pt cut if needed
247  if ( m_mcpCuts && !passesMCPCuts(*muItr)) continue; // MCP cuts
248  if ( m_combOnly && (*muItr)->muonType() != xAOD::Muon::Combined ) continue; // require combined muons
249  if ( (*muItr)->muonType() == xAOD::Muon::SiliconAssociatedForwardMuon && !m_useCombMeasurement) continue;
250  theMuonsAfterSelection.push_back(*muItr);
251  }
252  if (theMuonsAfterSelection.size() == 0) return StatusCode::SUCCESS;;
253  ATH_MSG_DEBUG("Number of muons after selection: " << theMuonsAfterSelection.size());
254  }
255 
256  // Sort into pairs - end result will be a vector of JpsiCandidate structs
257  std::vector<JpsiCandidate> jpsiCandidates;
258  if (m_mumu) jpsiCandidates = getPairs(theMuonsAfterSelection);
259  if (m_trktrk) jpsiCandidates = getPairs(theIDTracksAfterSelection);
260  if (m_mutrk) jpsiCandidates = getPairs2Colls(theIDTracksAfterSelection,theMuonsAfterSelection,m_doTagAndProbe);
261 
262 
263  // (1) Enforce one combined muon
264  if (m_atLeastOneComb) {
265  std::vector<JpsiCandidate> selectCandidates;
266  for(auto &cand : jpsiCandidates) { if(cand.muonTypes!=TT) selectCandidates.push_back(cand); }
267  selectCandidates.swap(jpsiCandidates);
268  ATH_MSG_DEBUG("Number of candidates after requirement of at least 1 combined muon: " << jpsiCandidates.size() );
269  }
270 
271  // (2) Establish track content for candidates
272  // and set the appropriate track collections for the combined muon tracks where appropriate (for saving to persistency later)
273 
274  // mu+trk or trk+trk - always ID track collection
275  if (m_mutrk || m_trktrk) {
276  for (auto jpsiItr=jpsiCandidates.begin(); jpsiItr!=jpsiCandidates.end(); ++jpsiItr) {
277  (*jpsiItr).collection1 = importedTrackCollection;
278  (*jpsiItr).collection2 = importedTrackCollection;
279  }
280  }
281 
282  if (m_mumu) {
283  for (auto jpsiItr=jpsiCandidates.begin(); jpsiItr!=jpsiCandidates.end(); ++jpsiItr) {
284  if ( (m_combOnly && !m_useCombMeasurement) || m_atLeastOneComb || m_allMuons) {
285  (*jpsiItr).trackParticle1 = (*jpsiItr).muon1->trackParticle( xAOD::Muon::InnerDetectorTrackParticle );
286  (*jpsiItr).trackParticle2 = (*jpsiItr).muon2->trackParticle( xAOD::Muon::InnerDetectorTrackParticle );
287  (*jpsiItr).collection1 = importedTrackCollection;
288  (*jpsiItr).collection2 = importedTrackCollection;
289  }
290  if (m_combOnly && m_useCombMeasurement) {
291  if (!(*jpsiItr).muon1->combinedTrackParticleLink().isValid()) {
292  (*jpsiItr).trackParticle1 = (*jpsiItr).muon1->trackParticle( xAOD::Muon::InnerDetectorTrackParticle );
293  (*jpsiItr).collection1 = importedTrackCollection;
294  }
295 
296  if (!(*jpsiItr).muon2->combinedTrackParticleLink().isValid()) {
297  (*jpsiItr).trackParticle2 = (*jpsiItr).muon2->trackParticle( xAOD::Muon::InnerDetectorTrackParticle );
298  (*jpsiItr).collection2 = importedTrackCollection;
299  }
300 
301  if ((*jpsiItr).muon1->combinedTrackParticleLink().isValid()) {
302  (*jpsiItr).trackParticle1 = (*jpsiItr).muon1->trackParticle( xAOD::Muon::CombinedTrackParticle );
303  bool foundCollection(false);
304  // Look for correct muon track container
305  for (auto muTrkCollItr=importedMuonTrackCollections.begin(); muTrkCollItr!=importedMuonTrackCollections.end(); ++muTrkCollItr) {
306  if (isContainedIn((*jpsiItr).trackParticle1,*muTrkCollItr)) { (*jpsiItr).collection1 = *muTrkCollItr; foundCollection=true; break;}
307  }
308  if (!foundCollection) { // didn't find the correct muon track container so go back to ID
309  (*jpsiItr).trackParticle1 = (*jpsiItr).muon1->trackParticle( xAOD::Muon::InnerDetectorTrackParticle );
310  (*jpsiItr).collection1 = importedTrackCollection;
311  ATH_MSG_WARNING("Muon track from muon of author " << (*jpsiItr).muon1->author() << " not found in muon track collections you have provided.");
312  ATH_MSG_WARNING("Defaulting to ID track collection - combined measurement will not be used");
313  }
314  }
315 
316  if ((*jpsiItr).muon2->combinedTrackParticleLink().isValid()) {
317  (*jpsiItr).trackParticle2 = (*jpsiItr).muon2->trackParticle( xAOD::Muon::CombinedTrackParticle );
318  bool foundCollection(false);
319  // Look for correct muon track container
320  for (auto muTrkCollItr=importedMuonTrackCollections.begin(); muTrkCollItr!=importedMuonTrackCollections.end(); ++muTrkCollItr) {
321  if (isContainedIn((*jpsiItr).trackParticle2,*muTrkCollItr)) { (*jpsiItr).collection2 = *muTrkCollItr; foundCollection=true; break;}
322  }
323  if (!foundCollection) { // didn't find the correct muon track container so go back to ID
324  (*jpsiItr).trackParticle2 = (*jpsiItr).muon2->trackParticle( xAOD::Muon::InnerDetectorTrackParticle );
325  (*jpsiItr).collection2 = importedTrackCollection;
326  ATH_MSG_WARNING("Muon track from muon of author " << (*jpsiItr).muon2->author() << " not found in muon track collections you have provided.");
327  ATH_MSG_WARNING("Defaulting to ID track collection - combined measurement will not be used");
328  }
329  }
330  } // combined measurement
331  } // iteration over candidates
332  }
333 
334 
335  // (3) Enforce higher track pt if requested
336  if (m_higherPt>0.0) {
337  std::vector<JpsiCandidate> selectCandidates;
338  for(auto& cand : jpsiCandidates){
339  bool reject = (fabs(cand.trackParticle1->pt()) < m_higherPt) && (fabs(cand.trackParticle2->pt()) < m_higherPt);
340  if(!reject) selectCandidates.push_back(cand);
341  }
342  selectCandidates.swap(jpsiCandidates);
343  ATH_MSG_DEBUG("Number of candidates after higherPt cut: " << jpsiCandidates.size() );
344  }
345 
346  // (4) Select all opp/same charged track pairs
347  std::vector<JpsiCandidate> sortedJpsiCandidates;
348  sortedJpsiCandidates = selectCharges(jpsiCandidates);
349 
350  ATH_MSG_DEBUG("Number of candidates after charge selection: " << sortedJpsiCandidates.size() );
351 
352  // (5) Select for decay angle, if requested
353  if (m_collAnglePhi>0.0 && m_collAngleTheta>0.0) {
354  std::vector<JpsiCandidate> selectCandidates;
355  for(auto& cand : sortedJpsiCandidates){
356  double deltatheta = fabs( cand.trackParticle1->theta() - cand.trackParticle2->theta() );
357  double deltaphi = std::abs(xAOD::P4Helpers::deltaPhi(cand.trackParticle1->phi0() , cand.trackParticle2->phi0()));
358  bool reject = (deltatheta > m_collAngleTheta) || (deltaphi > m_collAnglePhi);
359  if(!reject) selectCandidates.push_back(cand);
360  }
361  sortedJpsiCandidates.swap(selectCandidates);
362  ATH_MSG_DEBUG("Number of collimated candidates: " << sortedJpsiCandidates.size() );
363  }
364 
365  // (6) Select for invariant mass, if requested
366  std::array<double,2> trkMasses{m_trk1M, m_trk2M};
367  if ( (m_invMassLower > 0.0) || (m_invMassUpper > 0.0) ) {
368  std::vector<JpsiCandidate> selectCandidates;
369  for(auto& cand : sortedJpsiCandidates){
370  double invMass = getInvariantMass(cand,trkMasses);
371  bool reject = invMass < m_invMassLower || invMass > m_invMassUpper;
372  if(!reject) selectCandidates.push_back(cand);
373  }
374  selectCandidates.swap(sortedJpsiCandidates);
375  ATH_MSG_DEBUG("Number of candidates passing invariant mass selection: " << sortedJpsiCandidates.size() );
376  }
377 
378  ATH_MSG_DEBUG("Number of pairs passing all selections and going to vertexing: " << sortedJpsiCandidates.size() );
379  if (sortedJpsiCandidates.size() == 0) return StatusCode::SUCCESS;;
380  std::vector<const xAOD::TrackParticle*> theTracks;
381  std::vector<const xAOD::Muon*> theStoredMuons;
382  // Fit each pair of tracks to a vertex
383  for(auto jpsiItr=sortedJpsiCandidates.begin(); jpsiItr!=sortedJpsiCandidates.end(); ++jpsiItr) {
384  theTracks.clear();
385  theTracks.push_back((*jpsiItr).trackParticle1);
386  theTracks.push_back((*jpsiItr).trackParticle2);
387  std::unique_ptr<xAOD::Vertex> myVxCandidate {fit(theTracks,importedTrackCollection)}; // This line actually does the fitting and object making
388  if (myVxCandidate) {
389  // Chi2 cut if requested
390  double chi2 = myVxCandidate->chiSquared();
391  ATH_MSG_DEBUG("chi2 is: " << chi2);
392  if (m_Chi2Cut <= 0.0 || chi2 <= m_Chi2Cut) {
393  // decorate the candidate with refitted tracks and muons via the BPhysHelper
394  xAOD::BPhysHelper jpsiHelper(myVxCandidate.get());
395  bool validtrk = jpsiHelper.setRefTrks();
396  if(!validtrk) ATH_MSG_WARNING("Problem setting tracks " << __FILE__ << ':' << __LINE__);
397  if (m_mumu || m_mutrk) {
398  theStoredMuons.clear();
399  theStoredMuons.push_back((*jpsiItr).muon1);
400  if (m_mumu) theStoredMuons.push_back((*jpsiItr).muon2);
401  bool valid = jpsiHelper.setMuons(theStoredMuons,importedMuonCollection);
402  if(!valid) ATH_MSG_WARNING("Problem setting muons " << __FILE__ << ':' << __LINE__);
403  }
404  // Retain the vertex
405  vxContainer.push_back(std::move(myVxCandidate));
406  }
407  } else { // fit failed
408  ATH_MSG_DEBUG("Fitter failed!");
409  // Don't try to delete the object, since we arrived here,
410  // because this pointer is null...
411  //delete myVxCandidate;
412  }
413  }
414  ATH_MSG_DEBUG("vxContainer size " << vxContainer.size());
415 
416  return StatusCode::SUCCESS;;
417  }
418 
419  // *********************************************************************************
420 
421  // ---------------------------------------------------------------------------------
422  // fit - does the fit
423  // ---------------------------------------------------------------------------------
424 
425  xAOD::Vertex* JpsiFinder::fit(const std::vector<const xAOD::TrackParticle*> &inputTracks,const xAOD::TrackParticleContainer* importedTrackCollection) const {
426 
427  const Trk::TrkV0VertexFitter* concreteVertexFitter=0;
428  if (m_useV0Fitter) {
429  // making a concrete fitter for the V0Fitter
430  concreteVertexFitter = dynamic_cast<const Trk::TrkV0VertexFitter * >(m_iV0VertexFitter.get());
431  if(concreteVertexFitter == 0) {
432  ATH_MSG_FATAL("The vertex fitter passed is not a V0 Vertex Fitter");
433  return NULL;
434  }
435  }
436 
437  const Trk::Perigee& aPerigee1 = inputTracks[0]->perigeeParameters();
438  const Trk::Perigee& aPerigee2 = inputTracks[1]->perigeeParameters();
439  int sflag = 0;
440  int errorcode = 0;
441  Amg::Vector3D startingPoint = m_vertexEstimator->getCirclesIntersectionPoint(&aPerigee1,&aPerigee2,sflag,errorcode);
442  if (errorcode != 0) {startingPoint(0) = 0.0; startingPoint(1) = 0.0; startingPoint(2) = 0.0;}
443  if (m_useV0Fitter) {
444  xAOD::Vertex* myVxCandidate = concreteVertexFitter->fit(inputTracks, startingPoint);
445 
446  // Added by ASC
447  if(myVxCandidate != 0){
448  std::vector<ElementLink<DataVector<xAOD::TrackParticle> > > newLinkVector;
449  for(unsigned int i=0; i< myVxCandidate->trackParticleLinks().size(); i++)
450  { ElementLink<DataVector<xAOD::TrackParticle> > mylink=myVxCandidate->trackParticleLinks()[i]; //makes a copy (non-const)
451  mylink.setStorableObject(*importedTrackCollection, true);
452  newLinkVector.push_back( mylink ); }
453 
454  myVxCandidate->clearTracks();
455  myVxCandidate->setTrackParticleLinks( newLinkVector );
456  }
457 
458 
459 
460  return myVxCandidate;
461  } else {
462  xAOD::Vertex* myVxCandidate = m_iVertexFitter->fit(inputTracks, startingPoint);
463 
464  // Added by ASC
465  if(myVxCandidate != 0){
466  std::vector<ElementLink<DataVector<xAOD::TrackParticle> > > newLinkVector;
467  for(unsigned int i=0; i< myVxCandidate->trackParticleLinks().size(); i++)
468  { ElementLink<DataVector<xAOD::TrackParticle> > mylink=myVxCandidate->trackParticleLinks()[i]; //makes a copy (non-const)
469  mylink.setStorableObject(*importedTrackCollection, true);
470  newLinkVector.push_back( mylink ); }
471 
472  myVxCandidate->clearTracks();
473  myVxCandidate->setTrackParticleLinks( newLinkVector );
474  }
475 
476 
477  return myVxCandidate;
478  }
479 
480 
481 
482  return NULL;
483 
484  } // End of fit method
485 
486 
487  // *********************************************************************************
488 
489  // ---------------------------------------------------------------------------------
490  // getPairs: forms up 2-plets of tracks
491  // ---------------------------------------------------------------------------------
492 
493  std::vector<JpsiCandidate> JpsiFinder::getPairs(const std::vector<const xAOD::TrackParticle*> &TracksIn) const {
494 
495  std::vector<JpsiCandidate> myPairs;
496  JpsiCandidate pair;
497  std::vector<const xAOD::TrackParticle*>::const_iterator outerItr;
498  std::vector<const xAOD::TrackParticle*>::const_iterator innerItr;
499 
500  if(TracksIn.size()>=2){
501  for(outerItr=TracksIn.begin();outerItr<TracksIn.end();++outerItr){
502  for(innerItr=(outerItr+1);innerItr!=TracksIn.end();++innerItr){
503  pair.trackParticle1 = *innerItr;
504  pair.trackParticle2 = *outerItr;
505  pair.pairType = TRKTRK;
506  myPairs.push_back(pair);
507  }
508  }
509  }
510 
511  return(myPairs);
512  }
513 
514  // ---------------------------------------------------------------------------------
515  // getPairs: forms up 2-plets of muons
516  // ---------------------------------------------------------------------------------
517 
518  std::vector<JpsiCandidate> JpsiFinder::getPairs(const std::vector<const xAOD::Muon*> &muonsIn) const {
519 
520  std::vector<JpsiCandidate> myPairs;
521  JpsiCandidate pair;
522  std::vector<const xAOD::Muon*>::const_iterator outerItr;
523  std::vector<const xAOD::Muon*>::const_iterator innerItr;
524 
525  if(muonsIn.size()>=2){
526  for(outerItr=muonsIn.begin();outerItr<muonsIn.end();++outerItr){
527  for(innerItr=(outerItr+1);innerItr!=muonsIn.end();++innerItr){
528  pair.muon1 = *innerItr;
529  pair.muon2 = *outerItr;
530  pair.pairType = MUMU;
531  bool mu1Comb( (*innerItr)->muonType() == xAOD::Muon::Combined );
532  bool mu2Comb( (*outerItr)->muonType() == xAOD::Muon::Combined );
533  if (mu1Comb && mu2Comb) pair.muonTypes = CC;
534  if ( (mu1Comb && !mu2Comb) || (!mu1Comb && mu2Comb) ) pair.muonTypes = CT;
535  if (!mu1Comb && !mu2Comb) pair.muonTypes = TT;
536  myPairs.push_back(pair);
537  }
538  }
539  }
540 
541  return(myPairs);
542  }
543 
544  // *********************************************************************************
545 
546  // ---------------------------------------------------------------------------------
547  // getPairs2Colls: forms up 2-plets of tracks from two independent collections
548  // ---------------------------------------------------------------------------------
549 
550  std::vector<JpsiCandidate> JpsiFinder::getPairs2Colls(const std::vector<const xAOD::TrackParticle*> &tracks, const std::vector<const xAOD::Muon*> &muons, bool tagAndProbe) const {
551 
552  std::vector<JpsiCandidate> myPairs;
553  JpsiCandidate pair;
554 
555  // Unless user is running in tag and probe mode, remove tracks which are also identified as muons
556  std::vector<const xAOD::TrackParticle*> tracksToKeep;
557  if (!tagAndProbe) {
558  if(tracks.size()>=1 && muons.size()>=1){
559  for (const xAOD::TrackParticle* trk : tracks) {
560  bool trackIsMuon(false);
561  for (const xAOD::Muon* mu : muons) {
562  auto& link = mu->inDetTrackParticleLink();
563  if ( link.isValid() && *link == trk ) {
564  trackIsMuon=true;
565  break;
566  }
567  }
568  if (!trackIsMuon) tracksToKeep.push_back(trk);
569  }
570  }
571  } else {tracksToKeep = tracks;}
572 
573  if(tracksToKeep.size()>=1 && muons.size()>=1){
574  for (const xAOD::TrackParticle* trk : tracksToKeep) {
575  for (const xAOD::Muon* mu : muons) {
576  pair.muon1 = mu;
577  // Muon track 1st
578  pair.trackParticle1 = mu->trackParticle( xAOD::Muon::InnerDetectorTrackParticle );
579  pair.trackParticle2 = trk;
580  pair.pairType = MUTRK;
581  myPairs.push_back(pair);
582  }
583  }
584  }
585 
586  return(myPairs);
587  }
588 
589 
590 
591  // *********************************************************************************
592 
593  // ---------------------------------------------------------------------------------
594  // getInvariantMass: returns invariant mass
595  // ----------------------------------------------------------getInvariantMass-----------------------
596 
597  double JpsiFinder::getInvariantMass(const JpsiCandidate &jpsiIn, std::span<const double> massHypotheses) const {
598 
599  // construct 4-vectors from track perigee parameters using given mass hypotheses.
600  // NOTE: in new data model (xAOD) the defining parameters are expressed as perigee parameters w.r.t. the beamspot
601  // NOTE2: TrackParticle::p4() method already returns TLorentzVector, however, we want to enforce our own mass hypothesis
602  TLorentzVector mu1;
603  TLorentzVector mu2;
604  mu1.SetVectM(jpsiIn.trackParticle1->p4().Vect(), massHypotheses[0]);
605  mu2.SetVectM(jpsiIn.trackParticle2->p4().Vect(), massHypotheses[1]);
606 
607  return (mu1+mu2).M();
608 
609  }
610 
611  // ---------------------------------------------------------------------------------
612  // selectCharges: selects track pairs with opposite charge / store + before -
613  // Boolean argument is to decide whether to accept oppositely or identically charged
614  // particles (true for oppositely charged)
615  // ---------------------------------------------------------------------------------
616 
617  std::vector<JpsiCandidate> JpsiFinder::selectCharges(const std::vector<JpsiCandidate> &jpsisIn) const {
618 
619  bool opposite(false),same(false),all(false);
620  opposite=m_oppChOnly;
621  same=m_sameChOnly;
622  all=m_allChCombs;
623 
624  JpsiCandidate tmpJpsi;
625  std::vector<JpsiCandidate> jpsis;
626  double qOverP1=0.;
627  double qOverP2=0.;
628  for(auto jpsiItr=jpsisIn.cbegin();jpsiItr!=jpsisIn.cend();jpsiItr++){
629  bool oppCh(false),sameCh(false);
630  tmpJpsi = *jpsiItr;
631  qOverP1=(*jpsiItr).trackParticle1->qOverP();
632  qOverP2=(*jpsiItr).trackParticle2->qOverP();
633  if(qOverP1*qOverP2<0.0) oppCh=true; // product charge < 0
634  if(qOverP1*qOverP2>0.0) sameCh=true; // product charge > 0
635  // +ve should be first so swap
636  // Don't do it for tag and probe analyses (because tag muon must not change position)
637  if (oppCh && qOverP1<0.0 && !m_doTagAndProbe && !m_mutrk) {
638  tmpJpsi.trackParticle1 = (*jpsiItr).trackParticle2;
639  tmpJpsi.trackParticle2 = (*jpsiItr).trackParticle1;
640  tmpJpsi.muon1 = (*jpsiItr).muon2;
641  tmpJpsi.muon2 = (*jpsiItr).muon1;
642  tmpJpsi.collection1 = (*jpsiItr).collection2;
643  tmpJpsi.collection2 = (*jpsiItr).collection1;
644  }
645  if (oppCh && (opposite || all) ) jpsis.push_back(tmpJpsi);
646  if (sameCh && (same || all) ) jpsis.push_back(tmpJpsi);
647 
648  } // end of for loop
649 
650  return(jpsis);
651  }
652 
653  // ---------------------------------------------------------------------------------
654  // Apply the current cuts of the MCP group recommendation.
655  // ---------------------------------------------------------------------------------
656 
657  bool JpsiFinder::passesMCPCuts(const xAOD::Muon* muon) const {
658 
659  return muon->passesIDCuts();
660 
661  }
662 
663  // ---------------------------------------------------------------------------------
664  // Checks whether a TPB is in the collection
665  // ---------------------------------------------------------------------------------
666 
667  bool JpsiFinder::isContainedIn(const xAOD::TrackParticle* theTrack, const xAOD::TrackParticleContainer* theCollection) const {
668  return std::find(theCollection->begin(), theCollection->end(), theTrack) != theCollection->end();
669  }
670 
671  // ---------------------------------------------------------------------------------
672  // trackMomentum: returns refitted track momentum
673  // ---------------------------------------------------------------------------------
674 
675  TVector3 JpsiFinder::trackMomentum(const xAOD::Vertex * vxCandidate, int trkIndex) const
676  {
677  double px = 0., py = 0., pz = 0.;
678  if (0 != vxCandidate) {
679  const Trk::TrackParameters* aPerigee = vxCandidate->vxTrackAtVertex()[trkIndex].perigeeAtVertex();
680  px = aPerigee->momentum()[Trk::px];
681  py = aPerigee->momentum()[Trk::py];
682  pz = aPerigee->momentum()[Trk::pz];
683  }
684  TVector3 mom(px,py,pz);
685  return mom;
686  }
687 
688 }
Analysis::JpsiFinder::m_invMassLower
double m_invMassLower
Definition: JpsiFinder.h:92
xAOD::TrackParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: TrackParticle_v1.cxx:73
Analysis::JpsiCandidate::trackParticle1
const xAOD::TrackParticle * trackParticle1
Definition: JpsiFinder.h:42
Trk::py
@ py
Definition: ParamDefs.h:66
xAOD::muon
@ muon
Definition: TrackingPrimitives.h:195
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
Analysis::JpsiFinder::getPairs
std::vector< JpsiCandidate > getPairs(const std::vector< const xAOD::TrackParticle * > &) const
Definition: JpsiFinder.cxx:493
xAOD::BPhysHelper
Definition: BPhysHelper.h:71
test_pyathena.px
px
Definition: test_pyathena.py:18
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
Analysis::JpsiFinder::performSearch
virtual StatusCode performSearch(const EventContext &ctx, xAOD::VertexContainer &vxContainer) const override
Definition: JpsiFinder.cxx:177
Analysis::JpsiFinder::m_Chi2Cut
double m_Chi2Cut
Definition: JpsiFinder.h:95
P4Helpers::invMass
double invMass(const I4Momentum &pA, const I4Momentum &pB)
invariant mass from two I4momentum references
Definition: P4Helpers.h:239
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
VertexPointEstimator.h
SG::ReadHandle::cptr
const_pointer_type cptr()
Dereference the pointer.
Analysis::JpsiFinder::m_collAngleTheta
double m_collAngleTheta
Definition: JpsiFinder.h:93
Analysis::JpsiFinder::m_trktrk
bool m_trktrk
Definition: JpsiFinder.h:79
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
xAODP4Helpers.h
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
Analysis::JpsiFinder::m_allMuons
bool m_allMuons
Definition: JpsiFinder.h:80
Trk::ParametersT
Dummy class used to allow special convertors to be called for surfaces owned by a detector element.
Definition: EMErrorDetail.h:25
xAOD::Vertex_v1::trackParticleLinks
const TrackParticleLinks_t & trackParticleLinks() const
Get all the particles associated with the vertex.
Analysis::JpsiFinder::m_collAnglePhi
double m_collAnglePhi
Definition: JpsiFinder.h:94
Analysis::JpsiFinder::passesMCPCuts
bool passesMCPCuts(const xAOD::Muon *) const
Definition: JpsiFinder.cxx:657
xAOD::P4Helpers::deltaPhi
double deltaPhi(double phiA, double phiB)
delta Phi in range [-pi,pi[
Definition: xAODP4Helpers.h:69
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
Analysis::JpsiFinder::m_TrkParticleCollection
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_TrkParticleCollection
Definition: JpsiFinder.h:100
Analysis::CT
@ CT
Definition: JpsiFinder.h:39
Analysis::JpsiFinder::m_MuonTrackKeys
SG::ReadHandleKeyArray< xAOD::TrackParticleContainer > m_MuonTrackKeys
Definition: JpsiFinder.h:101
Trk::pz
@ pz
global momentum (cartesian)
Definition: ParamDefs.h:67
Analysis::JpsiFinder::m_vertexEstimator
ToolHandle< InDet::VertexPointEstimator > m_vertexEstimator
Definition: JpsiFinder.h:105
Analysis::TRKTRK
@ TRKTRK
Definition: JpsiFinder.h:38
python.TrigEgammaFastCaloHypoTool.same
def same(val, tool)
Definition: TrigEgammaFastCaloHypoTool.py:12
Analysis::JpsiFinder::m_iVertexFitter
ToolHandle< Trk::IVertexFitter > m_iVertexFitter
Definition: JpsiFinder.h:102
DerivationFramework::MuonBag
std::vector< const xAOD::Muon * > MuonBag
Definition: BPhysAddMuonBasedInvMass.h:33
xAOD::Muon_v1
Class describing a Muon.
Definition: Muon_v1.h:38
Analysis::JpsiCandidate::muonTypes
MuonTypes muonTypes
Definition: JpsiFinder.h:49
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
Analysis::JpsiFinder::m_combOnly
bool m_combOnly
Definition: JpsiFinder.h:81
Analysis::JpsiFinder::isContainedIn
bool isContainedIn(const xAOD::TrackParticle *, const xAOD::TrackParticleContainer *) const
Definition: JpsiFinder.cxx:667
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
xAOD::TrackParticle_v1::p4
virtual FourMom_t p4() const override final
The full 4-momentum of the particle.
Definition: TrackParticle_v1.cxx:129
Analysis::JpsiFinder::selectCharges
std::vector< JpsiCandidate > selectCharges(const std::vector< JpsiCandidate > &) const
Definition: JpsiFinder.cxx:617
calibdata.valid
list valid
Definition: calibdata.py:45
Analysis::JpsiFinder::trackMomentum
TVector3 trackMomentum(const xAOD::Vertex *vxCandidate, int trkIndex) const
Definition: JpsiFinder.cxx:675
ParticleGun_EoverP_Config.mom
mom
Definition: ParticleGun_EoverP_Config.py:63
Analysis::JpsiFinder::m_mumu
bool m_mumu
Definition: JpsiFinder.h:77
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
Analysis::JpsiCandidate::collection1
const xAOD::TrackParticleContainer * collection1
Definition: JpsiFinder.h:46
python.TrigInDetConfig.inputTracks
inputTracks
Definition: TrigInDetConfig.py:168
lumiFormat.i
int i
Definition: lumiFormat.py:92
Analysis::JpsiFinder::m_sameChOnly
bool m_sameChOnly
Definition: JpsiFinder.h:97
Analysis::JpsiFinder::m_useCombMeasurement
bool m_useCombMeasurement
Definition: JpsiFinder.h:83
Analysis::MUTRK
@ MUTRK
Definition: JpsiFinder.h:38
beamspotman.n
n
Definition: beamspotman.py:731
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
Analysis::JpsiFinder::m_allChCombs
bool m_allChCombs
Definition: JpsiFinder.h:98
Analysis::JpsiFinder::getInvariantMass
double getInvariantMass(const JpsiCandidate &, std::span< const double >) const
Definition: JpsiFinder.cxx:597
Analysis::JpsiCandidate::collection2
const xAOD::TrackParticleContainer * collection2
Definition: JpsiFinder.h:47
Analysis::JpsiFinder::JpsiFinder
JpsiFinder(const std::string &t, const std::string &n, const IInterface *p)
Definition: JpsiFinder.cxx:108
xAOD::Vertex_v1::setTrackParticleLinks
void setTrackParticleLinks(const TrackParticleLinks_t &trackParticles)
Set all track particle links at once.
chi2
double chi2(TH1 *h0, TH1 *h1)
Definition: comparitor.cxx:522
Trk::px
@ px
Definition: ParamDefs.h:65
Amg::pz
@ pz
Definition: GeoPrimitives.h:40
MUON
xAOD::Muon MUON
D3PD INCLUDES.
Definition: TileCellFillerTool.h:37
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
Analysis::JpsiFinder::m_doTagAndProbe
bool m_doTagAndProbe
Definition: JpsiFinder.h:107
Analysis::JpsiFinder::m_useV0Fitter
bool m_useV0Fitter
Definition: JpsiFinder.h:84
Analysis::JpsiCandidate::muon2
const xAOD::Muon * muon2
Definition: JpsiFinder.h:45
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
Trk::ParametersBase
Definition: ParametersBase.h:55
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::JpsiFinder::m_muonCollectionKey
SG::ReadHandleKey< xAOD::MuonContainer > m_muonCollectionKey
Definition: JpsiFinder.h:99
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
Analysis::JpsiFinder::m_trk1M
double m_trk1M
Definition: JpsiFinder.h:86
Trk::Combined
@ Combined
Definition: TrackSummaryTool.h:32
xAOD::BPhysHelper::setMuons
bool setMuons(const std::vector< const xAOD::Muon * > &muons, const xAOD::MuonContainer *muonContainer)
Set links to muons.
Definition: BPhysHelper.cxx:479
Amg::py
@ py
Definition: GeoPrimitives.h:39
Analysis::JpsiFinder::m_mutrk
bool m_mutrk
Definition: JpsiFinder.h:78
xAOD::TrackParticle_v1::qOverP
float qOverP() const
Returns the parameter.
Analysis::JpsiFinder::m_higherPt
double m_higherPt
Definition: JpsiFinder.h:89
Analysis
The namespace of all packages in PhysicsAnalysis/JetTagging.
Definition: BTaggingCnvAlg.h:20
Analysis::JpsiFinder::m_atLeastOneComb
bool m_atLeastOneComb
Definition: JpsiFinder.h:82
Analysis::JpsiFinder::m_oppChOnly
bool m_oppChOnly
Definition: JpsiFinder.h:96
Analysis::JpsiFinder::getPairs2Colls
std::vector< JpsiCandidate > getPairs2Colls(const std::vector< const xAOD::TrackParticle * > &, const std::vector< const xAOD::Muon * > &, bool) const
Definition: JpsiFinder.cxx:550
Analysis::JpsiCandidate::trackParticle2
const xAOD::TrackParticle * trackParticle2
Definition: JpsiFinder.h:43
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
Analysis::JpsiFinder::~JpsiFinder
~JpsiFinder()
Definition: JpsiFinder.cxx:172
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
Analysis::JpsiCandidate::muon1
const xAOD::Muon * muon1
Definition: JpsiFinder.h:44
SG::VarHandleBase::key
virtual const std::string & key() const override final
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleBase.cxx:64
IVertexFitter.h
TrkV0VertexFitter.h
BPhysHelper.h
: B-physics xAOD helpers.
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
Cut::all
@ all
Definition: SUSYToolsAlg.cxx:64
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
Trk::ParametersBase::momentum
const Amg::Vector3D & momentum() const
Access method for the momentum.
Trk::TrkV0VertexFitter::fit
virtual xAOD::Vertex * fit(const std::vector< const xAOD::TrackParticle * > &vectorTrk, const Amg::Vector3D &startingPoint) const override
Interface for xAOD::TrackParticle with Amg::Vector3D starting point.
Definition: TrkV0VertexFitter.cxx:83
VertexContainer.h
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
JpsiFinder.h
Analysis::JpsiFinder::initialize
virtual StatusCode initialize() override
Definition: JpsiFinder.cxx:32
Analysis::JpsiFinder::m_trkThresholdPt
double m_trkThresholdPt
Definition: JpsiFinder.h:90
Analysis::JpsiFinder::m_invMassUpper
double m_invMassUpper
Definition: JpsiFinder.h:91
Trk::TrkV0VertexFitter
This class implements a vertex fitting algorithm optimised for V0 finding.
Definition: TrkV0VertexFitter.h:40
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
Analysis::JpsiFinder::m_forceTagAndProbe
bool m_forceTagAndProbe
Definition: JpsiFinder.h:108
xAOD::Vertex_v1::vxTrackAtVertex
std::vector< Trk::VxTrackAtVertex > & vxTrackAtVertex()
Non-const access to the VxTrackAtVertex vector.
Definition: Vertex_v1.cxx:181
Analysis::JpsiCandidate::pairType
PairType pairType
Definition: JpsiFinder.h:48
Analysis::MUMU
@ MUMU
Definition: JpsiFinder.h:38
AthAlgTool
Definition: AthAlgTool.h:26
Analysis::JpsiFinder::m_trkSelector
ToolHandle< Trk::ITrackSelectorTool > m_trkSelector
Definition: JpsiFinder.h:104
Analysis::TT
@ TT
Definition: JpsiFinder.h:39
ITrackSelectorTool.h
Analysis::JpsiCandidate
Definition: JpsiFinder.h:41
Analysis::JpsiFinder::m_thresholdPt
double m_thresholdPt
Definition: JpsiFinder.h:88
Analysis::JpsiFinder::m_trk2M
double m_trk2M
Definition: JpsiFinder.h:87
CaloNoise_fillDB.mu
mu
Definition: CaloNoise_fillDB.py:53
Analysis::JpsiFinder::m_iV0VertexFitter
ToolHandle< Trk::IVertexFitter > m_iV0VertexFitter
Definition: JpsiFinder.h:103
Analysis::JpsiFinder::m_diMuons
bool m_diMuons
Definition: JpsiFinder.h:85
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
TrackParticleContainer.h
Analysis::JpsiFinder::fit
xAOD::Vertex * fit(const std::vector< const xAOD::TrackParticle * > &, const xAOD::TrackParticleContainer *importedTrackCollection) const
Definition: JpsiFinder.cxx:425
Analysis::CC
@ CC
Definition: JpsiFinder.h:39
HepMCHelpers.h
Analysis::JpsiFinder::m_mcpCuts
bool m_mcpCuts
Definition: JpsiFinder.h:106
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
Generated on Sun Jun 30 2024 21:19:13 for ATLAS Offline Software by   doxygen 1.8.18