ATLAS Offline Software
FourMuonTool.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 // ****************************************************************************
6 // ----------------------------------------------------------------------------
7 // FourMuonTool
8 // James Catmore <James.Catmore@cern.ch>
9 // Evelina Bouhova-Thacker <e.bouhova@cern.ch>
10 // ----------------------------------------------------------------------------
11 // ****************************************************************************
12 
13 #include "FourMuonTool.h"
14 #include "BPhysPVTools.h"
15 #include "xAODBPhys/BPhysHelper.h"
16 #include "TrkVertexFitterInterfaces/IVertexFitter.h"
17 #include "TrkV0Fitter/TrkV0VertexFitter.h"
18 #include "TrkToolInterfaces/ITrackSelectorTool.h"
19 #include "AthLinks/ElementLink.h"
20 
21 #include "xAODTracking/Vertex.h"
22 #include "xAODTracking/VertexContainer.h"
23 #include "xAODTracking/VertexAuxContainer.h"
24 #include "xAODTracking/TrackParticle.h"
25 #include "xAODTracking/TrackParticleContainer.h"
26 #include "StoreGate/WriteDecorHandle.h"
27 
28 #include <algorithm>
29 
30 namespace DerivationFramework {
31 
32  StatusCode FourMuonTool::initialize() {
33 
34  // retrieving vertex Fitter
35  if ( m_iVertexFitter.retrieve().isFailure() ) {
36  ATH_MSG_FATAL("Failed to retrieve tool " << m_iVertexFitter);
37  return StatusCode::FAILURE;
38  } else {
39  ATH_MSG_DEBUG("Retrieved tool " << m_iVertexFitter);
40  }
41 
42  // retrieving V0 Fitter
43  ATH_CHECK( m_iV0VertexFitter.retrieve(DisableTool{!m_useV0Fitter}));
44 
45  // Get the track selector tool from ToolSvc
46  if ( m_trkSelector.retrieve().isFailure() ) {
47  ATH_MSG_FATAL("Failed to retrieve tool " << m_trkSelector);
48  return StatusCode::FAILURE;
49  } else {
50  ATH_MSG_DEBUG("Retrieved tool " << m_trkSelector);
51  }
52 
53  // Get the beam spot service
54  CHECK( m_eventInfo_key.initialize() );
55  ATH_CHECK(m_muonCollectionKey.initialize());
56  ATH_CHECK(m_TrkParticleCollection.initialize());
57  m_muonIndex = m_muonCollectionKey.key() + ".BPHY4MuonIndex";
58  ATH_CHECK(m_muonIndex.initialize());
59  ATH_MSG_DEBUG("Initialize successful");
60 
61  return StatusCode::SUCCESS;
62 
63  }
64 
65  FourMuonTool::FourMuonTool(const std::string& t, const std::string& n, const IInterface* p) : AthAlgTool(t,n,p),
66  m_ptCut(0.0),
67  m_etaCut(0.0),
68  m_useV0Fitter(false),
69  m_muonCollectionKey("Muons"),
70  m_TrkParticleCollection("TrackParticleCandidate"),
71  m_iVertexFitter("Trk::TrkVKalVrtFitter"),
72  m_iV0VertexFitter("Trk::V0VertexFitter"),
73  m_trkSelector("InDet::TrackSelectorTool")
74  {
75  declareProperty("ptCut",m_ptCut);
76  declareProperty("etaCut",m_etaCut);
77  declareProperty("useV0Fitter",m_useV0Fitter);
78  declareProperty("muonCollectionKey",m_muonCollectionKey);
79  declareProperty("TrackParticleCollection",m_TrkParticleCollection);
80  declareProperty("TrkVertexFitterTool",m_iVertexFitter);
81  declareProperty("V0VertexFitterTool",m_iV0VertexFitter);
82  declareProperty("TrackSelectorTool",m_trkSelector);
83  }
84 
85  FourMuonTool::~FourMuonTool() { }
86 
87  //-------------------------------------------------------------------------------------
88  // Find the candidates
89  //-------------------------------------------------------------------------------------
90  StatusCode FourMuonTool::performSearch(xAOD::VertexContainer*& pairVxContainer, xAOD::VertexAuxContainer*& pairVxAuxContainer,
91  xAOD::VertexContainer*& quadVxContainer, xAOD::VertexAuxContainer*& quadVxAuxContainer, bool &selectEvent) const
92  {
93  ATH_MSG_DEBUG( "FourMuonTool::performSearch" );
94  selectEvent = false;
95 
96  // pairs
97  pairVxContainer = new xAOD::VertexContainer;
98  pairVxAuxContainer = new xAOD::VertexAuxContainer;
99  pairVxContainer->setStore(pairVxAuxContainer);
100  // quads
101  quadVxContainer = new xAOD::VertexContainer;
102  quadVxAuxContainer = new xAOD::VertexAuxContainer;
103  quadVxContainer->setStore(quadVxAuxContainer);
104 
105 
106  // Get the muons from StoreGate
107  SG::ReadHandle<xAOD::MuonContainer> importedMuonCollection(m_muonCollectionKey);
108  ATH_CHECK(importedMuonCollection.isValid());
109  ATH_MSG_DEBUG("Muon container size "<<importedMuonCollection->size());
110 
111  // Get ID tracks
112  SG::ReadHandle<xAOD::TrackParticleContainer> importedTrackCollection(m_TrkParticleCollection);
113  ATH_CHECK(importedTrackCollection.isValid());
114  ATH_MSG_DEBUG("ID TrackParticle container size "<< importedTrackCollection->size());
115 
116  // Select the muons
117  std::vector<const xAOD::Muon*> theMuonsAfterSelection;
118  SG::WriteDecorHandle<xAOD::MuonContainer, int> muonDecorator(m_muonIndex);
119  unsigned int nCombMuons = 0;
120  unsigned int nSegmentTaggedMuons = 0;
121 
122  for (auto muItr=importedMuonCollection->begin(); muItr!=importedMuonCollection->end(); ++muItr) {
123  if ( *muItr == NULL ) continue;
124  muonDecorator(**muItr) = -1; // all muons must be decorated
125  if ( ((*muItr)->muonType() != xAOD::Muon::Combined ) && ((*muItr)->muonType() != xAOD::Muon::SegmentTagged ) ) continue;
126  if (!(*muItr)->inDetTrackParticleLink().isValid()) continue; // No muons without ID tracks
127  auto& link = (*muItr)->inDetTrackParticleLink();
128  const xAOD::TrackParticle* muonTrk = *link;
129  if ( muonTrk==NULL) continue;
130  const xAOD::Vertex* vx = nullptr;
131  if ( !m_trkSelector->decision(*muonTrk, vx) ) continue; // all ID tracks must pass basic tracking cuts
132  if ( fabs(muonTrk->pt())<m_ptCut ) continue; // pt cut
133  if ( fabs(muonTrk->eta())>m_etaCut ) continue; // eta cut
134  if ( (*muItr)->muonType() == xAOD::Muon::Combined ) ++nCombMuons;
135  if ( (*muItr)->muonType() == xAOD::Muon::SegmentTagged ) ++nSegmentTaggedMuons;
136  theMuonsAfterSelection.push_back(*muItr);
137  }
138  unsigned int nSelectedMuons = theMuonsAfterSelection.size();
139  ATH_MSG_DEBUG("Number of muons after selection: " << nSelectedMuons);
140  ATH_MSG_DEBUG("of which " << nCombMuons << " are combined");
141  ATH_MSG_DEBUG("and " << nSegmentTaggedMuons << " are segment tagged");
142  if ( (nSelectedMuons < 4) || (nCombMuons < 1) ) {
143  ATH_MSG_DEBUG("Muon criteria not met. Skipping event.");
144  return StatusCode::SUCCESS;
145  }
146  selectEvent = true; // if we got this far we should definitively accept the event
147 
148  // Decorators
149  SG::AuxElement::Decorator< std::string > indexDecorator("CombinationCode");
150  SG::AuxElement::Decorator< std::string > chargeDecorator("ChargeCode");
151  //SG::AuxElement::Decorator< double > acdcDecorator("ACminusDC");
152  //SG::AuxElement::Decorator< double > ssdcDecorator("SSminusDC");
153 
154  // Order by pT
155  std::sort(theMuonsAfterSelection.begin(), theMuonsAfterSelection.end(), [](const xAOD::Muon *a, const xAOD::Muon *b) {
156  return b->pt() < a->pt();
157  });
158 
159  // Decorate the selected muons (now pT ordered) with their index
160  unsigned int muonIndex(0);
161  for (auto selMuon : theMuonsAfterSelection) {
162  muonDecorator(*selMuon) = muonIndex;
163  ++muonIndex;
164  }
165 
166  // Quadruplet combinatorics
167  std::vector<Combination> quadruplets;
168  std::vector<Combination> pairs;
169  buildCombinations(theMuonsAfterSelection,pairs,quadruplets,nSelectedMuons);
170  if (quadruplets.size()==0) {
171  ATH_MSG_DEBUG("No acceptable quadruplets");
172  return StatusCode::SUCCESS;
173  }
174 
175  // Get the beam spot (for the vertexing starting point)
176  SG::ReadHandle<xAOD::EventInfo> evt(m_eventInfo_key);
177  if(not evt.isValid()) ATH_MSG_ERROR("Cannot Retrieve " << evt.key() );
178  const Amg::Vector3D beamSpot(evt->beamPosX(), evt->beamPosY(), evt->beamPosZ());
179 
180  // fit pairs
181  ATH_MSG_DEBUG("Successful pairs.....");
182  for (std::vector<Combination>::iterator pairItr = pairs.begin(); pairItr!=pairs.end(); ++pairItr) {
183  std::vector<const xAOD::TrackParticle*> theTracks = (*pairItr).trackParticles("pair1");
184  xAOD::Vertex* pairVxCandidate = fit(theTracks,importedTrackCollection.get(),beamSpot); // This line actually does the fitting and object making
185  if (pairVxCandidate != 0) {
186  // decorate the candidate with its codes
187  indexDecorator(*pairVxCandidate) = (*pairItr).combinationIndices();
188  chargeDecorator(*pairVxCandidate) = (*pairItr).combinationCharges();
189  // decorate the candidate with refitted tracks and muons via the BPhysHelper
190  xAOD::BPhysHelper helper(pairVxCandidate);
191  helper.setRefTrks();
192  std::vector<const xAOD::Muon*> theStoredMuons;
193  theStoredMuons = (*pairItr).muons;
194  helper.setMuons(theStoredMuons,importedMuonCollection.get());
195  // Retain the vertex
196  pairVxContainer->push_back(pairVxCandidate);
197  ATH_MSG_DEBUG("..... indices: " << (*pairItr).combinationIndices() <<
198  " charges: " << (*pairItr).combinationCharges() <<
199  " chi2: " << pairVxCandidate->chiSquared());
200  } else { // fit failed
201  ATH_MSG_DEBUG("Fitter failed!");
202  }
203  }
204  ATH_MSG_DEBUG("pairContainer size " << pairVxContainer->size());
205 
206  // fit quadruplets
207  ATH_MSG_DEBUG("Successful quadruplets.....");
208  for (std::vector<Combination>::iterator quadItr = quadruplets.begin(); quadItr!=quadruplets.end(); ++quadItr) {
209  std::vector<const xAOD::TrackParticle*> theDCTracks; theDCTracks.clear();
210  //std::vector<const xAOD::TrackParticle*> theACTracks; theACTracks.clear();
211  //std::vector<const xAOD::TrackParticle*> theSSTracks; theSSTracks.clear();
212  theDCTracks = (*quadItr).trackParticles("DC");
213  //theACTracks = (*quadItr).trackParticles("AC");
214  //theSSTracks = (*quadItr).trackParticles("SS");
215  xAOD::Vertex* dcVxCandidate = fit(theDCTracks,importedTrackCollection.get(), beamSpot);
216  //xAOD::Vertex* acVxCandidate = fit(theACTracks,importedTrackCollection, beamSpot);
217  //xAOD::Vertex* ssVxCandidate = fit(theSSTracks,importedTrackCollection, beamSpot);
218  // Get the chi2 for each one
219  //double acChi2(0.0);
220  //double ssChi2(0.0);
221  //if (acVxCandidate != 0) {acChi2 = acVxCandidate->chiSquared();}
222  //if (ssVxCandidate != 0) {ssChi2 = ssVxCandidate->chiSquared();}
223  if (dcVxCandidate != 0) {
224  // decorate the candidate with its codes
225  indexDecorator(*dcVxCandidate) = (*quadItr).combinationIndices();
226  chargeDecorator(*dcVxCandidate) = (*quadItr).combinationCharges();
227  // Decorate the DC candidate with the differences between its chi2 and the other
228  double dcChi2 = dcVxCandidate->chiSquared();
229  //acdcDecorator(*dcVxCandidate) = acChi2 - dcChi2;
230  //ssdcDecorator(*dcVxCandidate) = ssChi2 - dcChi2;
231  // decorate the candidate with refitted tracks and muons via the BPhysHelper
232  xAOD::BPhysHelper helper(dcVxCandidate);
233  helper.setRefTrks();
234  const std::vector<const xAOD::Muon*> &theStoredMuons = (*quadItr).muons;
235  helper.setMuons(theStoredMuons,importedMuonCollection.get());
236  // Retain the vertex
237  quadVxContainer->push_back(dcVxCandidate);
238  ATH_MSG_DEBUG("..... indices: " << (*quadItr).combinationIndices() <<
239  " charges: " << (*quadItr).combinationCharges() <<
240  " chi2(DC): " << dcChi2);
241  //" chi2(AC): " << acChi2 <<
242  //" chi2(SS): " << ssChi2);
243  } else { // fit failed
244  ATH_MSG_DEBUG("Fitter failed!");
245  }
246  }
247  ATH_MSG_DEBUG("quadruplet container size " << quadVxContainer->size());
248 
249  return StatusCode::SUCCESS;;
250  }
251 
252  // *********************************************************************************
253 
254  // ---------------------------------------------------------------------------------
255  // fit - does the fit
256  // ---------------------------------------------------------------------------------
257 
258  xAOD::Vertex* FourMuonTool::fit(const std::vector<const xAOD::TrackParticle*> &inputTracks,
259  const xAOD::TrackParticleContainer* importedTrackCollection,
260  const Amg::Vector3D &beamSpot) const {
261 
262  const Trk::TrkV0VertexFitter* concreteVertexFitter=0;
263  if (m_useV0Fitter) {
264  // making a concrete fitter for the V0Fitter
265  concreteVertexFitter = dynamic_cast<const Trk::TrkV0VertexFitter * >(&(*m_iV0VertexFitter));
266  if(concreteVertexFitter == 0) {
267  ATH_MSG_FATAL("The vertex fitter passed is not a V0 Vertex Fitter");
268  return NULL;
269  }
270  }
271 
272  xAOD::Vertex* myVxCandidate = nullptr;
273  if (m_useV0Fitter) {
274  myVxCandidate = concreteVertexFitter->fit(inputTracks, beamSpot /*vertex startingPoint*/ );
275  } else {
276  myVxCandidate = m_iVertexFitter->fit(inputTracks, beamSpot /*vertex startingPoint*/ );
277  }
278 
279  if(myVxCandidate) BPhysPVTools::PrepareVertexLinks(myVxCandidate, importedTrackCollection);
280 
281  return myVxCandidate;
282 
283  } // End of fit method
284 
285 
286  // *********************************************************************************
287 
288  // ---------------------------------------------------------------------------------
289  // getQuadIndices: forms up index lists
290  // ---------------------------------------------------------------------------------
291 
292  std::vector<std::vector<unsigned int> > FourMuonTool::getQuadIndices(unsigned int length) {
293 
294  std::vector<std::vector<unsigned int> > quadIndices = mFromN(4,length);
295  return(quadIndices);
296  }
297 
298 
299  // *********************************************************************************
300 
301  // ---------------------------------------------------------------------------------
302  // mFromN and combinatorics
303  // ---------------------------------------------------------------------------------
304  std::vector<std::vector<unsigned int> > FourMuonTool::mFromN(unsigned int m, unsigned int N) {
305 
306  std::vector<std::vector<unsigned int> > allCombinations;
307  std::vector<unsigned int> mainList;
308  std::vector<unsigned int> combination;
309  for (unsigned int i=0; i<N; ++i) mainList.push_back(i);
310  combinatorics(0,m,combination,mainList,allCombinations);
311  return allCombinations;
312  }
313 
314  void FourMuonTool::combinatorics(unsigned int offset,
315  unsigned int k,
316  std::vector<unsigned int> &combination,
317  std::vector<unsigned int> &mainList,
318  std::vector<std::vector<unsigned int> > &allCombinations) {
319  if (k==0) {
320  allCombinations.push_back(combination);
321  return;
322  }
323  if (k>0) {
324  for (unsigned int i=offset; i<=mainList.size()-k; ++i) {
325  combination.push_back(mainList[i]);
326  combinatorics(i+1,k-1,combination,mainList,allCombinations);
327  combination.pop_back();
328  }
329  }
330  }
331 
332  // ---------------------------------------------------------------------------------
333  // getPairIndices
334  // ---------------------------------------------------------------------------------
335 
336  std::vector<std::pair<unsigned int, unsigned int> > FourMuonTool::getPairIndices(unsigned int length){
337 
338  std::vector<std::pair<unsigned int, unsigned int> > uniquePairs;
339  std::vector<std::vector<unsigned int> > doublets = mFromN(2,length);
340  for (std::vector<std::vector<unsigned int> >::iterator it=doublets.begin(); it!=doublets.end(); ++it) {
341  std::pair<unsigned int, unsigned int> tmpPair = std::make_pair((*it).at(0),(*it).at(1));
342  uniquePairs.push_back(tmpPair);
343  }
344 
345  return(uniquePairs);
346  }
347 
348 
349 
350  // *********************************************************************************
351 
352  // ---------------------------------------------------------------------------------
353  // buildCombinations: forms up the quadruplet of muons/tracks
354  // ---------------------------------------------------------------------------------
355 
356  void FourMuonTool::buildCombinations(const std::vector<const xAOD::Muon*> &muonsIn,
357  std::vector<Combination> &pairs,
358  std::vector<Combination> &quadruplets,
359  unsigned int nSelectedMuons) {
360 
361  std::vector<std::vector<unsigned int> > quadrupletIndices = getQuadIndices(nSelectedMuons);
362  std::vector<std::pair<unsigned int, unsigned int> > pairIndices = getPairIndices(nSelectedMuons);
363 
364  // Quadruplets
365  std::vector<std::vector<unsigned int> >::iterator quadItr;
366  for (quadItr=quadrupletIndices.begin(); quadItr!=quadrupletIndices.end(); ++quadItr) {
367  const std::vector<unsigned int> &quad = (*quadItr);
368  std::vector<const xAOD::Muon*> theMuons = {muonsIn[quad[0]],muonsIn[quad[1]],muonsIn[quad[2]],muonsIn[quad[3]]};
369  if (!passesQuadSelection(theMuons)) continue;
370  Combination tmpQuad;
371  tmpQuad.muons = std::move(theMuons);
372  tmpQuad.quadIndices = quad;
373  quadruplets.emplace_back(std::move(tmpQuad));
374  }
375  if (quadruplets.size() == 0) return;
376 
377  // pairs
378  std::vector<std::pair<unsigned int, unsigned int> >::iterator pairItr;
379  for (pairItr=pairIndices.begin(); pairItr!=pairIndices.end(); ++pairItr) {
380  std::pair<unsigned int, unsigned int> pair = (*pairItr);
381  Combination tmpPair;
382  std::vector<const xAOD::Muon*> theMuons = {muonsIn[pair.first],muonsIn[pair.second]};
383  tmpPair.muons = std::move(theMuons);
384  tmpPair.pairIndices = pair;
385  pairs.emplace_back(std::move(tmpPair));
386  }
387 
388  return;
389 
390  }
391 
392  // *********************************************************************************
393 
394  // ---------------------------------------------------------------------------------
395  // passesQuadSelection: 4-muon selection
396  // ---------------------------------------------------------------------------------
397 
398  bool FourMuonTool::passesQuadSelection(const std::vector<const xAOD::Muon*> &muons) {
399  bool accept(false);
400  bool charges(true);
401  bool quality(false);
402  //unsigned int sumCharges = abs(mu0->charge() + mu1->charge() + mu2->charge() + mu3->charge());
403  //if (sumCharges<4) charges = true;
404  if (( muons.at(0)->muonType() == xAOD::Muon::Combined ) ||
405  ( muons.at(1)->muonType() == xAOD::Muon::Combined ) ||
406  ( muons.at(2)->muonType() == xAOD::Muon::Combined ) ||
407  ( muons.at(3)->muonType() == xAOD::Muon::Combined )
408  ) quality = true;
409  if (charges && quality) accept = true;
410  return accept;
411  }
412 
413 }
BPhysPVTools.h
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
xAOD::TrackParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: TrackParticle_v1.cxx:74
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
xAOD::BPhysHelper
Definition: BPhysHelper.h:71
xAOD::VertexAuxContainer_v1
Temporary container used until we have I/O for AuxStoreInternal.
Definition: VertexAuxContainer_v1.h:32
DerivationFramework::FourMuonTool::m_ptCut
double m_ptCut
Definition: FourMuonTool.h:160
DerivationFramework::FourMuonTool::FourMuonTool
FourMuonTool(const std::string &t, const std::string &n, const IInterface *p)
Definition: FourMuonTool.cxx:65
DerivationFramework::FourMuonTool::m_muonCollectionKey
SG::ReadHandleKey< xAOD::MuonContainer > m_muonCollectionKey
Definition: FourMuonTool.h:163
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
xAOD::TrackParticle_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition: TrackParticle_v1.cxx:78
DerivationFramework::FourMuonTool::m_useV0Fitter
bool m_useV0Fitter
Definition: FourMuonTool.h:162
DerivationFramework::FourMuonTool::m_iV0VertexFitter
ToolHandle< Trk::IVertexFitter > m_iV0VertexFitter
Definition: FourMuonTool.h:166
CutsMETMaker::accept
StatusCode accept(const xAOD::Muon *mu)
Definition: CutsMETMaker.cxx:18
DerivationFramework::FourMuonTool::combinatorics
static void combinatorics(unsigned int offset, unsigned int k, std::vector< unsigned int > &combination, std::vector< unsigned int > &mainList, std::vector< std::vector< unsigned int > > &allCombinations)
Definition: FourMuonTool.cxx:314
DerivationFramework::FourMuonTool::passesQuadSelection
static bool passesQuadSelection(const std::vector< const xAOD::Muon * > &muonsIn)
Definition: FourMuonTool.cxx:398
skel.it
it
Definition: skel.GENtoEVGEN.py:407
DerivationFramework::FourMuonTool::mFromN
static std::vector< std::vector< unsigned int > > mFromN(unsigned int m, unsigned int n)
Definition: FourMuonTool.cxx:304
JetTiledMap::N
@ N
Definition: TiledEtaPhiMap.h:44
LArG4FSStartPointFilter.evt
evt
Definition: LArG4FSStartPointFilter.py:42
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
DerivationFramework::FourMuonTool::fit
xAOD::Vertex * fit(const std::vector< const xAOD::TrackParticle * > &, const xAOD::TrackParticleContainer *importedTrackCollection, const Amg::Vector3D &beamSpot) const
Definition: FourMuonTool.cxx:258
xAOD::VertexContainer
VertexContainer_v1 VertexContainer
Definition of the current "Vertex container version".
Definition: VertexContainer.h:14
xAOD::Muon_v1
Class describing a Muon.
Definition: Muon_v1.h:38
python.CreateTierZeroArgdict.pairs
pairs
Definition: CreateTierZeroArgdict.py:201
runBeamSpotCalibration.helper
helper
Definition: runBeamSpotCalibration.py:115
DerivationFramework::FourMuonTool::m_iVertexFitter
ToolHandle< Trk::IVertexFitter > m_iVertexFitter
Definition: FourMuonTool.h:165
DerivationFramework::FourMuonTool::m_muonIndex
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_muonIndex
Definition: FourMuonTool.h:169
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
SG::Decorator
Helper class to provide type-safe access to aux data.
Definition: Decorator.h:59
python.TrigInDetConfig.inputTracks
inputTracks
Definition: TrigInDetConfig.py:191
xAOD::VertexAuxContainer
VertexAuxContainer_v1 VertexAuxContainer
Definition of the current jet auxiliary container.
Definition: VertexAuxContainer.h:19
lumiFormat.i
int i
Definition: lumiFormat.py:85
beamspotman.n
n
Definition: beamspotman.py:727
DerivationFramework::FourMuonTool::performSearch
StatusCode performSearch(xAOD::VertexContainer *&pairVxContainer, xAOD::VertexAuxContainer *&pairVxAuxContainer, xAOD::VertexContainer *&quadVxContainer, xAOD::VertexAuxContainer *&quadVxAuxContainer, bool &acceptEvent) const
Definition: FourMuonTool.cxx:90
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
SG::ReadHandle::get
const_pointer_type get() const
Dereference the pointer, but don't cache anything.
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
SG::WriteDecorHandle
Handle class for adding a decoration to an object.
Definition: StoreGate/StoreGate/WriteDecorHandle.h:100
DerivationFramework::Combination::quadIndices
std::vector< unsigned int > quadIndices
Definition: FourMuonTool.h:39
WriteDecorHandle.h
Handle class for adding a decoration to an object.
DerivationFramework::FourMuonTool::m_eventInfo_key
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfo_key
Definition: FourMuonTool.h:168
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
CHECK
#define CHECK(...)
Evaluate an expression and check for errors.
Definition: Control/AthenaKernel/AthenaKernel/errorcheck.h:422
DerivationFramework::BPhysPVTools::PrepareVertexLinks
static void PrepareVertexLinks(xAOD::Vertex *theResult, const xAOD::TrackParticleContainer *importedTrackCollection)
Definition: BPhysPVTools.cxx:530
DerivationFramework
THE reconstruction tool.
Definition: ParticleSortingAlg.h:24
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
DerivationFramework::FourMuonTool::~FourMuonTool
~FourMuonTool()
Definition: FourMuonTool.cxx:85
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
Vertex.h
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
Trk::Combined
@ Combined
Definition: TrackSummaryTool.h:32
DerivationFramework::FourMuonTool::m_trkSelector
ToolHandle< Trk::ITrackSelectorTool > m_trkSelector
Definition: FourMuonTool.h:167
DerivationFramework::FourMuonTool::m_etaCut
double m_etaCut
Definition: FourMuonTool.h:161
DerivationFramework::Combination::pairIndices
std::pair< unsigned int, unsigned int > pairIndices
Definition: FourMuonTool.h:40
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:76
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
DerivationFramework::FourMuonTool::buildCombinations
static void buildCombinations(const std::vector< const xAOD::Muon * > &muonsIn, std::vector< Combination > &pairs, std::vector< Combination > &quadruplets, unsigned int nSelectedMuons)
Definition: FourMuonTool.cxx:356
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
IVertexFitter.h
TrkV0VertexFitter.h
BPhysHelper.h
: B-physics xAOD helpers.
DerivationFramework::FourMuonTool::m_TrkParticleCollection
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_TrkParticleCollection
Definition: FourMuonTool.h:164
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
TrackParticle.h
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
a
TList * a
Definition: liststreamerinfos.cxx:10
xAOD::Vertex_v1::chiSquared
float chiSquared() const
Returns the of the vertex fit as float.
DerivationFramework::Combination::muons
std::vector< const xAOD::Muon * > muons
Definition: FourMuonTool.h:38
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
python.TrackLeptonConfig.quality
quality
Definition: TrackLeptonConfig.py:16
convertTimingResiduals.offset
offset
Definition: convertTimingResiduals.py:71
DerivationFramework::FourMuonTool::getQuadIndices
static std::vector< std::vector< unsigned int > > getQuadIndices(unsigned int length)
Definition: FourMuonTool.cxx:292
python.BuildSignatureFlags.beamSpot
AthConfigFlags beamSpot(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:475
DerivationFramework::Combination
Definition: FourMuonTool.h:37
DerivationFramework::FourMuonTool::initialize
StatusCode initialize()
Definition: FourMuonTool.cxx:32
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
AthAlgTool
Definition: AthAlgTool.h:26
ITrackSelectorTool.h
DerivationFramework::FourMuonTool::getPairIndices
static std::vector< std::pair< unsigned int, unsigned int > > getPairIndices(unsigned int length)
Definition: FourMuonTool.cxx:336
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
length
double length(const pvec &v)
Definition: FPGATrackSimLLPDoubletHoughTransformTool.cxx:26
TrackParticleContainer.h
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
VertexAuxContainer.h
fitman.k
k
Definition: fitman.py:528
python.SystemOfUnits.m
float m
Definition: SystemOfUnits.py:106
FourMuonTool.h
dumpNswErrorDb.quad
def quad
Definition: dumpNswErrorDb.py:30
Generated on Mon Sep 29 2025 21:10:27 for ATLAS Offline Software by   doxygen 1.8.18