ATLAS Offline Software
MuonInsideOutRecoTool.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
4 
6 
12 #include "xAODTracking/Vertex.h"
13 
14 using namespace Muon::MuonStationIndex;
15 namespace MuonCombined {
16 
17  MuonInsideOutRecoTool::MuonInsideOutRecoTool(const std::string& type, const std::string& name, const IInterface* parent) :
19  declareInterface<IMuonCombinedInDetExtensionTool>(this);
20  declareInterface<MuonInsideOutRecoTool>(this);
21  }
22 
24  ATH_CHECK(m_idHelperSvc.retrieve());
25  ATH_CHECK(m_edmHelperSvc.retrieve());
26  ATH_CHECK(m_printer.retrieve());
27  ATH_CHECK(m_segmentFinder.retrieve(DisableTool(m_segmentFinder.empty())));
28  ATH_CHECK(m_segmentMatchingTool.retrieve());
29  ATH_CHECK(m_ambiguityResolver.retrieve());
31  ATH_CHECK(m_trackFitter.retrieve());
33  // trigger does not use primary vertex
34  ATH_CHECK(m_vertexKey.initialize(!m_vertexKey.empty()));
35  ATH_CHECK(m_trackSummaryTool.retrieve());
36  ATH_CHECK(m_recoValidationTool.retrieve(DisableTool{m_recoValidationTool.empty()}));
37  ATH_CHECK(m_inputSegments.initialize(!m_inputSegments.empty()));
38  return StatusCode::SUCCESS;
39  }
40 
42  TrackCollection* combTracks, TrackCollection* meTracks, Trk::SegmentCollection* segments,
43  const EventContext& ctx) const {
44  ATH_MSG_WARNING("This version is deprecated, please use extendWithPRDs for MuGirl");
46  extendWithPRDs(inDetCandidates, tagMap, prdData, combTracks, meTracks, segments, ctx);
47  }
48 
51  TrackCollection* meTracks, Trk::SegmentCollection* segments, const EventContext& ctx) const {
52  ATH_MSG_DEBUG(" extending " << inDetCandidates.size());
53  // vector to store segments
54  std::vector<std::shared_ptr<const Muon::MuonSegment>> msegments;
55 
56  if(!m_inputSegments.empty()){
58  const Trk::SegmentCollection *segInColl = rh_segments.ptr();
59  for(auto trkSeg : *segInColl){
60  auto muonSeg = dynamic_cast<const Muon::MuonSegment*>(trkSeg);
61  std::shared_ptr<const Muon::MuonSegment> mseg2 = std::make_shared<const Muon::MuonSegment>(*muonSeg);
62  msegments.push_back(mseg2);
63  }
64  }
65 
66 
67  for (const InDetCandidate* it : inDetCandidates) { handleCandidate(*it, tagMap, prdData, combTracks, meTracks, segments, msegments, ctx); }
68  }
69 
72  TrackCollection* meTracks, Trk::SegmentCollection* segColl, std::vector<std::shared_ptr<const Muon::MuonSegment>> segments, const EventContext& ctx) const {
73  if (m_ignoreSiAssocated && indetCandidate.isSiliconAssociated()) {
74  ATH_MSG_DEBUG(" skip silicon associated track for extension ");
75  return;
76  }
77 
78  const xAOD::TrackParticle& indetTrackParticle = indetCandidate.indetTrackParticle();
79  if (!indetTrackParticle.track() || indetTrackParticle.pt() < m_idTrackMinPt) return;
80 
81  // get intersections which precision layers in the muon system
82  const Muon::MuonSystemExtension* muonSystemExtension = indetCandidate.getExtension();
83  if (!muonSystemExtension) {
84  ATH_MSG_VERBOSE("No MuonSystemExtension, aborting ");
85  return;
86  }
87  // fill validation content
88  if (!m_recoValidationTool.empty()) m_recoValidationTool->addTrackParticle(indetTrackParticle, *muonSystemExtension);
89 
90  // loop over intersections, get segments
91  std::vector<Muon::MuonLayerRecoData> allLayers;
92 
93  const std::vector<Muon::MuonSystemExtension::Intersection>& layerIntersections = muonSystemExtension->layerIntersections();
94  ATH_MSG_DEBUG(" ID track: pt " << indetTrackParticle.pt() << " eta " << indetTrackParticle.eta() << " phi "
95  << indetTrackParticle.phi() << " layers " << layerIntersections.size());
96 
97 
98 
99 
100  for (const Muon::MuonSystemExtension::Intersection& layer_intersect : layerIntersections) {
101 
102  // find segments for intersection
103  Muon::MuonLayerPrepRawData layerPrepRawData;
104  if (!getLayerData(layer_intersect.layerSurface, layerPrepRawData, prdData)) {
105  ATH_MSG_VERBOSE("Failed to get layer data");
106  continue;
107  }
108 
109  if(!m_segmentFinder.empty()){
110  segments.clear();
111  m_segmentFinder->find(ctx, layer_intersect, layerPrepRawData, segments);
112  }
113  if (segments.empty()) continue;
114 
115  // fill validation content
116  if (!m_recoValidationTool.empty()) {
117  for (const std::shared_ptr<const Muon::MuonSegment>& seg : segments) m_recoValidationTool->add(layer_intersect, *seg, 0);
118  }
119 
120  // match segments to intersection
121  std::vector<std::shared_ptr<const Muon::MuonSegment>> selectedSegments;
122  m_segmentMatchingTool->select(ctx, layer_intersect, segments, selectedSegments);
123  if (selectedSegments.empty()) continue;
124 
125  // fill validation content
126  if (!m_recoValidationTool.empty()) {
127  for (const auto& seg : selectedSegments) m_recoValidationTool->add(layer_intersect, *seg, 1);
128  }
129 
130  // add to total list
131  allLayers.emplace_back(layer_intersect, std::move(selectedSegments));
132  }
133 
134  if (msgLvl(MSG::DEBUG)) {
135  msg(MSG::DEBUG) << " Layers with segments " << allLayers.size();
136  for (auto& layer : allLayers) {
137  for (auto& seg : layer.segments) { msg(MSG::DEBUG) << std::endl << m_printer->print(*seg); }
138  }
139  msg(MSG::DEBUG) << endmsg;
140  }
141 
142  // find best candidate and exit if none found
143  std::pair<std::unique_ptr<const Muon::MuonCandidate>, std::unique_ptr<Trk::Track>> bestCandidate =
144  findBestCandidate(ctx, indetTrackParticle, allLayers);
145  if (!bestCandidate.first) { return; }
146 
147  // add candidate to indet candidate
148  addTag(ctx, indetCandidate, tagMap, *bestCandidate.first, bestCandidate.second, combTracks, meTracks, segColl);
149  }
150 
151  std::pair<std::unique_ptr<const Muon::MuonCandidate>, std::unique_ptr<Trk::Track>> MuonInsideOutRecoTool::findBestCandidate(
152  const EventContext& ctx, const xAOD::TrackParticle& indetTrackParticle,
153  const std::vector<Muon::MuonLayerRecoData>& allLayers) const {
154  // resolve ambiguities
155  std::vector<Muon::MuonCandidate> resolvedCandidates;
156  m_ambiguityResolver->resolveOverlaps(ctx, allLayers, resolvedCandidates);
157 
158  // fit candidates
160  typedef std::pair<std::unique_ptr<Trk::Track>, std::unique_ptr<const Muon::MuonCandidate>> candidatePair;
161  std::vector<candidatePair> trackCandidateLookup;
162  for (Muon::MuonCandidate& candidate : resolvedCandidates) {
163  std::unique_ptr<Trk::Track> track = m_candidateTrackBuilder->buildCombinedTrack(ctx, *indetTrackParticle.track(), candidate);
165  if (!track || !track->isValid() || !track->fitQuality()->numberDoF()) continue;
166 
167  tracks.push_back(track.get());
168  trackCandidateLookup.emplace_back(std::move(track), std::make_unique<Muon::MuonCandidate>(std::move(candidate)));
169  }
170 
171  ATH_MSG_DEBUG("found " << tracks.size() << " combined tracks");
172 
173  // first handle easy cases of zero or one track
174  if (tracks.empty()) return {nullptr, nullptr};
175 
176  Trk::Track* selectedTrack = nullptr;
177  if (tracks.size() == 1) {
178  selectedTrack = tracks.front();
179  } else {
180  // more than 1 track call ambiguity solver and select first track
181  std::unique_ptr<const TrackCollection> resolvedTracks(m_trackAmbiguityResolver->process(&tracks));
182  if (!resolvedTracks || resolvedTracks->empty()) {
183  ATH_MSG_WARNING("Ambiguity resolver returned no tracks. Arbitrarily using the first track of initial collection.");
184  selectedTrack = tracks.front();
185  } else {
186  TrackCollection::iterator it = std::find(tracks.begin(), tracks.end(), resolvedTracks->front());
187  if (it != tracks.end()) {
188  selectedTrack = *it;
189  } else {
190  ATH_MSG_ERROR("Ambiguity resolver returned an unknown track. Arbitrarily using the first track of initial collection.");
191  selectedTrack = tracks.front();
192  }
193  }
194  }
195  // get candidate
197  std::find_if(trackCandidateLookup.begin(), trackCandidateLookup.end(),
198  [selectedTrack](candidatePair& ele) { return ele.first.get() == selectedTrack; });
199 
200  if (look_itr == trackCandidateLookup.end() || !look_itr->second) {
201  ATH_MSG_WARNING("candidate lookup failed, this should not happen");
202  return {nullptr, nullptr};
203  }
204  // generate a track summary for this candidate
205  if (m_trackSummaryTool.isEnabled()) { m_trackSummaryTool->computeAndReplaceTrackSummary(*selectedTrack, false); }
206 
207  return std::make_pair(std::move(look_itr->second), std::move(look_itr->first));
208  }
209 
210  void MuonInsideOutRecoTool::addTag(const EventContext& ctx, const InDetCandidate& indetCandidate, InDetCandidateToTagMap* tagMap,
211  const Muon::MuonCandidate& candidate, std::unique_ptr<Trk::Track>& selectedTrack,
212  TrackCollection* combTracks, TrackCollection* meTracks, Trk::SegmentCollection* segments) const {
213  const xAOD::TrackParticle& idTrackParticle = indetCandidate.indetTrackParticle();
214  Amg::Vector3D origin{0., 0., 0.};
215 
216  const xAOD::Vertex* matchedVertex = nullptr;
217  if (!m_vertexKey.empty()) {
219  if (!vertices.isValid()) {
220  ATH_MSG_WARNING("No vertex container with key = " << m_vertexKey.key() << " found");
221  } else {
222  for (const auto* const vx : *vertices) {
223  for (const auto& tpLink : vx->trackParticleLinks()) {
224  if (*tpLink == &idTrackParticle) {
225  matchedVertex = vx;
226  break;
227  }
228  if (matchedVertex) break;
229  }
230  }
231  }
232  }
233  if (matchedVertex) {
234  origin = Amg::Vector3D{matchedVertex->x(), matchedVertex->y(), matchedVertex->z()};
235  ATH_MSG_DEBUG(" found matched vertex " << origin);
236  } else {
237  origin = Amg::Vector3D{-idTrackParticle.d0() * std::sin(idTrackParticle.phi()) + idTrackParticle.vx(),
238  idTrackParticle.d0() * std::cos(idTrackParticle.phi()) + idTrackParticle.vy(),
239  idTrackParticle.z0() + idTrackParticle.vz()};
240  ATH_MSG_DEBUG(" NO matched vertex take track perigee " << origin);
241  }
242 
243  ATH_MSG_VERBOSE("selectedTrack:");
244  if (msgLevel(MSG::VERBOSE)) {
245  int tsos = 0;
246  for (const Trk::TrackStateOnSurface* it : *selectedTrack->trackStateOnSurfaces()) {
247  ++tsos;
248  if (it->trackParameters()) {
249  ATH_MSG_VERBOSE("check tsos " << tsos << " r " << it->trackParameters()->position().perp() << " z "
250  << it->trackParameters()->position().z() << " p "
251  << it->trackParameters()->momentum().mag());
252  }
253  }
254  }
255 
256  std::vector<const Muon::MuonSegment*> segLinks;
257  for (const Muon::MuonLayerIntersection& layer : candidate.layerIntersections) {
258  std::unique_ptr<Muon::MuonSegment> copy = std::make_unique<Muon::MuonSegment>(*layer.segment);
259  segLinks.push_back(copy.get());
260  segments->push_back(std::move(copy));
261  }
263  //cppcheck-suppress invalidLifetime
264  std::sort(segLinks.begin(), segLinks.end(), [this](const Muon::MuonSegment* seg_a, const Muon::MuonSegment* seg_b) -> bool {
265  ChIndex ch_a = m_idHelperSvc->chamberIndex(m_edmHelperSvc->chamberId(*seg_a));
266  ChIndex ch_b = m_idHelperSvc->chamberIndex(m_edmHelperSvc->chamberId(*seg_b));
267  StIndex st_a = toStationIndex(ch_a);
268  StIndex st_b = toStationIndex(ch_b);
269  if (st_a != st_b) return st_a < st_b;
271  if (ch_a == ChIndex::CSL || ch_a == ChIndex::CSS || ch_b == ChIndex::CSS || ch_b == ChIndex::CSL)
272  return (ch_a == ChIndex::CSL) + 2 * (ch_a == ChIndex::CSS) > (ch_b == ChIndex::CSL) + 2 * (ch_b == ChIndex::CSS);
273  return ch_a < ch_b;
274  });
275 
276  if (msgLevel(MSG::DEBUG)) {
277  std::stringstream sstr;
278  for (const Muon::MuonSegment* muo_seg : segLinks) {
279  auto chIdx = m_idHelperSvc->chamberIndex(m_edmHelperSvc->chamberId(*muo_seg));
280  auto thIdx = m_idHelperSvc->technologyIndex(m_edmHelperSvc->chamberId(*muo_seg));
281  sstr << chName(chIdx) << " (" << technologyName(thIdx) << "), ";
282  }
283  ATH_MSG_DEBUG("Selected segments " << segLinks.size() << " " << sstr.str());
284  }
285 
286  // perform standalone refit
287  std::unique_ptr<Trk::Track> standaloneRefit{m_trackFitter->standaloneRefit(ctx, *selectedTrack, origin)};
288 
289  combTracks->push_back(std::move(selectedTrack));
290  ElementLink<TrackCollection> comblink(*combTracks, combTracks->size() - 1);
291 
292  // create tag and set SA refit
293  MuGirlTag* tag = new MuGirlTag(comblink, segLinks);
294  if (standaloneRefit) {
295  meTracks->push_back(std::move(standaloneRefit));
296  ElementLink<TrackCollection> melink(*meTracks, meTracks->size() - 1);
297  tag->setUpdatedExtrapolatedTrack(melink);
298  }
299 
300  // add tag to IndetCandidateToTagMap
301  tagMap->addEntry(&indetCandidate, tag);
302  }
303 
306  // get technologies in the given layer
307  StIndex stIndex = toStationIndex(surf.regionIndex, surf.layerIndex);
308  const std::set<TechnologyIndex>& technologiesInStation = m_idHelperSvc->technologiesInStation(stIndex);
309  if (msgLevel(MSG::DEBUG)) {
310  std::string techString;
311  for (const TechnologyIndex& tech : technologiesInStation)
312  techString += " " + technologyName(tech);
313  ATH_MSG_DEBUG("getLayerData: sector " << surf.sector << " " << regionName(surf.regionIndex) << " "
314  << layerName(surf.layerIndex) << " technologies " << techString);
315  }
316 
317  bool isok{false};
318  // loop over technologies and get data
319  for (const TechnologyIndex& it : technologiesInStation) {
320  // get collections, keep track of failures
321  switch(it) {
322  using enum TechnologyIndex;
323  case TechnologyIndexMax:
324  case TechnologyUnknown:
325  break;
326  case MDT:
327  isok |= getLayerDataTech<Muon::MdtPrepData>(it, surf, prdData.mdtPrds, layerPrepRawData.mdts);
328  break;
329  case RPC:
330  isok |= getLayerDataTech<Muon::RpcPrepData>(it, surf, prdData.rpcPrds, layerPrepRawData.rpcs);
331  break;
332  case TGC:
333  isok |= getLayerDataTech<Muon::TgcPrepData>(it, surf, prdData.tgcPrds, layerPrepRawData.tgcs);
334  break;
335  case CSC:
336  isok |= getLayerDataTech<Muon::CscPrepData>(it, surf, prdData.cscPrds, layerPrepRawData.cscs);
337  break;
338  case STGC:
339  isok |= getLayerDataTech<Muon::sTgcPrepData>(it, surf, prdData.stgcPrds, layerPrepRawData.stgcs);
340  break;
341  case MM:
342  isok |= getLayerDataTech<Muon::MMPrepData>(it, surf, prdData.mmPrds, layerPrepRawData.mms);
343  break;
344  }
345  }
346 
347  if (msgLvl(MSG::DEBUG)) {
348  msg(MSG::DEBUG) << " Got data: sector " << surf.sector << " " << regionName(surf.regionIndex) << " "
349  << layerName(surf.layerIndex);
350  if (!layerPrepRawData.mdts.empty()) msg(MSG::DEBUG) << " MDTs " << layerPrepRawData.mdts.size();
351  if (!layerPrepRawData.rpcs.empty()) msg(MSG::DEBUG) << " RPCs " << layerPrepRawData.rpcs.size();
352  if (!layerPrepRawData.tgcs.empty()) msg(MSG::DEBUG) << " TGCs " << layerPrepRawData.tgcs.size();
353  if (!layerPrepRawData.cscs.empty()) msg(MSG::DEBUG) << " CSCs " << layerPrepRawData.cscs.size();
354  if (!layerPrepRawData.stgcs.empty()) msg(MSG::DEBUG) << " STGCs " << layerPrepRawData.stgcs.size();
355  if (!layerPrepRawData.mms.empty()) msg(MSG::DEBUG) << " MMs " << layerPrepRawData.mms.size();
356  msg(MSG::DEBUG) << endmsg;
357  }
358  return isok;
359  }
360 
361  template <class COL>
363  const Muon::MuonPrepDataContainerT<COL>* input,
364  std::vector<const Muon::MuonPrepDataCollection<COL>*>& output) const {
365  if (!input || input->size() == 0) return false;
366  // get technologies in the given layer
367  unsigned int layHash = sectorLayerHash(surf.regionIndex, surf.layerIndex);
368 
369  // get hashes
370  const Muon::MuonLayerHashProviderTool::HashVec hashes = m_layerHashProvider->getHashes(surf.sector, technology, layHash);
371 
372  // skip empty inputs
373  if (hashes.empty()) return false;
374 
375  // loop over hashes
376  for (Muon::MuonLayerHashProviderTool::HashVec::const_iterator it = hashes.begin(); it != hashes.end(); ++it) {
377  // skip if not found
378  const auto* colIt = input->indexFindPtr(*it);
379  if (!colIt) { continue; }
380  ATH_MSG_VERBOSE(" adding " << m_idHelperSvc->toStringChamber(colIt->identify()) << " size " << colIt->size());
381  // else add
382  output.push_back(colIt);
383  }
384  return output.size();
385  }
386 } // namespace MuonCombined
python.root_lsr_rank.hashes
hashes
Definition: root_lsr_rank.py:34
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
Muon::MuonCandidate
Definition: MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonLayerEvent/MuonLayerEvent/MuonCandidate.h:14
xAOD::TrackParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: TrackParticle_v1.cxx:74
MuonCombined::MuonInsideOutRecoTool::m_ignoreSiAssocated
Gaudi::Property< bool > m_ignoreSiAssocated
Definition: MuonInsideOutRecoTool.h:112
xAOD::Vertex_v1::x
float x() const
Returns the x position.
Muon::MuonPrepDataContainer
Template for Muon PRD containers (which are basically collections of MuonPrepDataCollections).
Definition: MuonPrepDataContainer.h:42
STGC
@ STGC
Definition: RegSelEnums.h:39
MuonCombined::InDetCandidate::getExtension
const Muon::MuonSystemExtension * getExtension() const
Definition: InDetCandidate.cxx:46
Muon::MuonLayerHashProviderTool::HashVec
std::vector< IdentifierHash > HashVec
define data structure
Definition: MuonLayerHashProviderTool.h:29
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
Trk::Track
The ATLAS Track class.
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/Track.h:73
xAOD::TrackParticle_v1::vx
float vx() const
The x origin for the parameters.
Muon::MuonStationIndex
Definition: MuonStationIndex.h:13
SG::VIEW_ELEMENTS
@ VIEW_ELEMENTS
this data object is a view, it does not own its elmts
Definition: OwnershipPolicy.h:18
MuonCombined::InDetCandidateToTagMap
Definition: InDetCandidateToTagMap.h:15
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
Trk::Track::trackStateOnSurfaces
const Trk::TrackStates * trackStateOnSurfaces() const
return a pointer to a const DataVector of const TrackStateOnSurfaces.
xAOD::TrackParticle_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition: TrackParticle_v1.cxx:78
Muon::MuonLayerSurface::regionIndex
DetRegIdx regionIndex
Definition: MuonLayerSurface.h:30
Muon::MuonStationIndex::sectorLayerHash
unsigned int sectorLayerHash(DetectorRegionIndex detectorRegionIndex, LayerIndex layerIndex)
create a hash out of region and layer
MuonCombined::MuonInsideOutRecoTool::m_ambiguityResolver
ToolHandle< Muon::IMuonLayerAmbiguitySolverTool > m_ambiguityResolver
Definition: MuonInsideOutRecoTool.h:98
xAOD::TrackParticle_v1::vz
float vz() const
The z origin for the parameters.
Muon::MuonStationIndex::TechnologyIndex
TechnologyIndex
enum to classify the different layers in the muon spectrometer
Definition: MuonStationIndex.h:54
skel.it
it
Definition: skel.GENtoEVGEN.py:407
xAOD::TrackParticle_v1::z0
float z0() const
Returns the parameter.
MM
@ MM
Definition: RegSelEnums.h:38
AthCommonMsg< AlgTool >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
MuonCombined::InDetCandidate
Definition: InDetCandidate.h:18
MuonCombined::MuonInsideOutRecoTool::handleCandidate
void handleCandidate(const InDetCandidate &inDetCandidate, InDetCandidateToTagMap *tagMap, const IMuonCombinedInDetExtensionTool::MuonPrdData &prdData, TrackCollection *combTracks, TrackCollection *meTracks, Trk::SegmentCollection *segColl, std::vector< std::shared_ptr< const Muon::MuonSegment >> segments, const EventContext &ctx) const
handle a single candidate
Definition: MuonInsideOutRecoTool.cxx:70
Muon::MuonLayerPrepRawData::tgcs
std::vector< const TgcPrepDataCollection * > tgcs
Definition: MuonLayerPrepRawData.h:25
Muon::MuonLayerPrepRawData
Struct to hold all PrepRawData collections in a given layer.
Definition: MuonLayerPrepRawData.h:22
MuonCombined::MuonInsideOutRecoTool::extendWithPRDs
virtual void extendWithPRDs(const InDetCandidateCollection &inDetCandidates, InDetCandidateToTagMap *tagMap, IMuonCombinedInDetExtensionTool::MuonPrdData prdData, TrackCollection *combTracks, TrackCollection *meTracks, Trk::SegmentCollection *segments, const EventContext &ctx) const override
IMuonCombinedInDetExtensionTool interface: extend ID candidate with PRDs for segment-finding.
Definition: MuonInsideOutRecoTool.cxx:49
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
MuonCombined::MuonInsideOutRecoTool::m_segmentMatchingTool
ToolHandle< Muon::IMuonLayerSegmentMatchingTool > m_segmentMatchingTool
Definition: MuonInsideOutRecoTool.h:96
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
Muon::MuonStationIndex::TechnologyIndex::TechnologyIndexMax
@ TechnologyIndexMax
xAOD::TrackParticle_v1::d0
float d0() const
Returns the parameter.
Muon::MuonLayerPrepRawData::stgcs
std::vector< const sTgcPrepDataCollection * > stgcs
Definition: MuonLayerPrepRawData.h:27
MuonCombined::MuonInsideOutRecoTool::m_segmentFinder
ToolHandle< Muon::IMuonLayerSegmentFinderTool > m_segmentFinder
Definition: MuonInsideOutRecoTool.h:94
Muon::MuonStationIndex::toStationIndex
StIndex toStationIndex(ChIndex index)
convert ChIndex into StIndex
MuonCombined::InDetCandidateToTagMap::addEntry
void addEntry(const InDetCandidate *idcand, TagBase *tag)
Definition: InDetCandidateToTagMap.cxx:8
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
MuonCombined::IMuonCombinedInDetExtensionTool::MuonPrdData::cscPrds
const Muon::CscPrepDataContainer * cscPrds
Definition: IMuonCombinedInDetExtensionTool.h:32
DataModel_detail::iterator
(Non-const) Iterator class for DataVector/DataList.
Definition: DVLIterator.h:184
TrackCollection
DataVector< Trk::Track > TrackCollection
This typedef represents a collection of Trk::Track objects.
Definition: TrackCollection.h:19
MuonCombined::MuonInsideOutRecoTool::m_recoValidationTool
ToolHandle< Muon::IMuonRecoValidationTool > m_recoValidationTool
Definition: MuonInsideOutRecoTool.h:109
MuonCombined::MuonInsideOutRecoTool::m_trackFitter
ToolHandle< Rec::ICombinedMuonTrackBuilder > m_trackFitter
Definition: MuonInsideOutRecoTool.h:102
TGC
Definition: TgcBase.h:6
Muon::MuonLayerPrepRawData::mdts
std::vector< const MdtPrepDataCollection * > mdts
Definition: MuonLayerPrepRawData.h:23
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
Muon::MuonStationIndex::chName
const std::string & chName(ChIndex index)
convert ChIndex into a string
Definition: MuonStationIndex.cxx:119
MuonCombined::MuonInsideOutRecoTool::getLayerData
bool getLayerData(const Muon::MuonLayerSurface &surf, Muon::MuonLayerPrepRawData &layerPrepRawData, IMuonCombinedInDetExtensionTool::MuonPrdData prdData) const
access data in layer
Definition: MuonInsideOutRecoTool.cxx:304
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
Muon::MuonLayerSurface
types
Definition: MuonLayerSurface.h:15
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
MuonCombined::MuonInsideOutRecoTool::findBestCandidate
std::pair< std::unique_ptr< const Muon::MuonCandidate >, std::unique_ptr< Trk::Track > > findBestCandidate(const EventContext &ctx, const xAOD::TrackParticle &indetTrackParticle, const std::vector< Muon::MuonLayerRecoData > &allLayers) const
find the best candidate for a given set of segments
Definition: MuonInsideOutRecoTool.cxx:151
MuonCombined::MuonInsideOutRecoTool::m_idTrackMinPt
Gaudi::Property< double > m_idTrackMinPt
Definition: MuonInsideOutRecoTool.h:111
Muon::MuonSystemExtension
Tracking class to hold the extrapolation from a particle from the calo entry to the end of muon syste...
Definition: MuonSystemExtension.h:18
test_pyathena.parent
parent
Definition: test_pyathena.py:15
MuonCombined::MuonInsideOutRecoTool::m_edmHelperSvc
ServiceHandle< Muon::IMuonEDMHelperSvc > m_edmHelperSvc
Definition: MuonInsideOutRecoTool.h:91
MuonCombined::MuonInsideOutRecoTool::m_vertexKey
SG::ReadHandleKey< xAOD::VertexContainer > m_vertexKey
Definition: MuonInsideOutRecoTool.h:115
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
xAOD::Vertex_v1::z
float z() const
Returns the z position.
MuonCombined::MuonInsideOutRecoTool::addTag
void addTag(const EventContext &ctx, const InDetCandidate &indetCandidate, InDetCandidateToTagMap *tagMap, const Muon::MuonCandidate &candidate, std::unique_ptr< Trk::Track > &selectedTrack, TrackCollection *combTracks, TrackCollection *meTracks, Trk::SegmentCollection *segments) const
add muon candidate to indet candidate
Definition: MuonInsideOutRecoTool.cxx:210
MuonCombined::MuonInsideOutRecoTool::m_printer
PublicToolHandle< Muon::MuonEDMPrinterTool > m_printer
Definition: MuonInsideOutRecoTool.h:93
Muon::MuonStationIndex::technologyName
const std::string & technologyName(TechnologyIndex index)
convert LayerIndex into a string
Definition: MuonStationIndex.cxx:169
Muon::MuonPrepDataCollection
Template to hold collections of MuonPrepRawData objects.
Definition: MuonPrepDataCollection.h:46
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
Vertex.h
python.compareTCTs.isok
isok
Definition: compareTCTs.py:349
Muon::MuonStationIndex::StIndex
StIndex
enum to classify the different station layers in the muon spectrometer
Definition: MuonStationIndex.h:23
MuonSystemExtension.h
xAOD::TrackParticle_v1::vy
float vy() const
The y origin for the parameters.
RPC
@ RPC
Definition: RegSelEnums.h:32
Trk::TrackStateOnSurface
represents the track state (measurement, material, fit parameters and quality) at a surface.
Definition: TrackStateOnSurface.h:71
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
Muon::MuonStationIndex::layerName
const std::string & layerName(LayerIndex index)
convert LayerIndex into a string
Definition: MuonStationIndex.cxx:153
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
MuonCombined::MuonInsideOutRecoTool::getLayerDataTech
bool getLayerDataTech(Muon::MuonStationIndex::TechnologyIndex technology, const Muon::MuonLayerSurface &surf, const Muon::MuonPrepDataContainerT< COL > *input, std::vector< const Muon::MuonPrepDataCollection< COL > * > &output) const
access data in layer for a given technology
Definition: MuonInsideOutRecoTool.cxx:362
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
Muon::MuonStationIndex::regionName
const std::string & regionName(DetectorRegionIndex index)
convert DetectorRegionIndex into a string
Definition: MuonStationIndex.cxx:138
Muon::MuonLayerSurface::sector
int sector
Definition: MuonLayerSurface.h:29
Muon::MuonLayerPrepRawData::cscs
std::vector< const CscPrepDataCollection * > cscs
Definition: MuonLayerPrepRawData.h:26
MuonCombined::MuonInsideOutRecoTool::m_candidateTrackBuilder
ToolHandle< Muon::IMuonCandidateTrackBuilderTool > m_candidateTrackBuilder
Definition: MuonInsideOutRecoTool.h:100
SG::ReadHandle::ptr
const_pointer_type ptr()
Dereference the pointer.
MuonCombined::MuGirlTag
TagBase implementation for a combined fit.
Definition: MuGirlTag.h:23
MuonCombined::MuonInsideOutRecoTool::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition: MuonInsideOutRecoTool.h:90
MuonCombined::InDetCandidate::indetTrackParticle
const xAOD::TrackParticle & indetTrackParticle() const
access TrackParticle
Definition: InDetCandidate.cxx:27
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
MuonCombined::InDetCandidate::isSiliconAssociated
bool isSiliconAssociated() const
Returns true if this candidate was formed from a special far forward InDet track.
Definition: InDetCandidate.cxx:35
MuonCombined::MuonInsideOutRecoTool::m_layerHashProvider
ToolHandle< Muon::MuonLayerHashProviderTool > m_layerHashProvider
Definition: MuonInsideOutRecoTool.h:106
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
MuonCombined::MuonInsideOutRecoTool::initialize
virtual StatusCode initialize() override
Definition: MuonInsideOutRecoTool.cxx:23
MuonCombined
The MuonTagToSegMap is an auxillary construct that links the MuonSegments associated with a combined ...
Definition: IMuonSystemExtensionTool.h:23
Muon::MuonLayerPrepRawData::rpcs
std::vector< const RpcPrepDataCollection * > rpcs
Definition: MuonLayerPrepRawData.h:24
MuonCandidate.h
DEBUG
#define DEBUG
Definition: page_access.h:11
xAOD::Vertex_v1::y
float y() const
Returns the y position.
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
MuonCombined::MuonInsideOutRecoTool::m_trackAmbiguityResolver
ToolHandle< Trk::ITrackAmbiguityProcessorTool > m_trackAmbiguityResolver
Definition: MuonInsideOutRecoTool.h:104
MuonCombined::MuonInsideOutRecoTool::m_trackSummaryTool
ToolHandle< Trk::IExtendedTrackSummaryTool > m_trackSummaryTool
Definition: MuonInsideOutRecoTool.h:108
Muon::MuonStationIndex::TechnologyIndex::TechnologyUnknown
@ TechnologyUnknown
Muon::MuonSystemExtension::layerIntersections
const std::vector< Intersection > & layerIntersections() const
access to the intersections with the layers.
Definition: MuonSystemExtension.h:62
Muon::MuonLayerPrepRawData::mms
std::vector< const MMPrepDataCollection * > mms
Definition: MuonLayerPrepRawData.h:28
MuonSegment.h
Muon::MuonSystemExtension::Intersection
data per intersection
Definition: MuonSystemExtension.h:21
MuonLayerPrepRawData.h
MuonCombined::IMuonCombinedInDetExtensionTool::MuonPrdData::rpcPrds
const Muon::RpcPrepDataContainer * rpcPrds
Definition: IMuonCombinedInDetExtensionTool.h:30
CSC
@ CSC
Definition: RegSelEnums.h:34
xAOD::track
@ track
Definition: TrackingPrimitives.h:513
calibdata.copy
bool copy
Definition: calibdata.py:26
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
MuGirlTag.h
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:13
xAOD::TrackParticle_v1::track
const Trk::Track * track() const
Returns a pointer (which can be NULL) to the Trk::Track which was used to make this TrackParticle.
Definition: TrackParticle_v1.cxx:806
MuonCombined::IMuonCombinedInDetExtensionTool::MuonPrdData
Definition: IMuonCombinedInDetExtensionTool.h:27
CaloCondBlobAlgs_fillNoiseFromASCII.tag
string tag
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:23
Muon::MuonSegment
Definition: MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonSegment/MuonSegment/MuonSegment.h:45
MuonCombined::IMuonCombinedInDetExtensionTool::MuonPrdData::tgcPrds
const Muon::TgcPrepDataContainer * tgcPrds
Definition: IMuonCombinedInDetExtensionTool.h:31
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
AthAlgTool
Definition: AthAlgTool.h:26
MuonCombined::IMuonCombinedInDetExtensionTool::MuonPrdData::mmPrds
const Muon::MMPrepDataContainer * mmPrds
Definition: IMuonCombinedInDetExtensionTool.h:34
Muon::MuonLayerSurface::layerIndex
LayerIdx layerIndex
Definition: MuonLayerSurface.h:31
MuonCombined::MuonInsideOutRecoTool::extend
virtual void extend(const InDetCandidateCollection &inDetCandidates, InDetCandidateToTagMap *tagMap, TrackCollection *combTracks, TrackCollection *meTracks, Trk::SegmentCollection *segments, const EventContext &ctx) const override
IMuonCombinedInDetExtensionTool interface: deprecated.
Definition: MuonInsideOutRecoTool.cxx:41
MuonInsideOutRecoTool.h
MuonCombined::MuonInsideOutRecoTool::m_inputSegments
SG::ReadHandleKey< Trk::SegmentCollection > m_inputSegments
Definition: MuonInsideOutRecoTool.h:117
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
MuonCombined::IMuonCombinedInDetExtensionTool::MuonPrdData::stgcPrds
const Muon::sTgcPrepDataContainer * stgcPrds
Definition: IMuonCombinedInDetExtensionTool.h:33
Muon::MuonCandidate::layerIntersections
std::vector< MuonLayerIntersection > layerIntersections
MuonLayerIntersections.
Definition: MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonLayerEvent/MuonLayerEvent/MuonCandidate.h:20
Muon::MuonLayerIntersection
Definition: MuonLayerIntersection.h:13
MDT
@ MDT
Definition: RegSelEnums.h:31
xAOD::TrackParticle_v1::phi
virtual double phi() const override final
The azimuthal angle ( ) of the particle (has range to .)
MuonCombined::IMuonCombinedInDetExtensionTool::MuonPrdData::mdtPrds
const Muon::MdtPrepDataContainer * mdtPrds
Definition: IMuonCombinedInDetExtensionTool.h:29