ATLAS Offline Software
Public Member Functions | Private Member Functions | Private Attributes | List of all members
Muon::MuonLayerSegmentFinderTool Class Reference

#include <MuonLayerSegmentFinderTool.h>

Inheritance diagram for Muon::MuonLayerSegmentFinderTool:
Collaboration diagram for Muon::MuonLayerSegmentFinderTool:

Public Member Functions

virtual ~MuonLayerSegmentFinderTool ()=default
 
StatusCode initialize () override
 
void find (const EventContext &ctx, const MuonSystemExtension::Intersection &intersection, const MuonLayerPrepRawData &layerPrepRawData, std::vector< std::shared_ptr< const Muon::MuonSegment > > &segments) const override
 IMuonLayerSegmentFinderTool interface: find. More...
 
void findMdtSegmentsFromHough (const EventContext &ctx, const MuonSystemExtension::Intersection &intersection, std::vector< std::shared_ptr< const Muon::MuonSegment > > &segments) const override
 

Private Member Functions

void findClusterSegments (const EventContext &ctx, const MuonSystemExtension::Intersection &intersection, const MuonLayerPrepRawData &layerPrepRawData, std::vector< std::shared_ptr< const Muon::MuonSegment > > &segments) const
 find segments from PRD clusters More...
 
void findCscSegments (const EventContext &ctx, const MuonLayerPrepRawData &layerPrepRawData, std::vector< std::shared_ptr< const Muon::MuonSegment > > &segments) const
 find csc segments More...
 
void findMdtSegments (const MuonSystemExtension::Intersection &intersection, const MuonLayerPrepRawData &layerPrepRawData, std::vector< std::shared_ptr< const Muon::MuonSegment > > &segments) const
 find mdt segments from hits in the layer More...
 
void findMdtSegments (const MuonSystemExtension::Intersection &intersection, const std::vector< const MdtDriftCircleOnTrack * > &mdts, const std::vector< const MuonClusterOnTrack * > &clusters, std::vector< std::shared_ptr< const Muon::MuonSegment > > &segments) const
 find mdt segments main routine More...
 

Private Attributes

ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
 
PublicToolHandle< MuonEDMPrinterTool > m_printer
 
ToolHandle< IMuonPRDSelectionTool > m_muonPRDSelectionTool
 
ToolHandle< IMuonSegmentMaker > m_segmentMaker
 
ToolHandle< ICscSegmentFinder > m_csc2dSegmentFinder
 
ToolHandle< ICscSegmentFinder > m_csc4dSegmentFinder
 
ToolHandle< IMuonNSWSegmentFinderTool > m_clusterSegMakerNSW
 
ToolHandle< Muon::IMuonLayerSegmentMatchingTool > m_segmentMatchingTool
 
SG::ReadHandleKey< Muon::HoughDataPerSectorVec > m_houghDataPerSectorVecKey
 Use the hough data to find sectors in the speectrometer traversed by a muon. More...
 
SG::ReadHandleKey< Trk::SegmentCollection > m_patternSegs {this,"InSegmentContainer","TrackMuonSegments"}
 Do not rebuild the segments if the segment is already built upstream. More...
 
const Muon::MuonSectorMapping m_muonSectorMapping {}
 

Detailed Description

Definition at line 34 of file MuonLayerSegmentFinderTool.h.

Constructor & Destructor Documentation

◆ ~MuonLayerSegmentFinderTool()

virtual Muon::MuonLayerSegmentFinderTool::~MuonLayerSegmentFinderTool ( )
virtualdefault

Member Function Documentation

◆ find()

void Muon::MuonLayerSegmentFinderTool::find ( const EventContext &  ctx,
const MuonSystemExtension::Intersection &  intersection,
const MuonLayerPrepRawData &  layerPrepRawData,
std::vector< std::shared_ptr< const Muon::MuonSegment > > &  segments 
) const
override

IMuonLayerSegmentFinderTool interface: find.

Definition at line 38 of file MuonLayerSegmentFinderTool.cxx.

39  {
40  ATH_MSG_VERBOSE(
41  " Running segment finding in sector "
42  << intersection.layerSurface.sector << " region " << MuonStationIndex::regionName(intersection.layerSurface.regionIndex)
43  << " layer " << MuonStationIndex::layerName(intersection.layerSurface.layerIndex) << " intersection position: r "
44  << intersection.trackParameters->position().perp() << " z " << intersection.trackParameters->position().z() << " locX "
45  << intersection.trackParameters->parameters()[Trk::locX] << " locY " << intersection.trackParameters->parameters()[Trk::locY]
46  << " phi " << intersection.trackParameters->position().phi());
47 
48  // run cluster hit based segment finding on PRDs
49  findClusterSegments(ctx, intersection, layerPrepRawData, segments);
50  ATH_MSG_VERBOSE(" findClusterSegments " << segments.size());
51 
52  // run standard MDT/Trigger hit segment finding either from Hough or hits
53  findMdtSegments(intersection, layerPrepRawData, segments);
54  }

◆ findClusterSegments()

void Muon::MuonLayerSegmentFinderTool::findClusterSegments ( const EventContext &  ctx,
const MuonSystemExtension::Intersection &  intersection,
const MuonLayerPrepRawData &  layerPrepRawData,
std::vector< std::shared_ptr< const Muon::MuonSegment > > &  segments 
) const
private

find segments from PRD clusters

Find whether the segment has some hits that are needed

Nope

Segment is compatible

If no NSW was reconstructed thus far there's no hope that we'll do it later as well. Give up Lasst, die Ihr eintretet, alle Hoffnung fahren!

Definition at line 94 of file MuonLayerSegmentFinderTool.cxx.

96  {
97  // if there are CSC hits run CSC segment finding
98  if (!layerPrepRawData.cscs.empty()) findCscSegments(ctx, layerPrepRawData, segments);
99 
100  // No need to call the NSW segment finding
101  if (layerPrepRawData.mms.empty() && layerPrepRawData.stgcs.empty()) return;
102 
103  // NSW segment finding
104  MuonLayerROTs layerROTs;
105  if (!m_muonPRDSelectionTool->calibrateAndSelect(intersection, layerPrepRawData, layerROTs)) {
106  ATH_MSG_WARNING("Failed to calibrate and select layer data");
107  return;
108  }
109 
110  ATH_MSG_DEBUG(" MM prds " << layerPrepRawData.mms.size() << " STGC prds " << layerPrepRawData.stgcs.size());
111 
112  // get STGC and MM clusters
113  const std::vector<const MuonClusterOnTrack*>& clustersSTGC = layerROTs.getClusters(TechnologyIndex::STGC);
114  const std::vector<const MuonClusterOnTrack*>& clustersMM = layerROTs.getClusters(TechnologyIndex::MM);
115 
116  using NSWSegmentCache = Muon::IMuonNSWSegmentFinderTool::SegmentMakingCache;
117  NSWSegmentCache cache{};
118 
119 
120  if (!clustersSTGC.empty()) {
121  ATH_MSG_DEBUG(" STGC clusters " << clustersSTGC.size());
122  std::transform(clustersSTGC.begin(), clustersSTGC.end(), std::back_inserter(cache.inputClust),
123  [](const Muon::MuonClusterOnTrack* cl){ return std::unique_ptr<Muon::MuonClusterOnTrack>{cl->clone()};});
124 
125  }
126  if (!clustersMM.empty()) {
127  ATH_MSG_DEBUG(" MM clusters " << clustersMM.size());
128  std::transform(clustersMM.begin(), clustersMM.end(), std::back_inserter(cache.inputClust),
129  [](const Muon::MuonClusterOnTrack* cl){ return std::unique_ptr<Muon::MuonClusterOnTrack>{cl->clone()};});
130  }
131  if (cache.inputClust.empty()) return;
132 
133 
134  if (!m_patternSegs.empty()) {
135  std::set<Identifier> needed_rios{};
136  for (std::unique_ptr<const MuonClusterOnTrack>& clus : cache.inputClust) {
137  needed_rios.insert(clus->identify());
138  }
139  SG::ReadHandle<Trk::SegmentCollection> input_segs{m_patternSegs, ctx};
140  for (const Trk::Segment *trk_seg : *input_segs) {
141  const MuonSegment *seg = dynamic_cast<const Muon::MuonSegment *>(trk_seg);
142  // Initial check that the segments are on the same detector side
143  if (intersection.trackParameters->associatedSurface().center().z() * seg->globalPosition().z() < 0) continue;
144 
146  bool hasNSW{false};
147  for (size_t n = 0; !hasNSW && n < seg->numberOfContainedROTs(); ++n) {
148  const MuonClusterOnTrack *clus = dynamic_cast<const MuonClusterOnTrack *>(seg->rioOnTrack(n));
149  hasNSW |= (clus && needed_rios.count(clus->identify()));
150  }
152  if (!hasNSW) continue;
154  if (m_segmentMatchingTool->match(ctx, intersection, *seg)) segments.emplace_back(seg->clone());
155  }
158  return;
159  }
160 
161  m_clusterSegMakerNSW->find(ctx, cache);
162 
163  for (std::unique_ptr<MuonSegment>& seg : cache.constructedSegs) {
164  ATH_MSG_DEBUG(" NSW segment " << m_printer->print(*seg));
165  segments.emplace_back(std::move(seg));
166  }
167  }

◆ findCscSegments()

void Muon::MuonLayerSegmentFinderTool::findCscSegments ( const EventContext &  ctx,
const MuonLayerPrepRawData &  layerPrepRawData,
std::vector< std::shared_ptr< const Muon::MuonSegment > > &  segments 
) const
private

find csc segments

Definition at line 169 of file MuonLayerSegmentFinderTool.cxx.

170  {
171  // run 2d segment finder
172  std::unique_ptr<MuonSegmentCombinationCollection> combi2D = m_csc2dSegmentFinder->find(layerPrepRawData.cscs, ctx);
173  if (!combi2D) return;
174 
175  // run 4d segment finder
176  std::unique_ptr<MuonSegmentCombinationCollection> combi4D = m_csc4dSegmentFinder->find(*combi2D, ctx);
177  if (!combi4D) return;
178 
179  // extract segments and clean-up memory
180  for (auto com : *combi4D) {
181  const Muon::MuonSegmentCombination& combi = *com;
182  unsigned int nstations = combi.numberOfStations();
183 
184  // loop over chambers in combi and extract segments
185  for (unsigned int i = 0; i < nstations; ++i) {
186  // loop over segments in station
187  Muon::MuonSegmentCombination::SegmentVec* segs = combi.stationSegments(i);
188 
189  // check if not empty
190  if (!segs || segs->empty()) continue;
191  // loop over new segments, copy them into collection
192  for (std::unique_ptr<MuonSegment>& seg_it : *segs) {
193  ATH_MSG_DEBUG(" " << m_printer->print(*seg_it));
194  segments.emplace_back(std::move(seg_it));
195  }
196  }
197  }
198  }

◆ findMdtSegments() [1/2]

void Muon::MuonLayerSegmentFinderTool::findMdtSegments ( const MuonSystemExtension::Intersection &  intersection,
const MuonLayerPrepRawData &  layerPrepRawData,
std::vector< std::shared_ptr< const Muon::MuonSegment > > &  segments 
) const
private

find mdt segments from hits in the layer

◆ findMdtSegments() [2/2]

void Muon::MuonLayerSegmentFinderTool::findMdtSegments ( const MuonSystemExtension::Intersection &  intersection,
const std::vector< const MdtDriftCircleOnTrack * > &  mdts,
const std::vector< const MuonClusterOnTrack * > &  clusters,
std::vector< std::shared_ptr< const Muon::MuonSegment > > &  segments 
) const
private

find mdt segments main routine

◆ findMdtSegmentsFromHough()

void Muon::MuonLayerSegmentFinderTool::findMdtSegmentsFromHough ( const EventContext &  ctx,
const MuonSystemExtension::Intersection &  intersection,
std::vector< std::shared_ptr< const Muon::MuonSegment > > &  segments 
) const
override

Definition at line 199 of file MuonLayerSegmentFinderTool.cxx.

201  {
202 
203  if(m_houghDataPerSectorVecKey.empty()) return;
204  unsigned int nprevSegments = segments.size(); // keep track of what is already there
205  int sector = intersection.layerSurface.sector;
206  MuonStationIndex::DetectorRegionIndex regionIndex = intersection.layerSurface.regionIndex;
207  MuonStationIndex::LayerIndex layerIndex = intersection.layerSurface.layerIndex;
208 
209  // get hough data
210  SG::ReadHandle houghDataPerSectorVec{m_houghDataPerSectorVecKey, ctx};
211  if (!houghDataPerSectorVec.isValid()) {
212  ATH_MSG_ERROR("Hough data per sector vector not found");
213  return;
214  }
215 
216  // sanity check
217  if (static_cast<int>(houghDataPerSectorVec->vec.size()) <= sector - 1) {
218  ATH_MSG_WARNING(" MuonLayerHoughTool::HoughDataPerSectorVec smaller than sector "
219  << houghDataPerSectorVec->vec.size() << " sector " << sector);
220  return;
221  }
222 
223  // get hough maxima in the layer
224  unsigned int sectorLayerHash = MuonStationIndex::sectorLayerHash(regionIndex, layerIndex);
225  const MuonLayerHoughTool::HoughDataPerSector& houghDataPerSector = houghDataPerSectorVec->vec[sector - 1];
226  ATH_MSG_DEBUG(" findMdtSegmentsFromHough: sector "
227  << sector << " " << MuonStationIndex::regionName(regionIndex) << " "
228  << MuonStationIndex::layerName(layerIndex) << " sector hash " << sectorLayerHash << " houghData "
229  << houghDataPerSectorVec->vec.size() << " " << houghDataPerSector.maxVec.size());
230 
231  // sanity check
232  if (houghDataPerSector.maxVec.size() <= sectorLayerHash) {
233  ATH_MSG_WARNING(" houghDataPerSector.maxVec.size() smaller than hash " << houghDataPerSector.maxVec.size()
234  << " hash " << sectorLayerHash);
235  return;
236  }
237  const MuonLayerHoughTool::MaximumVec& maxVec = houghDataPerSector.maxVec[sectorLayerHash];
238 
239  // get local coordinates in the layer frame
240  bool barrelLike = intersection.layerSurface.regionIndex == DetectorRegionIndex::Barrel;
241 
242  float phi = intersection.trackParameters->position().phi();
243 
244  // in the endcaps take the r in the sector frame from the local position of the extrapolation
245  float r = barrelLike ? m_muonSectorMapping.transformRToSector(intersection.trackParameters->position().perp(), phi,
246  intersection.layerSurface.sector, true)
247  : intersection.trackParameters->parameters()[Trk::locX];
248 
249  float z = intersection.trackParameters->position().z();
250  float errx = Amg::error(*intersection.trackParameters->covariance(), Trk::locX);
251  float x = barrelLike ? r : z;
252  float y = barrelLike ? z : r;
253  float theta = std::atan2(x, y);
254 
255  ATH_MSG_DEBUG(" Got Hough maxima " << maxVec.size() << " extrapolated position in Hough space (" << x << "," << y
256  << ") error " << errx << " "
257  << " angle " << theta);
258 
259  // lambda to handle calibration and selection of MDTs
260  std::vector<std::unique_ptr<const Trk::MeasurementBase>> garbage;
261  auto handleMdt = [this, intersection, &garbage](const MdtPrepData& prd, std::vector<const MdtDriftCircleOnTrack*>& mdts) {
262  const MdtDriftCircleOnTrack* mdt = m_muonPRDSelectionTool->calibrateAndSelect(intersection, prd);
263  if (!mdt) return;
264  mdts.push_back(mdt);
265  garbage.emplace_back(mdt);
266  };
267 
268 
269  // lambda to handle calibration and selection of clusters
270  auto handleCluster = [this, intersection,&garbage](const MuonCluster& prd,
271  std::vector<const MuonClusterOnTrack*>& clusters) {
272  const MuonClusterOnTrack* cluster = m_muonPRDSelectionTool->calibrateAndSelect(intersection, prd);
273  if (!cluster) return;
274  clusters.push_back(cluster);
275  garbage.emplace_back(cluster);
276  };
277 
278 
279  // loop over maxima and associate them to the extrapolation
280  MuonLayerHoughTool::MaximumVec::const_iterator mit = maxVec.begin();
281  MuonLayerHoughTool::MaximumVec::const_iterator mit_end = maxVec.end();
282  for (; mit != mit_end; ++mit) {
283  const MuonHough::MuonLayerHough::Maximum& maximum = **mit;
284  float residual = maximum.pos - y;
285  float residualTheta = maximum.theta - theta;
286  float refPos = (maximum.hough != nullptr) ? maximum.hough->m_descriptor.referencePosition : 0;
287  float maxwidth = (maximum.binposmax - maximum.binposmin);
288  if (maximum.hough) maxwidth *= maximum.hough->m_binsize;
289  float pull = residual / std::hypot(errx , maxwidth * OneOverSqrt12);
290 
291 
292  ATH_MSG_DEBUG(" Hough maximum " << maximum.max << " position (" << refPos << "," << maximum.pos
293  << ") residual " << residual << " pull " << pull << " angle " << maximum.theta
294  << " residual " << residualTheta);
295 
296  // select maximum
297  if (std::abs(pull) > 5) continue;
298 
299  // loop over hits in maximum and add them to the hit list
300  std::vector<const MdtDriftCircleOnTrack*> mdts;
301  std::vector<const MuonClusterOnTrack*> clusters;
302  for (const auto& hit : maximum.hits) {
303 
304  // treat the case that the hit is a composite TGC hit
305  if (hit->tgc) {
306  for (const auto& prd : hit->tgc->etaCluster) {
307  handleCluster(*prd, clusters);
308  }
309  } else if (hit->prd) {
310  Identifier id = hit->prd->identify();
311  if (m_idHelperSvc->isMdt(id))
312  handleMdt(static_cast<const MdtPrepData&>(*hit->prd), mdts);
313  else
314  handleCluster(static_cast<const MuonCluster&>(*hit->prd), clusters);
315  }
316  }
317 
318  // get phi hits
319  const MuonLayerHoughTool::PhiMaximumVec& phiMaxVec =
320  houghDataPerSector.phiMaxVec[toInt(intersection.layerSurface.regionIndex)];
321  ATH_MSG_DEBUG(" Got Phi Hough maxima " << phiMaxVec.size() << " phi " << phi);
322 
323  // loop over maxima and associate them to the extrapolation
324  MuonLayerHoughTool::PhiMaximumVec::const_iterator pit = phiMaxVec.begin();
325  MuonLayerHoughTool::PhiMaximumVec::const_iterator pit_end = phiMaxVec.end();
326  for (; pit != pit_end; ++pit) {
327  const MuonHough::MuonPhiLayerHough::Maximum& maximum = **pit;
328  const float residual = deltaPhi( maximum.pos, phi);
329 
330  ATH_MSG_DEBUG(" Phi Hough maximum " << maximum.max << " phi " << maximum.pos << ") angle "
331  << maximum.pos << " residual " << residual);
332 
333  for (const auto& phi_hit : maximum.hits) {
334  // treat the case that the hit is a composite TGC hit
335  if (phi_hit->tgc) {
336  Identifier id = phi_hit->tgc->phiCluster.front()->identify();
337  if (m_idHelperSvc->layerIndex(id) != intersection.layerSurface.layerIndex) continue;
338  for (const auto& prd : phi_hit->tgc->phiCluster) handleCluster(*prd, clusters);
339  } else if (phi_hit->prd) {
340  Identifier id = phi_hit->prd->identify();
341  if (m_idHelperSvc->layerIndex(id) != intersection.layerSurface.layerIndex) continue;
342  handleCluster(static_cast<const MuonCluster&>(*phi_hit->prd), clusters);
343  }
344  }
345  }
346 
347  // call segment finder
348  ATH_MSG_DEBUG(" Got hits: mdts " << mdts.size() << " clusters " << clusters.size());
349  findMdtSegments(intersection, mdts, clusters, segments);
350 
351  // clean-up memory
352  garbage.clear();
353  ATH_MSG_DEBUG(" Done maximum: new segments " << segments.size() - nprevSegments);
354  }
355  ATH_MSG_DEBUG(" Done with layer: new segments " << segments.size() - nprevSegments);
356  }

◆ initialize()

StatusCode Muon::MuonLayerSegmentFinderTool::initialize ( )
override

Definition at line 23 of file MuonLayerSegmentFinderTool.cxx.

23  {
24  ATH_CHECK(m_idHelperSvc.retrieve());
25  ATH_CHECK(m_printer.retrieve());
26  ATH_CHECK(m_muonPRDSelectionTool.retrieve());
27  ATH_CHECK(m_segmentMaker.retrieve());
28  ATH_CHECK(m_csc2dSegmentFinder.retrieve(DisableTool{!m_idHelperSvc->hasCSC() || m_csc2dSegmentFinder.empty()}));
29  ATH_CHECK(m_csc4dSegmentFinder.retrieve(DisableTool{!m_idHelperSvc->hasCSC() || m_csc4dSegmentFinder.empty()}));
30  ATH_CHECK(m_patternSegs.initialize(!m_patternSegs.empty()));
31  ATH_CHECK(m_segmentMatchingTool.retrieve(DisableTool{m_patternSegs.empty()}));
32  ATH_CHECK(m_houghDataPerSectorVecKey.initialize(!m_houghDataPerSectorVecKey.empty()));
33  ATH_CHECK(m_clusterSegMakerNSW.retrieve(DisableTool{m_clusterSegMakerNSW.empty()|| !m_patternSegs.empty()}));
34 
35  return StatusCode::SUCCESS;
36  }

Member Data Documentation

◆ m_clusterSegMakerNSW

ToolHandle<IMuonNSWSegmentFinderTool> Muon::MuonLayerSegmentFinderTool::m_clusterSegMakerNSW
private
Initial value:
{
this,
"NSWMuonClusterSegmentFinderTool",
"",
}

Definition at line 100 of file MuonLayerSegmentFinderTool.h.

◆ m_csc2dSegmentFinder

ToolHandle<ICscSegmentFinder> Muon::MuonLayerSegmentFinderTool::m_csc2dSegmentFinder
private
Initial value:
{
this,
"Csc2DSegmentMaker",
"Csc2dSegmentMaker/Csc2dSegmentMaker",
}

Definition at line 90 of file MuonLayerSegmentFinderTool.h.

◆ m_csc4dSegmentFinder

ToolHandle<ICscSegmentFinder> Muon::MuonLayerSegmentFinderTool::m_csc4dSegmentFinder
private
Initial value:
{
this,
"Csc4DSegmentMaker",
"Csc4dSegmentMaker/Csc4dSegmentMaker",
}

Definition at line 95 of file MuonLayerSegmentFinderTool.h.

◆ m_houghDataPerSectorVecKey

SG::ReadHandleKey<Muon::HoughDataPerSectorVec> Muon::MuonLayerSegmentFinderTool::m_houghDataPerSectorVecKey
private
Initial value:
{this, "HoughKey",
"", "HoughDataPerSectorVec key"}

Use the hough data to find sectors in the speectrometer traversed by a muon.

Definition at line 110 of file MuonLayerSegmentFinderTool.h.

◆ m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> Muon::MuonLayerSegmentFinderTool::m_idHelperSvc
private
Initial value:
{
this,
"MuonIdHelperSvc",
"Muon::MuonIdHelperSvc/MuonIdHelperSvc",
}

Definition at line 69 of file MuonLayerSegmentFinderTool.h.

◆ m_muonPRDSelectionTool

ToolHandle<IMuonPRDSelectionTool> Muon::MuonLayerSegmentFinderTool::m_muonPRDSelectionTool
private
Initial value:
{
this,
"MuonPRDSelectionTool",
"Muon::MuonPRDSelectionTool/MuonPRDSelectionTool",
}

Definition at line 80 of file MuonLayerSegmentFinderTool.h.

◆ m_muonSectorMapping

const Muon::MuonSectorMapping Muon::MuonLayerSegmentFinderTool::m_muonSectorMapping {}
private

Definition at line 116 of file MuonLayerSegmentFinderTool.h.

◆ m_patternSegs

SG::ReadHandleKey<Trk::SegmentCollection> Muon::MuonLayerSegmentFinderTool::m_patternSegs {this,"InSegmentContainer","TrackMuonSegments"}
private

Do not rebuild the segments if the segment is already built upstream.

Definition at line 114 of file MuonLayerSegmentFinderTool.h.

◆ m_printer

PublicToolHandle<MuonEDMPrinterTool> Muon::MuonLayerSegmentFinderTool::m_printer
private
Initial value:
{
this,
"MuonEDMPrinterTool",
"Muon::MuonEDMPrinterTool/MuonEDMPrinterTool",
}

Definition at line 75 of file MuonLayerSegmentFinderTool.h.

◆ m_segmentMaker

ToolHandle<IMuonSegmentMaker> Muon::MuonLayerSegmentFinderTool::m_segmentMaker
private
Initial value:
{
this,
"SegmentMaker",
"Muon::DCMathSegmentMaker/DCMathSegmentMaker",
}

Definition at line 85 of file MuonLayerSegmentFinderTool.h.

◆ m_segmentMatchingTool

ToolHandle<Muon::IMuonLayerSegmentMatchingTool> Muon::MuonLayerSegmentFinderTool::m_segmentMatchingTool
private
Initial value:
{
this, "MuonLayerSegmentMatchingTool", "Muon::MuonLayerSegmentMatchingTool/MuonLayerSegmentMatchingTool"}

Definition at line 106 of file MuonLayerSegmentFinderTool.h.

The documentation for this class was generated from the following files:
Muon::MuonStationIndex::LayerIndex
LayerIndex
enum to classify the different layers in the muon spectrometer
Definition: MuonStationIndex.h:38
beamspotman.r
def r
Definition: beamspotman.py:674
Trk::PrepRawDataType::MdtPrepData
@ MdtPrepData
Muon::MuonStationIndex::DetectorRegionIndex::Barrel
@ Barrel
Muon::MuonSegmentCombination
Definition: MuonSegmentCombination.h:30
MuonHough::MuonPhiLayerHough::Maximum::pos
float pos
Definition: MuonPhiLayerHough.h:27
Muon::MuonLayerSegmentFinderTool::m_csc4dSegmentFinder
ToolHandle< ICscSegmentFinder > m_csc4dSegmentFinder
Definition: MuonLayerSegmentFinderTool.h:95
Muon::MuonLayerSegmentFinderTool::m_patternSegs
SG::ReadHandleKey< Trk::SegmentCollection > m_patternSegs
Do not rebuild the segments if the segment is already built upstream.
Definition: MuonLayerSegmentFinderTool.h:114
Trk::locX
@ locX
Definition: ParamDefs.h:37
Trk::locY
@ locY
local cartesian
Definition: ParamDefs.h:38
Muon::MuonSectorMapping::transformRToSector
double transformRToSector(double r, double phi, int sector, bool toSector=true) const
expresses a radial position from and to the sector coordinate frame, the phi position should always b...
Definition: MuonSectorMapping.h:140
MuonHough::MuonLayerHough::m_binsize
float m_binsize
Definition: MuonLayerHough.h:176
ClusterSeg::residual
@ residual
Definition: ClusterNtuple.h:20
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
xAOD::deltaPhi
setSAddress setEtaMS setDirPhiMS setDirZMS setBarrelRadius setEndcapAlpha setEndcapRadius setInterceptInner setEtaMap setEtaBin setIsTgcFailure setDeltaPt deltaPhi
Definition: L2StandAloneMuon_v1.cxx:161
Muon::MuonLayerSegmentFinderTool::m_clusterSegMakerNSW
ToolHandle< IMuonNSWSegmentFinderTool > m_clusterSegMakerNSW
Definition: MuonLayerSegmentFinderTool.h:100
Muon::MuonLayerSegmentFinderTool::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition: MuonLayerSegmentFinderTool.h:69
MuonHough::MuonLayerHough::m_descriptor
RegionDescriptor m_descriptor
Definition: MuonLayerHough.h:187
Muon::MuonStationIndex::sectorLayerHash
unsigned int sectorLayerHash(DetectorRegionIndex detectorRegionIndex, LayerIndex layerIndex)
create a hash out of region and layer
Muon::MuonLayerSegmentFinderTool::m_segmentMaker
ToolHandle< IMuonSegmentMaker > m_segmentMaker
Definition: MuonLayerSegmentFinderTool.h:85
Muon::MuonLayerSegmentFinderTool::findMdtSegments
void findMdtSegments(const MuonSystemExtension::Intersection &intersection, const MuonLayerPrepRawData &layerPrepRawData, std::vector< std::shared_ptr< const Muon::MuonSegment > > &segments) const
find mdt segments from hits in the layer
Muon::MuonSegmentCombination::stationSegments
SegmentVec * stationSegments(unsigned int index) const
Access to segments in a given station.
Definition: MuonSegmentCombination.h:114
Muon::MuonLayerSegmentFinderTool::m_muonSectorMapping
const Muon::MuonSectorMapping m_muonSectorMapping
Definition: MuonLayerSegmentFinderTool.h:116
MuonHough::RegionDescriptor::referencePosition
float referencePosition
Definition: MuonLayerHough.h:48
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
x
#define x
intersection
std::vector< std::string > intersection(std::vector< std::string > &v1, std::vector< std::string > &v2)
Definition: compareFlatTrees.cxx:25
xAOD::MuonSegment
MuonSegment_v1 MuonSegment
Reference the current persistent version:
Definition: Event/xAOD/xAODMuon/xAODMuon/MuonSegment.h:13
Muon::MuonLayerHoughTool::PhiMaximumVec
HoughDataPerSec::PhiMaximumVec PhiMaximumVec
Definition: MuonLayerHoughTool.h:64
xAOD::phi
setEt phi
Definition: TrigEMCluster_v1.cxx:29
MuonHough::MuonLayerHough::Maximum::binposmin
int binposmin
Definition: MuonLayerHough.h:76
MuonHough::MuonLayerHough::Maximum
struct representing the maximum in the hough space
Definition: MuonLayerHough.h:64
Muon::MuonStationIndex::TechnologyIndex::MM
@ MM
MuonHough::MuonLayerHough::Maximum::theta
float theta
Definition: MuonLayerHough.h:69
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
Muon::MuonLayerSegmentFinderTool::findClusterSegments
void findClusterSegments(const EventContext &ctx, const MuonSystemExtension::Intersection &intersection, const MuonLayerPrepRawData &layerPrepRawData, std::vector< std::shared_ptr< const Muon::MuonSegment > > &segments) const
find segments from PRD clusters
Definition: MuonLayerSegmentFinderTool.cxx:94
MuonHough::MuonLayerHough::Maximum::max
float max
Definition: MuonLayerHough.h:67
Muon::MuonLayerSegmentFinderTool::m_muonPRDSelectionTool
ToolHandle< IMuonPRDSelectionTool > m_muonPRDSelectionTool
Definition: MuonLayerSegmentFinderTool.h:80
lumiFormat.i
int i
Definition: lumiFormat.py:85
z
#define z
beamspotman.n
n
Definition: beamspotman.py:729
MuonHough::MuonPhiLayerHough::Maximum
Definition: MuonPhiLayerHough.h:23
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
Muon::MuonLayerSegmentFinderTool::m_houghDataPerSectorVecKey
SG::ReadHandleKey< Muon::HoughDataPerSectorVec > m_houghDataPerSectorVecKey
Use the hough data to find sectors in the speectrometer traversed by a muon.
Definition: MuonLayerSegmentFinderTool.h:110
MuonHough::MuonPhiLayerHough::Maximum::hits
PhiHitVec hits
Definition: MuonPhiLayerHough.h:35
Trk::Segment
Definition: Tracking/TrkEvent/TrkSegment/TrkSegment/Segment.h:56
Amg::transform
Amg::Vector3D transform(Amg::Vector3D &v, Amg::Transform3D &tr)
Transform a point from a Trasformation3D.
Definition: GeoPrimitivesHelpers.h:156
Muon::MuonLayerSegmentFinderTool::findCscSegments
void findCscSegments(const EventContext &ctx, const MuonLayerPrepRawData &layerPrepRawData, std::vector< std::shared_ptr< const Muon::MuonSegment > > &segments) const
find csc segments
Definition: MuonLayerSegmentFinderTool.cxx:169
python.StandardJetMods.pull
pull
Definition: StandardJetMods.py:304
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
Muon::MuonLayerSegmentFinderTool::m_printer
PublicToolHandle< MuonEDMPrinterTool > m_printer
Definition: MuonLayerSegmentFinderTool.h:75
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
MuonHough::MuonLayerHough::Maximum::hough
const MuonLayerHough * hough
Definition: MuonLayerHough.h:83
jobOption.theta
theta
Definition: jobOption.ParticleGun_fwd_sequence.py:13
Muon::MuonLayerHoughTool::MaximumVec
HoughDataPerSec::MaximumVec MaximumVec
Definition: MuonLayerHoughTool.h:63
MuonHough::MuonPhiLayerHough::Maximum::max
float max
Definition: MuonPhiLayerHough.h:26
Muon::MuonStationIndex::layerName
const std::string & layerName(LayerIndex index)
convert LayerIndex into a string
Definition: MuonStationIndex.cxx:153
Amg::error
double error(const Amg::MatrixX &mat, int index)
return diagonal error of the matrix caller should ensure the matrix is symmetric and the index is in ...
Definition: EventPrimitivesHelpers.h:40
MuonR4::SegmentFit::toInt
constexpr int toInt(const ParamDefs p)
Definition: MuonHoughDefs.h:42
MuonHough::MuonLayerHough::Maximum::pos
float pos
Definition: MuonLayerHough.h:68
MuonCluster
Definition: Trigger/TrigAlgorithms/TrigLongLivedParticles/src/MuonCluster.h:46
Muon::MuonStationIndex::regionName
const std::string & regionName(DetectorRegionIndex index)
convert DetectorRegionIndex into a string
Definition: MuonStationIndex.cxx:138
MuonHough::MuonLayerHough::Maximum::hits
HitVec hits
Definition: MuonLayerHough.h:81
Muon::MuonLayerHoughTool::HoughDataPerSector
HoughDataPerSec HoughDataPerSector
Definition: MuonLayerHoughTool.h:68
Muon::MuonStationIndex::DetectorRegionIndex
DetectorRegionIndex
enum to classify the different layers in the muon spectrometer
Definition: MuonStationIndex.h:47
y
#define y
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
Muon::MuonSegmentCombination::SegmentVec
std::vector< std::unique_ptr< MuonSegment > > SegmentVec
Definition: MuonSegmentCombination.h:32
Muon::IMuonNSWSegmentFinderTool::SegmentMakingCache
Helper struct to parse the data around.
Definition: IMuonNSWSegmentFinderTool.h:31
Muon::MuonStationIndex::TechnologyIndex::STGC
@ STGC
RunTileMonitoring.clusters
clusters
Definition: RunTileMonitoring.py:133
Muon::MuonLayerSegmentFinderTool::m_segmentMatchingTool
ToolHandle< Muon::IMuonLayerSegmentMatchingTool > m_segmentMatchingTool
Definition: MuonLayerSegmentFinderTool.h:106
Muon::MuonSegment
Definition: MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonSegment/MuonSegment/MuonSegment.h:45
Muon::MuonLayerSegmentFinderTool::m_csc2dSegmentFinder
ToolHandle< ICscSegmentFinder > m_csc2dSegmentFinder
Definition: MuonLayerSegmentFinderTool.h:90
MuonHough::MuonLayerHough::Maximum::binposmax
int binposmax
Definition: MuonLayerHough.h:77
dq_make_web_display.cl
cl
print [x.__class__ for x in toList(dqregion.getSubRegions()) ]
Definition: dq_make_web_display.py:25
Muon::MuonSegmentCombination::numberOfStations
unsigned int numberOfStations() const
Number of stations with segment.
Definition: MuonSegmentCombination.h:108
Muon::MuonClusterOnTrack
Base class for Muon cluster RIO_OnTracks.
Definition: MuonClusterOnTrack.h:34
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Sun Aug 31 2025 22:03:51 for ATLAS Offline Software by   doxygen 1.8.18