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 "DerivationFrameworkBPhys/FourMuonTool.h"
14 #include "DerivationFrameworkBPhys/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  declareInterface<FourMuonTool>(this);
76  declareProperty("ptCut",m_ptCut);
77  declareProperty("etaCut",m_etaCut);
78  declareProperty("useV0Fitter",m_useV0Fitter);
79  declareProperty("muonCollectionKey",m_muonCollectionKey);
80  declareProperty("TrackParticleCollection",m_TrkParticleCollection);
81  declareProperty("TrkVertexFitterTool",m_iVertexFitter);
82  declareProperty("V0VertexFitterTool",m_iV0VertexFitter);
83  declareProperty("TrackSelectorTool",m_trkSelector);
84  }
85 
86  FourMuonTool::~FourMuonTool() { }
87 
88  //-------------------------------------------------------------------------------------
89  // Find the candidates
90  //-------------------------------------------------------------------------------------
91  StatusCode FourMuonTool::performSearch(xAOD::VertexContainer*& pairVxContainer, xAOD::VertexAuxContainer*& pairVxAuxContainer,
92  xAOD::VertexContainer*& quadVxContainer, xAOD::VertexAuxContainer*& quadVxAuxContainer, bool &selectEvent) const
93  {
94  ATH_MSG_DEBUG( "FourMuonTool::performSearch" );
95  selectEvent = false;
96 
97  // pairs
98  pairVxContainer = new xAOD::VertexContainer;
99  pairVxAuxContainer = new xAOD::VertexAuxContainer;
100  pairVxContainer->setStore(pairVxAuxContainer);
101  // quads
102  quadVxContainer = new xAOD::VertexContainer;
103  quadVxAuxContainer = new xAOD::VertexAuxContainer;
104  quadVxContainer->setStore(quadVxAuxContainer);
105 
106 
107  // Get the muons from StoreGate
108  SG::ReadHandle<xAOD::MuonContainer> importedMuonCollection(m_muonCollectionKey);
109  ATH_CHECK(importedMuonCollection.isValid());
110  ATH_MSG_DEBUG("Muon container size "<<importedMuonCollection->size());
111 
112  // Get ID tracks
113  SG::ReadHandle<xAOD::TrackParticleContainer> importedTrackCollection(m_TrkParticleCollection);
114  ATH_CHECK(importedTrackCollection.isValid());
115  ATH_MSG_DEBUG("ID TrackParticle container size "<< importedTrackCollection->size());
116 
117  // Select the muons
118  std::vector<const xAOD::Muon*> theMuonsAfterSelection;
119  SG::WriteDecorHandle<xAOD::MuonContainer, int> muonDecorator(m_muonIndex);
120  unsigned int nCombMuons = 0;
121  unsigned int nSegmentTaggedMuons = 0;
122 
123  for (auto muItr=importedMuonCollection->begin(); muItr!=importedMuonCollection->end(); ++muItr) {
124  if ( *muItr == NULL ) continue;
125  muonDecorator(**muItr) = -1; // all muons must be decorated
126  if ( ((*muItr)->muonType() != xAOD::Muon::Combined ) && ((*muItr)->muonType() != xAOD::Muon::SegmentTagged ) ) continue;
127  if (!(*muItr)->inDetTrackParticleLink().isValid()) continue; // No muons without ID tracks
128  auto& link = (*muItr)->inDetTrackParticleLink();
129  const xAOD::TrackParticle* muonTrk = *link;
130  if ( muonTrk==NULL) continue;
131  const xAOD::Vertex* vx = nullptr;
132  if ( !m_trkSelector->decision(*muonTrk, vx) ) continue; // all ID tracks must pass basic tracking cuts
133  if ( fabs(muonTrk->pt())<m_ptCut ) continue; // pt cut
134  if ( fabs(muonTrk->eta())>m_etaCut ) continue; // eta cut
135  if ( (*muItr)->muonType() == xAOD::Muon::Combined ) ++nCombMuons;
136  if ( (*muItr)->muonType() == xAOD::Muon::SegmentTagged ) ++nSegmentTaggedMuons;
137  theMuonsAfterSelection.push_back(*muItr);
138  }
139  unsigned int nSelectedMuons = theMuonsAfterSelection.size();
140  ATH_MSG_DEBUG("Number of muons after selection: " << nSelectedMuons);
141  ATH_MSG_DEBUG("of which " << nCombMuons << " are combined");
142  ATH_MSG_DEBUG("and " << nSegmentTaggedMuons << " are segment tagged");
143  if ( (nSelectedMuons < 4) || (nCombMuons < 1) ) {
144  ATH_MSG_DEBUG("Muon criteria not met. Skipping event.");
145  return StatusCode::SUCCESS;
146  }
147  selectEvent = true; // if we got this far we should definitively accept the event
148 
149  // Decorators
150  SG::AuxElement::Decorator< std::string > indexDecorator("CombinationCode");
151  SG::AuxElement::Decorator< std::string > chargeDecorator("ChargeCode");
152  //SG::AuxElement::Decorator< double > acdcDecorator("ACminusDC");
153  //SG::AuxElement::Decorator< double > ssdcDecorator("SSminusDC");
154 
155  // Order by pT
156  std::sort(theMuonsAfterSelection.begin(), theMuonsAfterSelection.end(), [](const xAOD::Muon *a, const xAOD::Muon *b) {
157  return b->pt() < a->pt();
158  });
159 
160  // Decorate the selected muons (now pT ordered) with their index
161  unsigned int muonIndex(0);
162  for (auto selMuon : theMuonsAfterSelection) {
163  muonDecorator(*selMuon) = muonIndex;
164  ++muonIndex;
165  }
166 
167  // Quadruplet combinatorics
168  std::vector<Combination> quadruplets;
169  std::vector<Combination> pairs;
170  buildCombinations(theMuonsAfterSelection,pairs,quadruplets,nSelectedMuons);
171  if (quadruplets.size()==0) {
172  ATH_MSG_DEBUG("No acceptable quadruplets");
173  return StatusCode::SUCCESS;
174  }
175 
176  // Get the beam spot (for the vertexing starting point)
177  SG::ReadHandle<xAOD::EventInfo> evt(m_eventInfo_key);
178  if(not evt.isValid()) ATH_MSG_ERROR("Cannot Retrieve " << evt.key() );
179  const Amg::Vector3D beamSpot(evt->beamPosX(), evt->beamPosY(), evt->beamPosZ());
180 
181  // fit pairs
182  ATH_MSG_DEBUG("Successful pairs.....");
183  for (std::vector<Combination>::iterator pairItr = pairs.begin(); pairItr!=pairs.end(); ++pairItr) {
184  std::vector<const xAOD::TrackParticle*> theTracks = (*pairItr).trackParticles("pair1");
185  xAOD::Vertex* pairVxCandidate = fit(theTracks,importedTrackCollection.get(),beamSpot); // This line actually does the fitting and object making
186  if (pairVxCandidate != 0) {
187  // decorate the candidate with its codes
188  indexDecorator(*pairVxCandidate) = (*pairItr).combinationIndices();
189  chargeDecorator(*pairVxCandidate) = (*pairItr).combinationCharges();
190  // decorate the candidate with refitted tracks and muons via the BPhysHelper
191  xAOD::BPhysHelper helper(pairVxCandidate);
192  helper.setRefTrks();
193  std::vector<const xAOD::Muon*> theStoredMuons;
194  theStoredMuons = (*pairItr).muons;
195  helper.setMuons(theStoredMuons,importedMuonCollection.get());
196  // Retain the vertex
197  pairVxContainer->push_back(pairVxCandidate);
198  ATH_MSG_DEBUG("..... indices: " << (*pairItr).combinationIndices() <<
199  " charges: " << (*pairItr).combinationCharges() <<
200  " chi2: " << pairVxCandidate->chiSquared());
201  } else { // fit failed
202  ATH_MSG_DEBUG("Fitter failed!");
203  }
204  }
205  ATH_MSG_DEBUG("pairContainer size " << pairVxContainer->size());
206 
207  // fit quadruplets
208  ATH_MSG_DEBUG("Successful quadruplets.....");
209  for (std::vector<Combination>::iterator quadItr = quadruplets.begin(); quadItr!=quadruplets.end(); ++quadItr) {
210  std::vector<const xAOD::TrackParticle*> theDCTracks; theDCTracks.clear();
211  //std::vector<const xAOD::TrackParticle*> theACTracks; theACTracks.clear();
212  //std::vector<const xAOD::TrackParticle*> theSSTracks; theSSTracks.clear();
213  theDCTracks = (*quadItr).trackParticles("DC");
214  //theACTracks = (*quadItr).trackParticles("AC");
215  //theSSTracks = (*quadItr).trackParticles("SS");
216  xAOD::Vertex* dcVxCandidate = fit(theDCTracks,importedTrackCollection.get(), beamSpot);
217  //xAOD::Vertex* acVxCandidate = fit(theACTracks,importedTrackCollection, beamSpot);
218  //xAOD::Vertex* ssVxCandidate = fit(theSSTracks,importedTrackCollection, beamSpot);
219  // Get the chi2 for each one
220  //double acChi2(0.0);
221  //double ssChi2(0.0);
222  //if (acVxCandidate != 0) {acChi2 = acVxCandidate->chiSquared();}
223  //if (ssVxCandidate != 0) {ssChi2 = ssVxCandidate->chiSquared();}
224  if (dcVxCandidate != 0) {
225  // decorate the candidate with its codes
226  indexDecorator(*dcVxCandidate) = (*quadItr).combinationIndices();
227  chargeDecorator(*dcVxCandidate) = (*quadItr).combinationCharges();
228  // Decorate the DC candidate with the differences between its chi2 and the other
229  double dcChi2 = dcVxCandidate->chiSquared();
230  //acdcDecorator(*dcVxCandidate) = acChi2 - dcChi2;
231  //ssdcDecorator(*dcVxCandidate) = ssChi2 - dcChi2;
232  // decorate the candidate with refitted tracks and muons via the BPhysHelper
233  xAOD::BPhysHelper helper(dcVxCandidate);
234  helper.setRefTrks();
235  const std::vector<const xAOD::Muon*> &theStoredMuons = (*quadItr).muons;
236  helper.setMuons(theStoredMuons,importedMuonCollection.get());
237  // Retain the vertex
238  quadVxContainer->push_back(dcVxCandidate);
239  ATH_MSG_DEBUG("..... indices: " << (*quadItr).combinationIndices() <<
240  " charges: " << (*quadItr).combinationCharges() <<
241  " chi2(DC): " << dcChi2);
242  //" chi2(AC): " << acChi2 <<
243  //" chi2(SS): " << ssChi2);
244  } else { // fit failed
245  ATH_MSG_DEBUG("Fitter failed!");
246  }
247  }
248  ATH_MSG_DEBUG("quadruplet container size " << quadVxContainer->size());
249 
250  return StatusCode::SUCCESS;;
251  }
252 
253  // *********************************************************************************
254 
255  // ---------------------------------------------------------------------------------
256  // fit - does the fit
257  // ---------------------------------------------------------------------------------
258 
259  xAOD::Vertex* FourMuonTool::fit(const std::vector<const xAOD::TrackParticle*> &inputTracks,
260  const xAOD::TrackParticleContainer* importedTrackCollection,
261  const Amg::Vector3D &beamSpot) const {
262 
263  const Trk::TrkV0VertexFitter* concreteVertexFitter=0;
264  if (m_useV0Fitter) {
265  // making a concrete fitter for the V0Fitter
266  concreteVertexFitter = dynamic_cast<const Trk::TrkV0VertexFitter * >(&(*m_iV0VertexFitter));
267  if(concreteVertexFitter == 0) {
268  ATH_MSG_FATAL("The vertex fitter passed is not a V0 Vertex Fitter");
269  return NULL;
270  }
271  }
272 
273  xAOD::Vertex* myVxCandidate = nullptr;
274  if (m_useV0Fitter) {
275  myVxCandidate = concreteVertexFitter->fit(inputTracks, beamSpot /*vertex startingPoint*/ );
276  } else {
277  myVxCandidate = m_iVertexFitter->fit(inputTracks, beamSpot /*vertex startingPoint*/ );
278  }
279 
280  if(myVxCandidate) BPhysPVTools::PrepareVertexLinks(myVxCandidate, importedTrackCollection);
281 
282  return myVxCandidate;
283 
284  } // End of fit method
285 
286 
287  // *********************************************************************************
288 
289  // ---------------------------------------------------------------------------------
290  // getQuadIndices: forms up index lists
291  // ---------------------------------------------------------------------------------
292 
293  std::vector<std::vector<unsigned int> > FourMuonTool::getQuadIndices(unsigned int length) {
294 
295  std::vector<std::vector<unsigned int> > quadIndices = mFromN(4,length);
296  return(quadIndices);
297  }
298 
299 
300  // *********************************************************************************
301 
302  // ---------------------------------------------------------------------------------
303  // mFromN and combinatorics
304  // ---------------------------------------------------------------------------------
305  std::vector<std::vector<unsigned int> > FourMuonTool::mFromN(unsigned int m, unsigned int N) {
306 
307  std::vector<std::vector<unsigned int> > allCombinations;
308  std::vector<unsigned int> mainList;
309  std::vector<unsigned int> combination;
310  for (unsigned int i=0; i<N; ++i) mainList.push_back(i);
311  combinatorics(0,m,combination,mainList,allCombinations);
312  return allCombinations;
313  }
314 
315  void FourMuonTool::combinatorics(unsigned int offset,
316  unsigned int k,
317  std::vector<unsigned int> &combination,
318  std::vector<unsigned int> &mainList,
319  std::vector<std::vector<unsigned int> > &allCombinations) {
320  if (k==0) {
321  allCombinations.push_back(combination);
322  return;
323  }
324  if (k>0) {
325  for (unsigned int i=offset; i<=mainList.size()-k; ++i) {
326  combination.push_back(mainList[i]);
327  combinatorics(i+1,k-1,combination,mainList,allCombinations);
328  combination.pop_back();
329  }
330  }
331  }
332 
333  // ---------------------------------------------------------------------------------
334  // getPairIndices
335  // ---------------------------------------------------------------------------------
336 
337  std::vector<std::pair<unsigned int, unsigned int> > FourMuonTool::getPairIndices(unsigned int length){
338 
339  std::vector<std::pair<unsigned int, unsigned int> > uniquePairs;
340  std::vector<std::vector<unsigned int> > doublets = mFromN(2,length);
341  for (std::vector<std::vector<unsigned int> >::iterator it=doublets.begin(); it!=doublets.end(); ++it) {
342  std::pair<unsigned int, unsigned int> tmpPair = std::make_pair((*it).at(0),(*it).at(1));
343  uniquePairs.push_back(tmpPair);
344  }
345 
346  return(uniquePairs);
347  }
348 
349 
350 
351  // *********************************************************************************
352 
353  // ---------------------------------------------------------------------------------
354  // buildCombinations: forms up the quadruplet of muons/tracks
355  // ---------------------------------------------------------------------------------
356 
357  void FourMuonTool::buildCombinations(const std::vector<const xAOD::Muon*> &muonsIn,
358  std::vector<Combination> &pairs,
359  std::vector<Combination> &quadruplets,
360  unsigned int nSelectedMuons) {
361 
362  std::vector<std::vector<unsigned int> > quadrupletIndices = getQuadIndices(nSelectedMuons);
363  std::vector<std::pair<unsigned int, unsigned int> > pairIndices = getPairIndices(nSelectedMuons);
364 
365  // Quadruplets
366  std::vector<std::vector<unsigned int> >::iterator quadItr;
367  for (quadItr=quadrupletIndices.begin(); quadItr!=quadrupletIndices.end(); ++quadItr) {
368  const std::vector<unsigned int> &quad = (*quadItr);
369  std::vector<const xAOD::Muon*> theMuons = {muonsIn[quad[0]],muonsIn[quad[1]],muonsIn[quad[2]],muonsIn[quad[3]]};
370  if (!passesQuadSelection(theMuons)) continue;
371  Combination tmpQuad;
372  tmpQuad.muons = std::move(theMuons);
373  tmpQuad.quadIndices = quad;
374  quadruplets.emplace_back(std::move(tmpQuad));
375  }
376  if (quadruplets.size() == 0) return;
377 
378  // pairs
379  std::vector<std::pair<unsigned int, unsigned int> >::iterator pairItr;
380  for (pairItr=pairIndices.begin(); pairItr!=pairIndices.end(); ++pairItr) {
381  std::pair<unsigned int, unsigned int> pair = (*pairItr);
382  Combination tmpPair;
383  std::vector<const xAOD::Muon*> theMuons = {muonsIn[pair.first],muonsIn[pair.second]};
384  tmpPair.muons = std::move(theMuons);
385  tmpPair.pairIndices = pair;
386  pairs.emplace_back(std::move(tmpPair));
387  }
388 
389  return;
390 
391  }
392 
393  // *********************************************************************************
394 
395  // ---------------------------------------------------------------------------------
396  // passesQuadSelection: 4-muon selection
397  // ---------------------------------------------------------------------------------
398 
399  bool FourMuonTool::passesQuadSelection(const std::vector<const xAOD::Muon*> &muons) {
400  bool accept(false);
401  bool charges(true);
402  bool quality(false);
403  //unsigned int sumCharges = abs(mu0->charge() + mu1->charge() + mu2->charge() + mu3->charge());
404  //if (sumCharges<4) charges = true;
405  if (( muons.at(0)->muonType() == xAOD::Muon::Combined ) ||
406  ( muons.at(1)->muonType() == xAOD::Muon::Combined ) ||
407  ( muons.at(2)->muonType() == xAOD::Muon::Combined ) ||
408  ( muons.at(3)->muonType() == xAOD::Muon::Combined )
409  ) quality = true;
410  if (charges && quality) accept = true;
411  return accept;
412  }
413 
414 }
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:73
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
python.SystemOfUnits.m
int m
Definition: SystemOfUnits.py:91
DerivationFramework::FourMuonTool::m_ptCut
double m_ptCut
Definition: FourMuonTool.h:164
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:167
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
xAOD::TrackParticle_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition: TrackParticle_v1.cxx:77
DerivationFramework::FourMuonTool::m_useV0Fitter
bool m_useV0Fitter
Definition: FourMuonTool.h:166
DerivationFramework::FourMuonTool::m_iV0VertexFitter
ToolHandle< Trk::IVertexFitter > m_iV0VertexFitter
Definition: FourMuonTool.h:170
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:315
DerivationFramework::FourMuonTool::passesQuadSelection
static bool passesQuadSelection(const std::vector< const xAOD::Muon * > &muonsIn)
Definition: FourMuonTool.cxx:399
skel.it
it
Definition: skel.GENtoEVGEN.py:396
DerivationFramework::FourMuonTool::mFromN
static std::vector< std::vector< unsigned int > > mFromN(unsigned int m, unsigned int n)
Definition: FourMuonTool.cxx:305
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
DerivationFramework::FourMuonTool::fit
xAOD::Vertex * fit(const std::vector< const xAOD::TrackParticle * > &, const xAOD::TrackParticleContainer *importedTrackCollection, const Amg::Vector3D &beamSpot) const
Definition: FourMuonTool.cxx:259
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:112
DerivationFramework::FourMuonTool::m_iVertexFitter
ToolHandle< Trk::IVertexFitter > m_iVertexFitter
Definition: FourMuonTool.h:169
DerivationFramework::FourMuonTool::m_muonIndex
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_muonIndex
Definition: FourMuonTool.h:173
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
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:183
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:731
DerivationFramework::FourMuonTool::performSearch
StatusCode performSearch(xAOD::VertexContainer *&pairVxContainer, xAOD::VertexAuxContainer *&pairVxAuxContainer, xAOD::VertexContainer *&quadVxContainer, xAOD::VertexAuxContainer *&quadVxAuxContainer, bool &acceptEvent) const
Definition: FourMuonTool.cxx:91
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
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:41
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:172
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:86
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:171
DerivationFramework::FourMuonTool::m_etaCut
double m_etaCut
Definition: FourMuonTool.h:165
DerivationFramework::Combination::pairIndices
std::pair< unsigned int, unsigned int > pairIndices
Definition: FourMuonTool.h:42
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:77
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:357
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:168
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:40
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
convertTimingResiduals.offset
offset
Definition: convertTimingResiduals.py:71
DerivationFramework::FourMuonTool::getQuadIndices
static std::vector< std::vector< unsigned int > > getQuadIndices(unsigned int length)
Definition: FourMuonTool.cxx:293
python.BuildSignatureFlags.beamSpot
AthConfigFlags beamSpot(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:454
DerivationFramework::Combination
Definition: FourMuonTool.h:39
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:337
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
FourMuonTool.h
dumpNswErrorDb.quad
def quad
Definition: dumpNswErrorDb.py:24
Generated on Sun Dec 22 2024 21:10:35 for ATLAS Offline Software by   doxygen 1.8.18