ATLAS Offline Software
MuonStauRecoTool.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "MuonStauRecoTool.h"
6 
7 #include <memory>
8 
10 #include "GaudiKernel/ConcurrencyFlags.h"
29 
30 namespace {
31  constexpr double inverseSpeedOfLight = 1 / Gaudi::Units::c_light; // need 1/299.792458 inside calculateTof()/calculateBeta()
32 
33 }
34 using namespace Muon::MuonStationIndex;
35 namespace MuonCombined {
36 
38  std::ostringstream sout;
39  sout << " sector " << intersection.layerSurface.sector << " "
40  << Muon::MuonStationIndex::regionName(intersection.layerSurface.regionIndex) << " "
41  << Muon::MuonStationIndex::layerName(intersection.layerSurface.layerIndex);
42  return sout.str();
43  }
44 
45  MuonStauRecoTool::MuonStauRecoTool(const std::string& type, const std::string& name, const IInterface* parent) :
47 
49  ATH_CHECK(m_idHelperSvc.retrieve());
50  ATH_CHECK(m_printer.retrieve());
51  ATH_CHECK(m_edmHelperSvc.retrieve());
52  ATH_CHECK(m_segmentMaker.retrieve());
53  ATH_CHECK(m_segmentMakerT0Fit.retrieve());
54  ATH_CHECK(m_segmentMatchingTool.retrieve());
56  ATH_CHECK(m_hitTimingTool.retrieve());
59  ATH_CHECK(m_mdtCreator.retrieve());
60  ATH_CHECK(m_mdtCreatorStau.retrieve());
61  ATH_CHECK(m_insideOutRecoTool.retrieve());
62  ATH_CHECK(m_updator.retrieve());
65 
66  if (m_doTruth) {
67  // add pdgs from jobO to set
68  for (auto pdg : m_pdgsToBeConsidered.value()) { m_selectedPdgs.insert(pdg); }
69  }
70  return StatusCode::SUCCESS;
71  }
72 
75  TrackCollection* meTracks, Trk::SegmentCollection* segments, const EventContext& ctx) const {
76  // Maybe we'll need this later, I wouldn't be surprised if the PRDs are retrieved somewhere down the chain
77  // For now it's just a placeholder though
78  if (!prdData.mdtPrds) ATH_MSG_DEBUG("empty PRDs passed");
79  extend(inDetCandidates, tagMap, combTracks, meTracks, segments, ctx);
80  }
81 
83  TrackCollection* combTracks, TrackCollection* meTracks, Trk::SegmentCollection* segments,
84  const EventContext& ctx) const {
85  ATH_MSG_DEBUG(" extending " << inDetCandidates.size());
86 
87  if (meTracks) ATH_MSG_DEBUG("Not currently creating ME tracks for staus");
88  for (const InDetCandidate* it : inDetCandidates) { handleCandidate(ctx, *it, tagMap, combTracks, segments); }
89  }
90 
91  std::unique_ptr<MuonStauRecoTool::TruthInfo>
92  MuonStauRecoTool::getTruth(const xAOD::TrackParticle& indetTrackParticle) const {
93  // in case we are using the truth, check if the truth link is set and create the TruthInfo object
95  truthParticleLinkAcc("truthParticleLink");
96  if (m_doTruth && truthParticleLinkAcc.isAvailable(indetTrackParticle)) {
97  const ElementLink<xAOD::TruthParticleContainer>& truthLink = truthParticleLinkAcc(indetTrackParticle);
98  if (truthLink.isValid()) {
99  return std::make_unique<TruthInfo>((*truthLink)->pdgId(), (*truthLink)->m(), (*truthLink)->p4().Beta());
100  }
101  }
102  return nullptr;
103  }
104 
105  void MuonStauRecoTool::handleCandidate(const EventContext& ctx, const InDetCandidate& indetCandidate, InDetCandidateToTagMap* tagMap,
106  TrackCollection* combTracks, Trk::SegmentCollection* segments) const {
107  if (m_ignoreSiAssocated && indetCandidate.isSiliconAssociated()) {
108  ATH_MSG_DEBUG(" skip silicon associated track for extension ");
109  return;
110  }
111 
116  // get TrackParticle and apply the kinematic selection
117  const xAOD::TrackParticle& indetTrackParticle = indetCandidate.indetTrackParticle();
118  if (!indetTrackParticle.track() || indetTrackParticle.pt() < m_ptThreshold) return;
119 
120  // get truth info (will be zero pointer if running on data or m_doTruth == false)
121  std::unique_ptr<TruthInfo> truthInfo(getTruth(indetTrackParticle));
122 
123  // if truth based reconstruction is enabled, check whether to accept the given pdgId
124  if (!selectTruth(truthInfo.get())) {
125  ATH_MSG_DEBUG("Truth reconstruction enabled: skipping ID track with pdgId: " << (truthInfo ? truthInfo->pdgId : 0));
126  return;
127  }
128 
129  // get intersections which precision layers in the muon system
130  const Muon::MuonSystemExtension* muonSystemExtension = indetCandidate.getExtension();
131 
132  // summary for selected ID track
133  if (m_doSummary || msgLvl(MSG::DEBUG)) {
134  msg(MSG::INFO) << " ID track: pt " << indetTrackParticle.pt() << " eta " << indetTrackParticle.eta() << " phi "
135  << indetTrackParticle.phi();
136  if (truthInfo) msg(MSG::INFO) << truthInfo->toString();
137  if (!muonSystemExtension) msg(MSG::INFO) << " failed muonSystemExtension";
138  msg(MSG::INFO) << endmsg;
139  }
140 
141  // exit if no MuonSystemExtension was found
142  if (!muonSystemExtension) { return; }
143 
144  // fill validation content
145  if (!m_recoValidationTool.empty()) m_recoValidationTool->addTrackParticle(indetTrackParticle, *muonSystemExtension);
150  AssociatedData associatedData;
151  if (!extractTimeMeasurements(ctx, *muonSystemExtension, associatedData)) { return; }
152 
158  if (!createCandidates(associatedData, candidates)) { return; }
159 
160  if (!m_recoValidationTool.empty()) addCandidatesToNtuple(indetTrackParticle, candidates, 0);
161 
166  if (!refineCandidates(ctx, candidates)) { return; }
167 
168  if (!m_recoValidationTool.empty()) addCandidatesToNtuple(indetTrackParticle, candidates, 1);
169 
174  if (!combineCandidates(ctx, indetTrackParticle, candidates)) { return; }
175 
176  if (!m_recoValidationTool.empty()) addCandidatesToNtuple(indetTrackParticle, candidates, 2);
181  if (!resolveAmbiguities(candidates)) { return; }
182 
183  if (!m_recoValidationTool.empty()) addCandidatesToNtuple(indetTrackParticle, candidates, 3);
187  addTag(indetCandidate, *candidates.front(), tagMap, combTracks, segments);
188  }
189 
191  // keep track of candidates for which segments are found
192  CandidateVec refinedCandidates;
193 
194  // loop over candidates and redo segments using beta estimate from candidate
195  ATH_MSG_DEBUG("Refining candidates " << candidates.size());
196  for (auto& candidate : candidates) {
197  ATH_MSG_DEBUG(" candidate: betaseed beta" << candidate->betaSeed.beta << ", error" << candidate->betaSeed.error
198  << " layerDataVec size" << candidate->layerDataVec.size() << " hits size"
199  << candidate->hits.size());
200 
201  float beta = candidate->betaFitResult.beta;
202  // loop over layers and perform segment finding, collect segments per layer
203  for (const auto& layerData : candidate->layerDataVec) {
204  // store segments in layer
205  std::vector<std::shared_ptr<const Muon::MuonSegment>> segments;
206 
207  // loop over maxima
208  for (const auto& maximumData : layerData.maximumDataVec) {
209  // find segments for intersection
210  findSegments(layerData.intersection, *maximumData, segments, m_muonPRDSelectionToolStau, m_segmentMaker, beta);
211  }
212 
213  // skip if no segment were found
214  if (segments.empty()) continue;
215 
216  // fill validation content
217  if (!m_recoValidationTool.empty()) {
218  for (const auto& seg : segments) m_recoValidationTool->add(layerData.intersection, *seg, 2);
219  }
220 
221  // match segments to intersection, store the ones that match
222  std::vector<std::shared_ptr<const Muon::MuonSegment>> selectedSegments;
223  m_segmentMatchingTool->select(ctx, layerData.intersection, segments, selectedSegments);
224  // fill validation content
225  if (!m_recoValidationTool.empty()) {
226  for (const auto& seg : selectedSegments) m_recoValidationTool->add(layerData.intersection, *seg, 3);
227  }
228 
229  // add layer list
230  candidate->allLayers.emplace_back(layerData.intersection, std::move(selectedSegments));
231  }
232 
233  // keep candidate if any segments were found
234  if (!candidate->allLayers.empty()) refinedCandidates.push_back(candidate);
235  }
236 
237  // set candidates to the refinedCandidates
238  candidates = refinedCandidates;
239 
240  // print results afer refineCandidate
241  if (m_doSummary || msgLvl(MSG::DEBUG)) {
242  msg(MSG::INFO) << " Summary::refineCandidates ";
243  if (candidates.empty())
244  msg(MSG::INFO) << " No candidated found ";
245  else
246  msg(MSG::INFO) << " candidates " << candidates.size();
247 
248  for (const auto& candidate : candidates) {
249  msg(MSG::INFO) << std::endl
250  << " candidate: beta fit result: beta " << candidate->betaFitResult.beta << " chi2/ndof "
251  << candidate->betaFitResult.chi2PerDOF() << " layers with segments" << candidate->allLayers.size();
252  for (const auto& layer : candidate->allLayers)
253  msg(MSG::INFO) << std::endl
254  << " " << printIntersectionToString(layer.intersection) << " segments " << layer.segments.size();
255  }
256  msg(MSG::INFO) << endmsg;
257  }
258 
259  return !candidates.empty();
260  }
261 
263  Candidate& candidate) const {
264 
266  if (!mdtCalibConstants.isValid()) {
267  ATH_MSG_FATAL("Failed to retrieve calibration constants "<<m_calibDbKey.fullKey());
268  throw std::runtime_error("Failed to retrieve calibration constants");
269  }
270  ATH_MSG_VERBOSE("extractTimeMeasurementsFromTrack for candidate: beta seed " << candidate.betaSeed.beta);
271  Trk::Track* combinedTrack = candidate.combinedTrack.get();
272  if (!combinedTrack) return;
273 
274  // select around seed
275  float betaSeed = candidate.betaFitResult.beta;
276 
277  // fitter + hits
280 
281  // loop over track and calculate residuals
282  const Trk::TrackStates* states = combinedTrack->trackStateOnSurfaces();
283  if (!states) {
284  ATH_MSG_WARNING(" track without states, cannot extractTimeMeasurementsFromTrack ");
285  return;
286  }
287 
288  ATH_MSG_VERBOSE("Track : " << (*combinedTrack));
289 
290  // store RPC prds for clustering
291  typedef std::vector<const Muon::MuonClusterOnTrack*> RpcClVec;
292  using RpcClPerChMap = std::map<Identifier, std::tuple<const Trk::TrackParameters*, RpcClVec, RpcClVec>>;
293  RpcClPerChMap rpcPrdsPerChamber;
294 
295  using MdtTubeData = std::pair<const Trk::TrackParameters*, const Muon::MdtDriftCircleOnTrack*>;
296  using MdtTubeDataVec = std::vector<MdtTubeData>;
297  using MdtChamberLayerData = std::map<int, MdtTubeDataVec>;
298  MdtChamberLayerData mdtDataPerChamberLayer;
299 
300  // loop over TSOSs
302  Trk::TrackStates::const_iterator tsit_end = states->end();
303  for (; tsit != tsit_end; ++tsit) {
304  const Trk::TrackParameters* pars = (*tsit)->trackParameters();
305  if (!pars) continue;
306 
307  // check whether state is a measurement
308  const Trk::MeasurementBase* meas = (*tsit)->measurementOnTrack();
309  if (!meas || (*tsit)->type(Trk::TrackStateOnSurface::Outlier)) continue;
310 
311  // get Identifier and skip pseudo measurements, ID hits and all but MDT/RPC hits
312  Identifier id = m_edmHelperSvc->getIdentifier(*meas);
313  if (!id.is_valid() || !m_idHelperSvc->isMuon(id)) continue;
314 
315  // extract time measurements for RPCs
316  if (m_idHelperSvc->isMdt(id)) {
317  // MDTs
318  const Muon::MdtDriftCircleOnTrack* mdt = dynamic_cast<const Muon::MdtDriftCircleOnTrack*>(meas);
319  if (!mdt) continue;
320 
321  if (m_segmentMDTT) {
322  int chIndexWithBIR = toInt(m_idHelperSvc->chamberIndex(mdt->identify()));
323  if (chIndexWithBIR == toInt(ChIndex::BIL)) {
324  std::string stName = m_idHelperSvc->chamberNameString(id);
325  if (stName[2] == 'R') { chIndexWithBIR += 1000; }
326  }
327  mdtDataPerChamberLayer[chIndexWithBIR].push_back(std::make_pair(pars, mdt));
328  } else {
330  float distance = pars->position().mag();
331  float time = 0.;
332 
333  float ix = pars->position().x();
334  float iy = pars->position().y();
335  float iz = pars->position().z();
336  float ie = 0.;
337  float er = -1;
338  float sh = 0;
339  bool isEta = !m_idHelperSvc->measuresPhi(id);
340  float propTime = 0;
341  float tof = calculateTof(1, distance);
342 
343  // use inverted RT relation together with track prediction to get estimate of drift time
344  float driftTime = mdt->driftTime(); // we need to add beta seed as it was subtracted when calibrating the hits
345  float locR = pars->parameters()[Trk::locR];
346  float errR = pars->covariance() ? Amg::error(*pars->covariance(), Trk::locR) : 0.3;
347  auto data = mdtCalibConstants->getCalibData(id, msgStream());
348  const auto& rtRelation = data->rtRelation;
349  float drdt = rtRelation->rt()->driftVelocity(driftTime);
350  float rres = rtRelation->rtRes()->resolution(driftTime);
351  float tres = rres / drdt;
352  float TlocR = rtRelation->tr()->driftTime(std::abs(locR)).value_or(0.);
353  float trackTimeRes = errR / drdt;
354  float tofShiftFromBeta = calculateTof(betaSeed, distance) - tof;
355  er = std::sqrt(tres * tres + trackTimeRes * trackTimeRes);
356  mdtTimeCalibration(id, driftTime, er);
357  time = driftTime - TlocR + tofShiftFromBeta;
358  propTime = driftTime;
359  ie = trackTimeRes;
360  // try removal of hit from fit
361  if (!m_updator.empty()) {
362  std::unique_ptr<const Trk::TrackParameters> unbiasedPars(
363  m_updator->removeFromState(*pars, meas->localParameters(), meas->localCovariance()));
364  if (unbiasedPars) {
365  float locRu = unbiasedPars->parameters()[Trk::locR];
366  float TlocRu = rtRelation->tr()->driftTime(std::abs(locRu)).value_or(0.);
367  float errRu = unbiasedPars->covariance() ? Amg::error(*unbiasedPars->covariance(), Trk::locR) : 0.3;
368  float trackTimeResu = errRu / drdt;
369  sh = TlocR - TlocRu;
370  time = driftTime - TlocRu + tofShiftFromBeta;
371  er = std::sqrt(tres * tres + trackTimeResu * trackTimeResu);
372  ie = trackTimeResu;
373  ATH_MSG_VERBOSE(" Got unbiased parameters: r " << locR << " ur " << locRu << " err " << errR << " uerr "
374  << errRu << " terr " << trackTimeRes << " terru "
375  << trackTimeResu);
376  }
377  }
378 
379  ATH_MSG_VERBOSE(" MDT " << mdt->driftRadius() << " locR " << locR << " err " << errR << " drift time " << driftTime
380  << " TlocR " << TlocR << " diff " << driftTime - TlocR << " tofShift " << tofShiftFromBeta
381  << " time " << time << " err " << er << " intrinsic " << tres << " track " << trackTimeRes);
382 
383  float beta = calculateBeta(time + tof, distance);
384  ATH_MSG_VERBOSE(" adding " << m_idHelperSvc->toString(id) << " distance " << distance << " time " << time << " beta"
385  << beta << " diff " << std::abs(beta - betaSeed));
386  if (std::abs(beta - betaSeed) > m_mdttBetaAssociationCut) continue;
387 
388  hits.emplace_back(Muon::TimePointBetaFitter::Hit(distance, time, er));
389  candidate.stauHits.emplace_back(MuGirlNS::StauHit(tech, time + tof, ix, iy, iz, id, ie, er, sh, isEta, propTime));
390 
392  float iadc = mdt->prepRawData()->adc();
393  float irdrift = mdt->driftRadius();
394  candidate.stauMDTHitExtras.emplace_back(MuGirlNS::StauMDTHitExtra(iadc, irdrift));
395  }
396  }
397  } else if (m_idHelperSvc->isRpc(id)) {
398  // treat CompetingMuonClustersOnTrack differently than RpcClusterOnTrack
399  std::vector<const Muon::MuonClusterOnTrack*> clusters;
400  const Muon::CompetingMuonClustersOnTrack* crot = dynamic_cast<const Muon::CompetingMuonClustersOnTrack*>(meas);
401  if (crot) {
402  clusters = crot->containedROTs();
403  } else {
404  const Muon::RpcClusterOnTrack* rpc = dynamic_cast<const Muon::RpcClusterOnTrack*>(meas);
405  if (rpc) clusters.push_back(rpc);
406  }
407  Identifier chamberId = m_idHelperSvc->chamberId(id);
408  bool measuresPhi = m_idHelperSvc->measuresPhi(id);
409  auto pos = rpcPrdsPerChamber.find(chamberId);
410  if (pos == rpcPrdsPerChamber.end()) {
411  if (measuresPhi)
412  rpcPrdsPerChamber[chamberId] = std::make_tuple(pars, clusters, RpcClVec());
413  else
414  rpcPrdsPerChamber[chamberId] = std::make_tuple(pars, RpcClVec(), clusters);
415  } else {
416  RpcClVec& clVec = measuresPhi ? std::get<1>(pos->second) : std::get<2>(pos->second);
417  clVec.insert(clVec.end(), clusters.begin(), clusters.end());
418  }
419  } else if (m_idHelperSvc->isCsc(id)) {
420  const Muon::CscClusterOnTrack* csc = dynamic_cast<const Muon::CscClusterOnTrack*>(meas);
421 
423  float distance = pars->position().mag();
424  float time = csc->prepRawData()->time();
425 
426  float ix = pars->position().x();
427  float iy = pars->position().y();
428  float iz = pars->position().z();
429  float ie = 0.;
430  float er = -1;
431  float sh = 0;
432  bool isEta = !m_idHelperSvc->measuresPhi(id);
433  float propTime = 0;
434  float tof = calculateTof(1, distance);
435  candidate.stauHits.push_back(MuGirlNS::StauHit(tech, time + tof, ix, iy, iz, id, ie, er, sh, isEta, propTime));
436  }
437  }
438 
439  auto insertRpcs = [betaSeed, this](const Trk::TrackParameters& pars, const RpcClVec& clusters,
441  if (clusters.empty()) return;
442 
443  std::vector<const Muon::MuonClusterOnTrack*> calibratedClusters;
444  for (const auto* cluster : clusters) {
445  const Muon::MuonClusterOnTrack* cl = m_muonPRDSelectionTool->calibrateAndSelect(pars, *cluster->prepRawData());
446  if (cl) calibratedClusters.push_back(cl);
447  }
448  if (calibratedClusters.empty()) return;
449 
450  Muon::IMuonHitTimingTool::TimingResult result = m_hitTimingTool->calculateTimingResult(calibratedClusters);
451  for (const auto* cl : calibratedClusters) delete cl;
452  if (!result.valid) return;
453 
454  Identifier id = clusters.front()->identify();
455 
457  float distance = pars.position().mag();
458  float time = result.time;
459  float ix = pars.position().x();
460  float iy = pars.position().y();
461  float iz = pars.position().z();
462  float ie = 0.;
463  float er = result.error;
464  rpcTimeCalibration(id, time, er);
465  float sh = 0;
466  bool isEta = !m_idHelperSvc->measuresPhi(id);
467  if (isEta) tech = MuGirlNS::RPCETA_STAU_HIT;
468  float propTime = 0;
469  float tof = calculateTof(1, distance);
470  float beta = calculateBeta(time + tof, distance);
471  ATH_MSG_VERBOSE(" adding " << m_idHelperSvc->toString(id) << " distance " << distance << " time " << time << " beta" << beta
472  << " diff " << std::abs(beta - betaSeed));
473 
474  if (std::abs(beta - betaSeed) > m_mdttBetaAssociationCut) return;
475 
476  hits.push_back(Muon::TimePointBetaFitter::Hit(distance, time, er));
477  candidate.stauHits.push_back(MuGirlNS::StauHit(tech, time + tof, ix, iy, iz, id, ie, er, sh, isEta, propTime));
478  };
479 
480  // get RPC timing per chamber
481  RpcClPerChMap::const_iterator chit = rpcPrdsPerChamber.begin();
482  RpcClPerChMap::const_iterator chit_end = rpcPrdsPerChamber.end();
483  ATH_MSG_VERBOSE("RPCs per chamber " << rpcPrdsPerChamber.size());
484 
485  for (; chit != chit_end; ++chit) {
486  const Trk::TrackParameters* pars = std::get<0>(chit->second);
487  const RpcClVec& phiClusters = std::get<1>(chit->second);
488  const RpcClVec& etaClusters = std::get<2>(chit->second);
489  insertRpcs(*pars, phiClusters, candidate, hits);
490  insertRpcs(*pars, etaClusters, candidate, hits);
491  }
492 
493  // get timing per MDT chamber, use segment error strategy (errors of the RT relation
495  Muon::MuonDriftCircleErrorStrategy calibrationStrategy(bits);
498 
500  TrkDriftCircleMath::SegmentFinder segmentFinder;
501  segmentFinder.setMaxDropDepth(2);
502  segmentFinder.setChi2DropCut(5);
503  segmentFinder.setDeltaCut(3);
504 
505  MdtChamberLayerData::const_iterator mit = mdtDataPerChamberLayer.begin();
506  MdtChamberLayerData::const_iterator mit_end = mdtDataPerChamberLayer.end();
507  for (; mit != mit_end; ++mit) {
508  ATH_MSG_VERBOSE(" new station layer " << Muon::MuonStationIndex::chName((Muon::MuonStationIndex::ChIndex)(mit->first % 1000))
509  << " hits " << mit->second.size());
510  if (mit->second.size() < 4) continue;
511 
512  // get RE element for first hit
513  const MuonGM::MdtReadoutElement* detEl = mit->second.front().second->detectorElement();
514  const Trk::PlaneSurface* surf = dynamic_cast<const Trk::PlaneSurface*>(&detEl->surface());
515  if (!surf) {
516  ATH_MSG_WARNING("MdtReadoutElement should always have a PlaneSurface as reference surface");
517  continue;
518  }
519  Amg::Transform3D gToStation = detEl->GlobalToAmdbLRSTransform();
520 
521  // get TrackParameters and SL intersect the DetEl surface (above a few GeV SL intersection is accurate enough)
522  const Trk::TrackParameters& firstPars = *mit->second.front().first;
523  Trk::Intersection slIntersection = surf->straightLineIntersection(firstPars.position(), firstPars.momentum(), false, false);
524 
525  // calculate seed position and direction
526  Trk::LocalDirection seedLocDir;
527  surf->globalToLocalDirection(firstPars.momentum(), seedLocDir);
528  Amg::Vector3D seedLocPos = gToStation * slIntersection.position;
529  TrkDriftCircleMath::LocVec2D seedPos(seedLocPos.y(), seedLocPos.z());
530  TrkDriftCircleMath::Line seedLine(seedPos, seedLocDir.angleYZ());
532 
533  std::vector<std::pair<std::shared_ptr<const Muon::MdtDriftCircleOnTrack>, const Trk::TrackParameters*>> indexLookUp;
534  unsigned index = 0;
535  for (const auto& entry : mit->second) {
536  const Trk::TrackParameters& pars = *entry.first;
537  const Muon::MdtDriftCircleOnTrack& mdt = *entry.second;
538  Identifier id = mdt.identify();
539  // calibrate MDT
540  std::unique_ptr<const Muon::MdtDriftCircleOnTrack> calibratedMdt(
541  m_mdtCreatorStau->correct(*mdt.prepRawData(), pars, &calibrationStrategy, betaSeed));
542  if (!calibratedMdt) {
543  ATH_MSG_WARNING("Failed to recalibrate existing MDT on track " << m_idHelperSvc->toString(id));
544  continue;
545  }
546  ATH_MSG_VERBOSE(" recalibrated MDT " << m_idHelperSvc->toString(id) << " r " << calibratedMdt->driftRadius() << " "
547  << Amg::error(calibratedMdt->localCovariance(), Trk::locR) << " old r "
548  << mdt.driftRadius() << " " << Amg::error(mdt.localCovariance(), Trk::locR)
549  << " r_track " << pars.parameters()[Trk::locR] << " residual "
550  << std::abs(mdt.driftRadius()) - std::abs(pars.parameters()[Trk::locR]));
551 
552  // calculate tube position taking into account the second coordinate
553  Amg::Vector2D lp(0., pars.parameters()[Trk::locZ]);
554  Amg::Vector3D gpos;
555  mdt.associatedSurface().localToGlobal(lp, pars.momentum(), gpos);
556 
557  // calculate local AMDB position
558  Amg::Vector3D locPos = gToStation * gpos;
559  TrkDriftCircleMath::LocVec2D lpos(locPos.y(), locPos.z());
560 
561  double r = std::abs(calibratedMdt->driftRadius());
562  double dr = Amg::error(calibratedMdt->localCovariance(), Trk::locR);
563 
564  // create identifier
565  TrkDriftCircleMath::MdtId mdtid(m_idHelperSvc->mdtIdHelper().isBarrel(id), m_idHelperSvc->mdtIdHelper().multilayer(id) - 1,
566  m_idHelperSvc->mdtIdHelper().tubeLayer(id) - 1, m_idHelperSvc->mdtIdHelper().tube(id) - 1);
567 
568  // create new DriftCircle
570  TrkDriftCircleMath::DCOnTrack dcOnTrack(dc, 1., 1.);
571 
572  dcs.push_back(dcOnTrack);
573  indexLookUp.emplace_back(std::move(calibratedMdt), &pars);
574  ++index;
575  }
576 
577  // now loop over the hits and fit the segment taking out each of the hits individually
578  for (unsigned int i = 0; i < dcs.size(); ++i) {
580  selection[i] = 1;
582  if (!mdtFitter.fit(result, seedLine, dcs, selection)) {
583  ATH_MSG_DEBUG("Fit failed ");
584  continue;
585  }
587  segment.hitsOnTrack(dcs.size());
588  unsigned int ndofFit = segment.ndof();
589  if (ndofFit < 1) continue;
590  double chi2NdofSegmentFit = segment.chi2() / ndofFit;
591  bool hasDropHit = false;
592  unsigned int dropDepth = 0;
593  if (!segmentFinder.dropHits(segment, hasDropHit, dropDepth)) {
594  ATH_MSG_DEBUG("DropHits failed, fit chi2/ndof " << chi2NdofSegmentFit);
595  if (msgLvl(MSG::VERBOSE)) {
596  segmentFinder.debugLevel(20);
597  segment = result;
598  segmentFinder.dropHits(segment, hasDropHit, dropDepth);
599  segmentFinder.debugLevel(0);
600  }
601  continue;
602  }
603  if (i >= segment.dcs().size()) continue;
605  const TrkDriftCircleMath::DCOnTrack& dc = segment.dcs()[i];
606  double res = dc.residual();
607  double err = std::sqrt(dc.dr() * dc.dr() + dc.errorTrack() * dc.errorTrack());
608  double pull = res / err;
609  double rline = toLine.toLineY(dc.position());
610  int index = dc.index();
611  if (index < 0 || index >= (int)indexLookUp.size()) {
612  ATH_MSG_WARNING(" lookup of TrackParameters and MdtDriftCircleOnTrack failed " << index << " range: 0 - "
613  << indexLookUp.size() - 1);
614  continue;
615  }
616  const Trk::TrackParameters* pars = indexLookUp[dc.index()].second;
617  const Muon::MdtDriftCircleOnTrack* mdt = indexLookUp[dc.index()].first.get();
618  Identifier id = mdt->identify();
619 
620  // calibrate MDT with nominal timing
621  std::shared_ptr<const Muon::MdtDriftCircleOnTrack> calibratedMdt(
622  m_mdtCreator->correct(*mdt->prepRawData(), *pars, &calibrationStrategy, betaSeed));
623  if (!calibratedMdt.get()) {
624  ATH_MSG_WARNING("Failed to recalibrate existing MDT on track " << m_idHelperSvc->toString(id));
625  continue;
626  }
627  float distance = pars->position().mag();
628  float time = 0.;
629 
630  float ix = pars->position().x();
631  float iy = pars->position().y();
632  float iz = pars->position().z();
633  float ie = 0.;
634  float er = -1;
635  float sh = 0;
636  bool isEta = !m_idHelperSvc->measuresPhi(id);
637  float propTime = 0;
638  float tof = calculateTof(1, distance);
639 
640  float iadc = mdt->prepRawData()->adc();
641  float irdrift = mdt->driftRadius();
642 
643  // use inverted RT relation together with track prediction to get estimate of drift time
644  float driftTime = calibratedMdt->driftTime(); // we need to add beta seed as it was subtracted when calibrating the hits
645  float locR = rline;
646  float errR = dc.errorTrack();
647  auto data = mdtCalibConstants->getCalibData(id, msgStream());
648  const auto& rtRelation = data->rtRelation;
649  float drdt = rtRelation->rt()->driftVelocity(driftTime);
650  float rres = rtRelation->rtRes()->resolution(driftTime);
651  float tres = rres / drdt;
652  float TlocR = rtRelation->tr()->driftTime(std::abs(locR)).value_or(0.);
653  float trackTimeRes = errR / drdt;
654  float tofShiftFromBeta = 0.; // muonBetaCalculationUtils.calculateTof(betaSeed,distance)-tof;
655  er = std::sqrt(tres * tres + trackTimeRes * trackTimeRes);
656  mdtTimeCalibration(id, driftTime, er);
657  time = driftTime - TlocR + tofShiftFromBeta;
658  propTime = driftTime;
659  ie = trackTimeRes;
660 
661  const float beta = calculateBeta(time + tof, distance);
662  bool isSelected = std::abs(beta - betaSeed) < m_mdttBetaAssociationCut;
663 
664  if (msgLvl(MSG::DEBUG)) {
665  msg(MSG::DEBUG) << m_idHelperSvc->toString(id) << std::setprecision(2) << " segment: after fit " << std::setw(5)
666  << chi2NdofSegmentFit << " ndof " << std::setw(2) << ndofFit;
667  if (segment.ndof() != ndofFit)
668  msg(MSG::DEBUG) << " after outlier " << std::setw(5) << chi2NdofSegmentFit << " ndof " << std::setw(2) << ndofFit;
669  msg(MSG::DEBUG) << " driftR " << std::setw(4) << dc.r() << " rline " << std::setw(5) << rline << " residual "
670  << std::setw(5) << res << " pull " << std::setw(4) << pull << " time " << std::setw(3) << time
671  << " beta" << std::setw(2) << beta << " err " << std::setw(3) << er << " intrinsic " << std::setw(3)
672  << tres << " track " << std::setw(3) << trackTimeRes;
673  if (!isSelected) msg(MSG::DEBUG) << " outlier";
674  msg(MSG::DEBUG) << std::setprecision(5) << endmsg;
675  }
676 
677  if (!isSelected) continue;
678 
679  hits.emplace_back(distance, time, er);
680  candidate.stauHits.emplace_back(MuGirlNS::MDTT_STAU_HIT, time + tof, ix, iy, iz, id, ie, er, sh, isEta, propTime);
682  candidate.stauMDTHitExtras.emplace_back(MuGirlNS::StauMDTHitExtra(iadc, irdrift));
683  }
684  }
685  }
686  // fit data
687  Muon::TimePointBetaFitter::FitResult betaFitResult = fitter.fitWithOutlierLogic(hits);
688  ATH_MSG_DEBUG(" extractTimeMeasurementsFromTrack: extracted " << candidate.stauHits.size() << " time measurements "
689  << " status fit " << betaFitResult.status << " beta "
690  << betaFitResult.beta << " chi2/ndof " << betaFitResult.chi2PerDOF());
691 
692  candidate.finalBetaFitResult = betaFitResult;
693  }
694 
695  void MuonStauRecoTool::addTag(const InDetCandidate& indetCandidate,
696  MuonStauRecoTool::Candidate& candidate,
697  InDetCandidateToTagMap* tagMap,
698  TrackCollection* combTracks,
699  Trk::SegmentCollection* segments) const {
700  // get combined track and the segments
701  combTracks->push_back(candidate.combinedTrack.release());
702  ElementLink<TrackCollection> comblink(*combTracks, combTracks->size() - 1);
703  std::vector<ElementLink<Trk::SegmentCollection>> segmentLinks;
704  for (const auto& layer : candidate.allLayers) {
705  for (const auto& segment : layer.segments) {
706  segments->push_back(segment->clone());
707  ElementLink<Trk::SegmentCollection> segLink(*segments, segments->size() - 1);
708  segmentLinks.push_back(segLink);
709  }
710  }
711 
712  // create tag
714 
715  // add additional info
716  tag->setMuBeta(candidate.betaFitResult.beta);
717 
718  // add StauExtras
719  std::unique_ptr<MuGirlNS::StauExtras> stauExtras = std::make_unique<MuGirlNS::StauExtras>();
720  stauExtras->betaAll = candidate.betaFitResult.beta;
721  stauExtras->betaAllt = candidate.finalBetaFitResult.beta;
722  stauExtras->hits = candidate.stauHits;
723  // TODO: ALEXIS ADD FLAG
725  stauExtras->extraMDTHitInfo = candidate.stauMDTHitExtras;
726  }
727 
728  tag->setStauExtras(std::move(stauExtras));
729 
730  // print results afer refineCandidate
731  if (m_doSummary || msgLvl(MSG::DEBUG)) {
732  msg(MSG::INFO) << " Summary::addTag ";
733  msg(MSG::INFO) << std::endl
734  << " candidate: beta fit result: beta " << candidate.betaFitResult.beta << " chi2/ndof "
735  << candidate.betaFitResult.chi2PerDOF() << " segments" << segmentLinks.size();
736  for (const auto& segment : segmentLinks) msg(MSG::INFO) << std::endl << " " << m_printer->print(**segment);
737  if (*comblink)
738  msg(MSG::INFO) << std::endl
739  << " track " << m_printer->print(**comblink) << std::endl
740  << m_printer->printStations(**comblink);
741  msg(MSG::INFO) << endmsg;
742  }
743 
744  // add tag to IndetCandidate
745  tagMap->addEntry(&indetCandidate, tag);
746  }
747 
749  ATH_MSG_DEBUG("Resolving ambiguities: candidates " << candidates.size());
750 
751  // push tracks into a collection and run ambi-solver
753  std::map<const Trk::Track*, std::shared_ptr<Candidate>> trackCandidateLookup;
754  for (const auto& candidate : candidates) {
755  Trk::Track* track = candidate->combinedTrack.get();
756  if (track) {
757  tracks.push_back(track);
758  trackCandidateLookup[track] = candidate;
759  }
760  }
761 
762  // first handle easy cases of zero or one track
763  if (tracks.empty()) return false;
764  if (tracks.size() == 1) return true;
765 
766  // more than 1 track call ambiguity solver and select first track
767  std::unique_ptr<const TrackCollection> resolvedTracks(m_trackAmbibuityResolver->process(&tracks));
768  if (!resolvedTracks || resolvedTracks->empty()) {
769  ATH_MSG_WARNING("No track survived the ambiguity solving");
770  return false;
771  }
772  const Trk::Track* selectedTrack = resolvedTracks->front();
773 
774  // get candidate
775  auto pos = trackCandidateLookup.find(selectedTrack);
776  if (pos == trackCandidateLookup.end()) {
777  ATH_MSG_WARNING("candidate lookup failed, this should not happen");
778  return false;
779  }
780 
781  // remove all candidates that were not combined
782  std::shared_ptr<Candidate> candidate = pos->second;
783  candidates.clear();
784  candidates.push_back(candidate);
785 
786  // print results afer resolveAmbiguities
787  if (m_doSummary || msgLvl(MSG::DEBUG)) {
788  msg(MSG::INFO) << " Summary::resolveAmbiguities ";
789  msg(MSG::INFO) << std::endl
790  << " candidate: beta fit result: beta " << candidate->betaFitResult.beta << " chi2/ndof "
791  << candidate->betaFitResult.chi2PerDOF() << " layers with segments" << candidate->allLayers.size() << std::endl
792  << " track " << m_printer->print(*candidate->combinedTrack) << std::endl
793  << m_printer->printStations(*candidate->combinedTrack);
794  msg(MSG::INFO) << endmsg;
795  }
796 
797  return true;
798  }
799 
800  bool MuonStauRecoTool::combineCandidates(const EventContext& ctx, const xAOD::TrackParticle& indetTrackParticle,
802  // keep track of candidates that have a successfull fit
803  CandidateVec combinedCandidates;
804 
805  // loop over candidates and redo segments using beta estimate from candidate
806  ATH_MSG_DEBUG("Combining candidates " << candidates.size());
807  for (auto& candidate : candidates) {
808  // find best matching track
809  std::pair<std::unique_ptr<const Muon::MuonCandidate>, std::unique_ptr<Trk::Track>> result =
810  m_insideOutRecoTool->findBestCandidate(ctx, indetTrackParticle, candidate->allLayers);
811 
812  if (result.first && result.second) {
813  ATH_MSG_DEBUG(" combined track found " << std::endl
814  << m_printer->print(*result.second) << std::endl
815  << m_printer->printStations(*result.second));
816  // add segments and track pointer to the candidate
817  candidate->muonCandidate = std::move(result.first);
818  candidate->combinedTrack = std::move(result.second);
819 
820  // extract times form track
821  extractTimeMeasurementsFromTrack(ctx, *candidate);
822  combinedCandidates.push_back(candidate);
823  if (!m_recoValidationTool.empty()) m_recoValidationTool->addTimeMeasurements(indetTrackParticle, candidate->stauHits);
824  }
825  }
826 
827  // remove all candidates that were not combined
828  candidates = combinedCandidates;
829 
830  // print results afer combineCandidate
831  if (m_doSummary || msgLvl(MSG::DEBUG)) {
832  msg(MSG::INFO) << " Summary::combineCandidates ";
833  if (candidates.empty())
834  msg(MSG::INFO) << " No candidated found ";
835  else
836  msg(MSG::INFO) << " candidates " << candidates.size();
837 
838  for (const auto& candidate : candidates) {
839  msg(MSG::INFO) << std::endl
840  << " candidate: beta fit result: " << candidate->betaFitResult.beta << " chi2/ndof "
841  << candidate->betaFitResult.chi2PerDOF();
842  if (candidate->finalBetaFitResult.status != 0)
843  msg(MSG::INFO) << " MDTT beta fit result: " << candidate->finalBetaFitResult.beta << " chi2/ndof "
844  << candidate->finalBetaFitResult.chi2PerDOF();
845  msg(MSG::INFO) << " layers with segments" << candidate->allLayers.size() << std::endl
846  << " track " << m_printer->print(*candidate->combinedTrack) << std::endl
847  << m_printer->printStations(*candidate->combinedTrack);
848  }
849  msg(MSG::INFO) << endmsg;
850  }
851 
852  return !candidates.empty();
853  }
854 
856  CandidateVec& candidates) const {
857  // loop over layers and select seed maxima
858  MaximumDataVec seedMaximumDataVec;
859  LayerDataVec::const_iterator it = associatedData.layerData.begin();
860  LayerDataVec::const_iterator it_end = associatedData.layerData.end();
861  for (; it != it_end; ++it) {
862  // loop over maximumDataVec
863  for (const auto& maximumData : it->maximumDataVec) {
864  // add all maximumData that have a time measurement
865  if (!maximumData->betaSeeds.empty()) seedMaximumDataVec.push_back(maximumData);
866  }
867  }
868  ATH_MSG_DEBUG("Creating candidates from seeds " << seedMaximumDataVec.size());
869 
870  if (seedMaximumDataVec.empty()) {
871  if (m_doSummary || msgLvl(MSG::DEBUG)) msg(MSG::INFO) << " Summary::createCandidates, no seeds found " << endmsg;
872  return false;
873  }
874 
875  // sorting lambda for MaximumData seeds
876  auto SortMaximumDataVec = [](const std::shared_ptr<MaximumData>& max1, const std::shared_ptr<MaximumData>& max2) {
877  return max1->maximum->max < max2->maximum->max;
878  };
879  std::stable_sort(seedMaximumDataVec.begin(), seedMaximumDataVec.end(), SortMaximumDataVec);
880 
881  // loop over seeds and create candidates
883  std::set<const MaximumData*> usedMaximumData;
884  MaximumDataVec::iterator sit = seedMaximumDataVec.begin();
885  MaximumDataVec::iterator sit_end = seedMaximumDataVec.end();
886  for (; sit != sit_end; ++sit) {
887  // only use once
888  if (usedMaximumData.count(sit->get())) continue;
889  usedMaximumData.insert(sit->get());
890 
891  // create new candidates from the beta seeds of the maximum
892  CandidateVec newCandidates;
893  for (const auto& betaSeed : (*sit)->betaSeeds) { newCandidates.push_back(std::make_shared<Candidate>(betaSeed)); }
894  // extend the candidates
895  extendCandidates(newCandidates, usedMaximumData, associatedData.layerData.begin(), associatedData.layerData.end());
896 
897  // loop over the candidates and fit them
898  for (auto& newCandidate : newCandidates) {
899  // fit data
900  newCandidate->betaFitResult = fitter.fitWithOutlierLogic(newCandidate->hits);
901  ATH_MSG_DEBUG(" New candidate: time measurements "
902  << newCandidate->hits.size() << " status " << newCandidate->betaFitResult.status << " beta "
903  << newCandidate->betaFitResult.beta << " chi2/ndof " << newCandidate->betaFitResult.chi2PerDOF());
904  // if the fit was successfull add the candidate to the candidate vector
905  if (newCandidate->betaFitResult.status != 0) {
906  newCandidate->combinedTrack = nullptr; // no track exists at this stage
907  candidates.push_back(newCandidate);
908  }
909  }
910  }
911 
912  // print results afer createCandidate
913  if (m_doSummary || msgLvl(MSG::DEBUG)) {
914  msg(MSG::INFO) << " Summary::createCandidates ";
915  if (candidates.empty())
916  msg(MSG::INFO) << " No candidated found ";
917  else
918  msg(MSG::INFO) << " candidates " << candidates.size();
919 
920  for (const auto& candidate : candidates) {
921  msg(MSG::INFO) << std::endl
922  << " candidate: beta seed " << candidate->betaSeed.beta << " beta fit result: beta "
923  << candidate->betaFitResult.beta << " chi2/ndof " << candidate->betaFitResult.chi2PerDOF() << " layers "
924  << candidate->layerDataVec.size();
925  for (const auto& layerData : candidate->layerDataVec)
926  msg(MSG::INFO) << std::endl
927  << " " << printIntersectionToString(layerData.intersection) << " maximumDataVec "
928  << layerData.maximumDataVec.size();
929  }
930  msg(MSG::INFO) << endmsg;
931  }
932 
933  return !candidates.empty();
934  }
935 
936  void MuonStauRecoTool::extendCandidates(MuonStauRecoTool::CandidateVec& candidates, std::set<const MaximumData*>& usedMaximumData,
937  MuonStauRecoTool::LayerDataVec::const_iterator it,
938  MuonStauRecoTool::LayerDataVec::const_iterator it_end) const {
939  // get current layer and move forward the
940  const LayerData& layerData = *it;
941  ATH_MSG_DEBUG(" extendCandidates: " << printIntersectionToString(layerData.intersection) << " maxima "
942  << layerData.maximumDataVec.size());
943 
944  CandidateVec newCandidates; // store new candidates
945  for (auto& candidate : candidates) {
946  // keep track of how often we extend this candidate
947  unsigned int nextensions = 0;
948 
949  // copy content of the candidate for reference
950  LayerDataVec layerDataVec = candidate->layerDataVec;
951  Muon::TimePointBetaFitter::HitVec hits = candidate->hits;
952 
953  // loop over maximumDataVec of the layer
954  for (const auto& maximumData : layerData.maximumDataVec) {
955  // create new hit vector
956  Muon::TimePointBetaFitter::HitVec newhits; // create new hits vector and add the ones from the maximum
957  if (extractTimeHits(*maximumData, newhits, &candidate->betaSeed)) {
958  // decide which candidate to update, create a new candidate if a maximum was already selected in the layer
959  Candidate* theCandidate = nullptr;
960  if (nextensions == 0)
961  theCandidate = candidate.get();
962  else {
963  std::shared_ptr<Candidate> newCandidate = std::make_shared<Candidate>(candidate->betaSeed);
964  newCandidate->layerDataVec = layerDataVec;
965  newCandidate->hits = hits;
966  theCandidate = newCandidate.get();
967  newCandidates.emplace_back(std::move(newCandidate));
968  }
969 
970  // create a LayerData object to add to the selected candidate
971  LayerData newLayerData(layerData.intersection);
972  newLayerData.maximumDataVec.push_back(maximumData);
973 
974  // update the candidate
975  theCandidate->hits.insert(theCandidate->hits.end(), newhits.begin(), newhits.end());
976  theCandidate->layerDataVec.push_back(newLayerData);
977  usedMaximumData.insert(maximumData.get());
978 
979  ATH_MSG_DEBUG(" adding maximumData: candidate hits " << theCandidate->hits.size() << " LayerDataVec "
980  << theCandidate->layerDataVec.size() << " nextensions "
981  << nextensions);
982 
983  ++nextensions;
984  }
985  }
986  }
987  ATH_MSG_DEBUG(" extendCandidates done, new candidates " << newCandidates.size());
988 
989  // add the new candidates
990  candidates.insert(candidates.end(), newCandidates.begin(), newCandidates.end());
991 
992  // move to the next layer, if we haven't reached the last layer, continue recursion
993  ++it;
994  if (it != it_end) extendCandidates(candidates, usedMaximumData, it, it_end);
995  }
996 
997  bool MuonStauRecoTool::extractTimeMeasurements(const EventContext& ctx,
998  const Muon::MuonSystemExtension& muonSystemExtension,
999  AssociatedData& associatedData) const {
1000  // get layer intersections
1001  // find RPC time measurements and segments to seed the beta fit using t0 fitting
1002  for (const Muon::MuonSystemExtension::Intersection& iSect: muonSystemExtension.layerIntersections()) {
1003  // create layer data object and add maxima
1004  LayerData layerData{iSect};
1005  associateHoughMaxima(ctx, layerData);
1006 
1007  // skip layer of not maxima are associated
1008  if (layerData.maximumDataVec.empty()) continue;
1009 
1010  associatedData.layerData.push_back(layerData);
1011 
1012  // loop over associated maxima
1013  for (auto& maximum : layerData.maximumDataVec) {
1014  // extract RPC timing
1015  extractRpcTimingFromMaximum(iSect, *maximum);
1016 
1017  // find segments for intersection
1018  std::vector<std::shared_ptr<const Muon::MuonSegment>> t0fittedSegments;
1019  findSegments(iSect, *maximum, t0fittedSegments, m_muonPRDSelectionTool, m_segmentMakerT0Fit);
1020  if (t0fittedSegments.empty()) continue;
1021 
1022  // match segments to intersection, store the ones that match
1023  m_segmentMatchingTool->select(ctx, iSect, t0fittedSegments, maximum->t0fittedSegments);
1024 
1025  // get beta seeds for Maximum
1026  getBetaSeeds(*maximum);
1027  }
1028  }
1029 
1030  // print results afer extractTimeMeasurements
1031  if (m_doSummary || msgLvl(MSG::DEBUG)) {
1032  msg(MSG::INFO) << " Summary::extractTimeMeasurements ";
1033  if (associatedData.layerData.empty())
1034  msg(MSG::INFO) << " No layers associated ";
1035  else
1036  msg(MSG::INFO) << " Associated layers " << associatedData.layerData.size();
1037 
1038  for (const auto& layerData : associatedData.layerData) {
1039  unsigned int nmaxWithBeta = 0;
1040  for (const auto& maximumData : layerData.maximumDataVec) {
1041  if (!maximumData->betaSeeds.empty()) ++nmaxWithBeta;
1042  }
1043  msg(MSG::INFO) << std::endl
1044  << " layer " << printIntersectionToString(layerData.intersection) << " associated maxima "
1045  << layerData.maximumDataVec.size() << " maxima with beta seeds " << nmaxWithBeta;
1046  }
1047  msg(MSG::INFO) << endmsg;
1048  }
1049 
1050  // return false if no layers were associated
1051  return !associatedData.layerData.empty();
1052  }
1053 
1055  const BetaSeed* seed) const {
1056  unsigned int nstart = hits.size();
1057 
1058  auto addHit = [&](float distance, float time, float error, float cut) {
1059  if (seed) {
1060  float beta = calculateBeta(time + calculateTof(1, distance), distance);
1061  ATH_MSG_VERBOSE(" matching hit: distance " << distance << " time " << time << " beta" << beta << " diff "
1062  << std::abs(beta - seed->beta));
1063  if (std::abs(beta - seed->beta) > cut) return;
1064  } else {
1065  ATH_MSG_VERBOSE(" addHit: distance " << distance << " time " << time << " beta"
1066  << calculateBeta(time + calculateTof(1, distance), distance));
1067  }
1068  if (error != 0.) hits.emplace_back(distance, time, error);
1069  };
1070 
1071  // add rpc measurements
1072  for (const auto& rpc : maximumData.rpcTimeMeasurements) {
1073  float time = rpc.time;
1074  float error = rpc.error;
1075  rpcTimeCalibration(rpc.rpcClusters.front()->identify(), time, error);
1076  addHit(rpc.rpcClusters.front()->globalPosition().mag(), time, error, m_rpcBetaAssociationCut);
1077  }
1078 
1079  // add segment t0 fits
1080  // if not seeded take all segments
1081  if (!seed) {
1082  for (const auto& seg : maximumData.t0fittedSegments) {
1083  if (!seg->hasFittedT0()) continue;
1084  float time = seg->time();
1085  float error = seg->errorTime();
1086  Identifier id = m_edmHelperSvc->chamberId(*seg);
1087  segmentTimeCalibration(id, time, error);
1088  addHit(seg->globalPosition().mag(), time, error, m_segmentBetaAssociationCut);
1089  }
1090  } else {
1091  // pick the best match
1092  const Muon::MuonSegment* bestSegment = nullptr;
1093  float smallestResidual = FLT_MAX;
1094  for (const auto& seg : maximumData.t0fittedSegments) {
1095  if (!seg->hasFittedT0()) continue;
1096  float distance = seg->globalPosition().mag();
1097  float time = seg->time();
1098  float beta = calculateBeta(time + calculateTof(1, distance), distance);
1099  float residual = std::abs(beta - seed->beta);
1100 
1101  if (residual < smallestResidual) {
1102  smallestResidual = residual;
1103  bestSegment = seg.get();
1104  }
1105  }
1106  if (bestSegment) {
1107  addHit(bestSegment->globalPosition().mag(), bestSegment->time(), bestSegment->errorTime(), m_segmentBetaAssociationCut);
1108  ATH_MSG_VERBOSE(" adding best segment: " << m_printer->print(*bestSegment));
1109  }
1110  }
1111  ATH_MSG_VERBOSE(" extractTimeHits done: added " << hits.size() - nstart << " hits");
1112 
1113  return nstart != hits.size();
1114  }
1115 
1116  void MuonStauRecoTool::getBetaSeeds(MaximumData& maximumData) const {
1117  // skip maximumData if no timing information is available
1118  if (maximumData.rpcTimeMeasurements.empty() && maximumData.t0fittedSegments.empty()) return;
1119 
1120  // fitter + hits
1123  extractTimeHits(maximumData, hits);
1124 
1125  Muon::TimePointBetaFitter::FitResult result = fitter.fitWithOutlierLogic(hits);
1126  float chi2ndof = result.chi2PerDOF();
1127 
1128  ATH_MSG_DEBUG(" fitting beta for maximum: time measurements " << hits.size() << " status " << result.status << " beta "
1129  << result.beta << " chi2/ndof " << chi2ndof);
1130  if (result.status != 0) maximumData.betaSeeds.emplace_back(result.beta, 1.);
1131  }
1132 
1134  std::vector<std::shared_ptr<const Muon::MuonSegment>>& segments,
1135  const ToolHandle<Muon::IMuonPRDSelectionTool>& muonPRDSelectionTool,
1136  const ToolHandle<Muon::IMuonSegmentMaker>& segmentMaker,
1137  float beta) const {
1138  const MuonHough::MuonLayerHough::Maximum& maximum = *maximumData.maximum;
1139  const std::vector<std::shared_ptr<const Muon::MuonClusterOnTrack>>& phiClusterOnTracks = maximumData.phiClusterOnTracks;
1140 
1141  // lambda to handle calibration and selection of MDTs
1142  auto handleMdt = [intersection, muonPRDSelectionTool](const Muon::MdtPrepData& prd,
1143  std::vector<const Muon::MdtDriftCircleOnTrack*>& mdts,
1144  float beta) {
1145  const Muon::MdtDriftCircleOnTrack* mdt = muonPRDSelectionTool->calibrateAndSelect(intersection, prd, beta);
1146  if (mdt) mdts.push_back(mdt);
1147  };
1148 
1149  // lambda to handle calibration and selection of clusters
1150  auto handleCluster = [intersection, muonPRDSelectionTool](const Muon::MuonCluster& prd,
1151  std::vector<const Muon::MuonClusterOnTrack*>& clusters) {
1152  const Muon::MuonClusterOnTrack* cluster = muonPRDSelectionTool->calibrateAndSelect(intersection, prd);
1153  if (cluster) clusters.push_back(cluster);
1154  };
1155 
1156  // loop over hits in maximum and add them to the hit list
1157  std::vector<const Muon::MdtDriftCircleOnTrack*> mdts;
1158  std::vector<const Muon::MuonClusterOnTrack*> clusters;
1159 
1160  // insert phi hits, clone them
1161  clusters.reserve(phiClusterOnTracks.size());
1162 
1163  for (const auto& phiClusterOnTrack : phiClusterOnTracks) { clusters.push_back(phiClusterOnTrack->clone()); }
1164 
1165  ATH_MSG_DEBUG("About to loop over Hough::Hits");
1166 
1167  MuonHough::HitVec::const_iterator hit = maximum.hits.begin();
1168  MuonHough::HitVec::const_iterator hit_end = maximum.hits.end();
1169  for (; hit != hit_end; ++hit) {
1170  ATH_MSG_DEBUG("hit x,y_min,y_max,w = " << (*hit)->x << "," << (*hit)->ymin << "," << (*hit)->ymax << "," << (*hit)->w);
1171  // treat the case that the hit is a composite TGC hit
1172  if ((*hit)->tgc) {
1173  for (const auto& prd : (*hit)->tgc->etaCluster) handleCluster(*prd, clusters);
1174  } else if ((*hit)->prd) {
1175  Identifier id = (*hit)->prd->identify();
1176  if (m_idHelperSvc->isMdt(id))
1177  handleMdt(static_cast<const Muon::MdtPrepData&>(*(*hit)->prd), mdts, beta);
1178  else
1179  handleCluster(static_cast<const Muon::MuonCluster&>(*(*hit)->prd), clusters);
1180  }
1181  }
1182 
1183  ATH_MSG_DEBUG("About to loop over calibrated hits");
1184 
1185  ATH_MSG_DEBUG("Dumping MDTs");
1186  for (const auto* it : mdts) ATH_MSG_DEBUG(*it);
1187 
1188  ATH_MSG_DEBUG("Dumping clusters");
1189  for (const auto* it : clusters) ATH_MSG_DEBUG(*it);
1190 
1191  // require at least 2 MDT hits
1192  if (mdts.size() > 2) {
1193  // run segment finder
1194  auto segColl = std::make_unique<Trk::SegmentCollection>(SG::VIEW_ELEMENTS);
1195  segmentMaker->find(intersection.trackParameters->position(), intersection.trackParameters->momentum(), mdts, clusters,
1196  !clusters.empty(), segColl.get(), intersection.trackParameters->momentum().mag(), 0, beta);
1197  if (segColl) {
1198  Trk::SegmentCollection::iterator sit = segColl->begin();
1199  Trk::SegmentCollection::iterator sit_end = segColl->end();
1200  for (; sit != sit_end; ++sit) {
1201  Trk::Segment* tseg = *sit;
1202  Muon::MuonSegment* mseg = static_cast<Muon::MuonSegment*>(tseg);
1203  assert(dynamic_cast<Muon::MuonSegment*>(tseg) != nullptr);
1204  ATH_MSG_DEBUG("Segment: " << m_printer->print(*mseg));
1205  segments.push_back(std::shared_ptr<const Muon::MuonSegment>(mseg));
1206  }
1207  }
1208  }
1209  // clean-up memory
1210  for (const auto* hit : mdts) delete hit;
1211  for (const auto* hit : clusters) delete hit;
1212  }
1213 
1215  MaximumData& maximumData) const {
1216  // extract trigger hits per chamber
1217  const MuonHough::MuonLayerHough::Maximum& maximum = *maximumData.maximum;
1218  std::map<Identifier, std::vector<const Muon::RpcPrepData*>> rpcPrdsPerChamber;
1219 
1220  // lambda to add the PRD
1221  auto addRpc = [&rpcPrdsPerChamber, this](const Trk::PrepRawData* prd) {
1222  const Muon::RpcPrepData* rpcPrd = dynamic_cast<const Muon::RpcPrepData*>(prd);
1223  if (rpcPrd) {
1224  Identifier chamberId = m_idHelperSvc->chamberId(rpcPrd->identify());
1225  rpcPrdsPerChamber[chamberId].push_back(rpcPrd);
1226  }
1227  };
1228 
1229  // extract eta hits
1230  MuonHough::HitVec::const_iterator hit = maximum.hits.begin();
1231  MuonHough::HitVec::const_iterator hit_end = maximum.hits.end();
1232  for (; hit != hit_end; ++hit) {
1233  if ((*hit)->tgc || !(*hit)->prd || !m_idHelperSvc->isRpc((*hit)->prd->identify())) continue;
1234  addRpc((*hit)->prd);
1235  }
1236 
1237  // extract phi hits
1238  for (const auto& rot : maximumData.phiClusterOnTracks) { addRpc(rot->prepRawData()); }
1239 
1240  // exit if no hits are found
1241  if (rpcPrdsPerChamber.empty()) return;
1242 
1243  std::map<Identifier, std::vector<const Muon::RpcPrepData*>>::iterator chit = rpcPrdsPerChamber.begin();
1244  std::map<Identifier, std::vector<const Muon::RpcPrepData*>>::iterator chit_end = rpcPrdsPerChamber.end();
1245  for (; chit != chit_end; ++chit) {
1246  // cluster hits
1247  Muon::RpcHitClusteringObj clustering(&m_idHelperSvc->rpcIdHelper());
1248  if (!clustering.cluster(chit->second)) {
1249  ATH_MSG_WARNING("Clustering failed");
1250  return;
1251  }
1252 
1253  ATH_MSG_DEBUG(" " << m_idHelperSvc->toStringChamber(chit->first) << " clustered RPCs: " << chit->second.size()
1254  << " eta clusters " << clustering.clustersEta.size() << " phi clusters " << clustering.clustersPhi.size());
1257  }
1258  }
1259 
1261  const std::vector<Muon::RpcClusterObj>& clusterObjects,
1262  MuonStauRecoTool::RpcTimeMeasurementVec& rpcTimeMeasurements) const {
1263  // loop over the clusters
1264  for (const auto& cluster : clusterObjects) {
1265  if (cluster.hitList.empty() || !cluster.hitList.front()) {
1266  ATH_MSG_WARNING("Cluster without hits: " << cluster.hitList.size());
1267  continue;
1268  }
1269  ATH_MSG_DEBUG(" new cluster: " << m_idHelperSvc->toString(cluster.hitList.front()->identify()) << " size "
1270  << cluster.hitList.size());
1271 
1272  // create the ROTs
1273  std::vector<const Muon::MuonClusterOnTrack*> clusters;
1274  for (const auto* rpc : cluster.hitList) {
1275  const Muon::MuonClusterOnTrack* rot(m_muonPRDSelectionTool->calibrateAndSelect(intersection, *rpc));
1276  if (rot) {
1277  clusters.push_back(rot);
1278  ATH_MSG_DEBUG(" strip " << m_idHelperSvc->toString(rot->identify()) << " time "
1279  << static_cast<const Muon::RpcClusterOnTrack*>(rot)->time());
1280  }
1281  }
1282  // get the timing result for the cluster
1284  if (result.valid) {
1285  // add the result
1286  RpcTimeMeasurement rpcTimeMeasurement;
1287  rpcTimeMeasurement.time = result.time;
1288  rpcTimeMeasurement.error = result.error;
1289  for (const auto* cl : clusters) {
1290  const Muon::RpcClusterOnTrack* rcl = dynamic_cast<const Muon::RpcClusterOnTrack*>(cl);
1291  if (rcl) rpcTimeMeasurement.rpcClusters.push_back(std::shared_ptr<const Muon::RpcClusterOnTrack>(rcl));
1292  }
1293  rpcTimeMeasurements.push_back(rpcTimeMeasurement);
1294  } else {
1295  // if no time measurement was created we need to clean up the memory
1296  for (const auto* cl : clusters) delete cl;
1297  }
1298  }
1299  }
1300 
1301  void MuonStauRecoTool::associateHoughMaxima(const EventContext& ctx,
1302  MuonStauRecoTool::LayerData& layerData) const {
1303 
1304  if (m_houghDataPerSectorVecKey.empty()) return;
1305  // get intersection and layer identifiers
1307  int sector = intersection.layerSurface.sector;
1308  Muon::MuonStationIndex::DetectorRegionIndex regionIndex = intersection.layerSurface.regionIndex;
1309  Muon::MuonStationIndex::LayerIndex layerIndex = intersection.layerSurface.layerIndex;
1310 
1311  // get hough data
1312  SG::ReadHandle houghDataPerSectorVec{m_houghDataPerSectorVecKey,ctx};
1313  if (!houghDataPerSectorVec.isValid()) {
1314  ATH_MSG_ERROR("Hough data per sector vector not found");
1315  return;
1316  }
1317 
1318  // sanity check
1319  if (static_cast<int>(houghDataPerSectorVec->vec.size()) <= sector - 1) {
1320  ATH_MSG_WARNING(" sector " << sector
1321  << " larger than the available sectors in the Hough tool: " << houghDataPerSectorVec->vec.size());
1322  return;
1323  }
1324 
1325  // get hough maxima in the layer
1326  unsigned int layHash = Muon::MuonStationIndex::sectorLayerHash(regionIndex, layerIndex);
1327  const Muon::MuonLayerHoughTool::HoughDataPerSector& houghDataPerSector = houghDataPerSectorVec->vec[sector - 1];
1328 
1329  // sanity check
1330  if (houghDataPerSector.maxVec.size() <= layHash) {
1331  ATH_MSG_WARNING(" houghDataPerSector.maxVec.size() smaller than hash " << houghDataPerSector.maxVec.size() << " hash "
1332  << layHash);
1333  return;
1334  }
1335  const Muon::MuonLayerHoughTool::MaximumVec& maxVec = houghDataPerSector.maxVec[layHash];
1336  if (maxVec.empty()) return;
1337 
1338  // get local coordinates in the layer frame
1339  bool barrelLike = intersection.layerSurface.regionIndex == DetectorRegionIndex::Barrel;
1340 
1341  // in the endcaps take the r in the sector frame from the local position of the extrapolation
1342  float phi = intersection.trackParameters->position().phi();
1343  float r = barrelLike ? m_muonSectorMapping.transformRToSector(intersection.trackParameters->position().perp(), phi,
1344  intersection.layerSurface.sector, true)
1345  : intersection.trackParameters->parameters()[Trk::locX];
1346 
1347  float z = intersection.trackParameters->position().z();
1348  float errx = intersection.trackParameters->covariance() ?
1349  Amg::error(*intersection.trackParameters->covariance(), Trk::locX) : 0.;
1350  float x = barrelLike ? z : r;
1351  float y = barrelLike ? r : z;
1352  float theta = std::atan2(y, x);
1353 
1354  // get phi hits
1355  const Muon::MuonLayerHoughTool::PhiMaximumVec& phiMaxVec = houghDataPerSector.phiMaxVec[toInt(regionIndex)];
1356  ATH_MSG_DEBUG(" Got Phi Hough maxima " << phiMaxVec.size() << " phi " << phi);
1357 
1358  // lambda to handle calibration and selection of clusters
1359  auto handleCluster = [intersection, this](const Muon::MuonCluster& prd,
1360  std::vector<std::shared_ptr<const Muon::MuonClusterOnTrack>>& clusters) {
1361  std::unique_ptr<const Muon::MuonClusterOnTrack> cluster{m_muonPRDSelectionTool->calibrateAndSelect(intersection, prd)};
1362  if (cluster) clusters.push_back(std::move(cluster));
1363  };
1364 
1365  // loop over maxima and associate phi hits with the extrapolation, should optimize this but calculating the residual with the phi
1366  // maximum
1367  std::vector<std::shared_ptr<const Muon::MuonClusterOnTrack>> phiClusterOnTracks;
1368  Muon::MuonLayerHoughTool::PhiMaximumVec::const_iterator pit = phiMaxVec.begin();
1369  Muon::MuonLayerHoughTool::PhiMaximumVec::const_iterator pit_end = phiMaxVec.end();
1370  for (; pit != pit_end; ++pit) {
1371  const MuonHough::MuonPhiLayerHough::Maximum& maximum = **pit;
1372  for (const std::shared_ptr<MuonHough::PhiHit>& hit : maximum.hits) {
1373  // treat the case that the hit is a composite TGC hit
1374  if (hit->tgc) {
1375  Identifier id = hit->tgc->phiCluster.front()->identify();
1376  if (m_idHelperSvc->layerIndex(id) != intersection.layerSurface.layerIndex) continue;
1377  for (const Muon::MuonCluster* prd : hit->tgc->phiCluster) handleCluster(*prd, phiClusterOnTracks);
1378  } else if (hit->prd && !(hit->prd->type(Trk::PrepRawDataType::sTgcPrepData) ||
1380  const Identifier id = hit->prd->identify();
1381  if (m_idHelperSvc->layerIndex(id) != intersection.layerSurface.layerIndex) continue;
1382  handleCluster(static_cast<const Muon::MuonCluster&>(*hit->prd), phiClusterOnTracks);
1383  }
1384  }
1385  }
1386 
1387  ATH_MSG_DEBUG(" associateHoughMaxima: " << printIntersectionToString(intersection) << " maxima " << maxVec.size() << " x,y=(" << x
1388  << "," << y << ") errorx " << errx << " "
1389  << " angle " << theta);
1390 
1391  // loop over maxima and associate them to the extrapolation
1392  for (const auto& mit : maxVec) {
1393  const MuonHough::MuonLayerHough::Maximum& maximum = *mit;
1394  if (std::find_if(maximum.hits.begin(),maximum.hits.end(),
1395  [](const std::shared_ptr<MuonHough::Hit>& hit){
1396  return hit->prd && (hit->prd->type(Trk::PrepRawDataType::sTgcPrepData) ||
1397  hit->prd->type(Trk::PrepRawDataType::MMPrepData));
1398  }) != maximum.hits.end()) continue;
1399  float residual = maximum.pos - x;
1400  float residualTheta = maximum.theta - theta;
1401  float refPos = (maximum.hough != nullptr) ? maximum.hough->m_descriptor.referencePosition : 0;
1402  float maxwidth = (maximum.binposmax - maximum.binposmin);
1403 
1404  if (maximum.hough){
1405  maxwidth *= maximum.hough->m_binsize;
1406  }
1407  const float pullUncert = std::sqrt(errx * errx + maxwidth * maxwidth / 12.);
1408  float pull = residual / (pullUncert > std::numeric_limits<float>::epsilon() ? pullUncert : 1.) ;
1409 
1410  ATH_MSG_DEBUG(" Hough maximum " << maximum.max << " position (" << refPos << "," << maximum.pos << ") residual " << residual
1411  << " pull " << pull << " angle " << maximum.theta << " residual " << residualTheta);
1412 
1413  // fill validation content
1414 
1415  // select maximum and add it to LayerData
1416  if (std::abs(pull) > 5) continue;
1417  layerData.maximumDataVec.emplace_back(std::make_shared<MaximumData>(intersection, &maximum, phiClusterOnTracks));
1418  }
1419  }
1420  void MuonStauRecoTool::mdtTimeCalibration(const Identifier& /*id*/, float& time, float& error) const {
1421  time -= 1.5;
1422  error *= 1.;
1423  }
1424  void MuonStauRecoTool::rpcTimeCalibration(const Identifier& /*id*/, float& time, float& error) const {
1425  time -= 0;
1426  error *= 0.5;
1427  }
1428  void MuonStauRecoTool::segmentTimeCalibration(const Identifier& /*id*/, float& time, float& error) const {
1429  time -= 1.5;
1430  error *= 1.;
1431  }
1433  float MuonStauRecoTool::calculateTof(const float beta, const float dist) const {
1434  return std::abs(beta) > 0 ? dist * inverseSpeedOfLight / beta : 1.e12;
1435  }
1438  float MuonStauRecoTool::calculateBeta(const float time, const float dist) const {
1439  return time != 0. ? dist * inverseSpeedOfLight / time : 20.;
1440  }
1442  const MuonStauRecoTool::CandidateVec& candidates, int stage) const {
1444  ATH_MSG_WARNING("You are calling the non thread-safe MuonRecoValidationTool with multiple threads, will most likely crash");
1445  }
1446  if (m_recoValidationTool.empty()) return;
1447 
1448  ATH_MSG_DEBUG("add candidates to ntuple, stage " << stage);
1449  for (const auto& candidate : candidates) {
1450  int ntimes = 0;
1451  float beta = -1.;
1452  float chi2ndof = -1.;
1453  if (candidate->finalBetaFitResult.status != 0) {
1454  ntimes = candidate->stauHits.size();
1455  beta = candidate->finalBetaFitResult.beta;
1456  chi2ndof = candidate->finalBetaFitResult.chi2PerDOF();
1457  } else if (candidate->betaFitResult.status != 0) {
1458  ntimes = candidate->hits.size();
1459  beta = candidate->betaFitResult.beta;
1460  chi2ndof = candidate->betaFitResult.chi2PerDOF();
1461  } else {
1462  ntimes = 1;
1463  beta = candidate->betaSeed.beta;
1464  chi2ndof = 0;
1465  }
1466  if (candidate->combinedTrack) ATH_MSG_DEBUG("candidate has combined track");
1467  m_recoValidationTool->addMuonCandidate(indetTrackParticle, candidate->muonCandidate.get(), candidate->combinedTrack.get(),
1468  ntimes, beta, chi2ndof, stage);
1469  }
1470  }
1471 
1472 } // namespace MuonCombined
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
Muon::RpcHitClusteringObj::clustersPhi
std::vector< RpcClusterObj > clustersPhi
Definition: RpcHitClustering.h:117
Muon::MuonStationIndex::LayerIndex
LayerIndex
enum to classify the different layers in the muon spectrometer
Definition: MuonStationIndex.h:38
Trk::SpaceTimePointBase::errorTime
float errorTime() const
access to the error on the measured time
Definition: SpaceTimePointBase.h:50
xAOD::TrackParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: TrackParticle_v1.cxx:74
make_hlt_rep.pars
pars
Definition: make_hlt_rep.py:90
MuonCombined::MuonStauRecoTool::m_muonPRDSelectionToolStau
ToolHandle< Muon::IMuonPRDSelectionTool > m_muonPRDSelectionToolStau
Definition: MuonStauRecoTool.h:247
beamspotman.r
def r
Definition: beamspotman.py:674
LArSamples::FitterData::fitter
const ShapeFitter * fitter
Definition: ShapeFitter.cxx:23
Muon::MuonDriftCircleErrorStrategy
Definition: MuonDriftCircleErrorStrategy.h:15
data
char data[hepevt_bytes_allocation_ATLAS]
Definition: HepEvt.cxx:11
MuonCombined::MuonStauRecoTool::Candidate
Definition: MuonStauRecoTool.h:98
MuonDriftCircleErrorStrategy.h
MuonCombined::InDetCandidate::getExtension
const Muon::MuonSystemExtension * getExtension() const
Definition: InDetCandidate.cxx:46
MuonCombined::MuonStauRecoTool::extractTimeHits
bool extractTimeHits(const MaximumData &maximumData, Muon::TimePointBetaFitter::HitVec &hits, const BetaSeed *seed=0) const
extract hits for the beta fit, returns true if hits were added
Definition: MuonStauRecoTool.cxx:1054
Muon::TimePointBetaFitter::Hit
simple struct holding the input to the fit
Definition: TimePointBetaFitter.h:18
MuonCombined::MuonStauRecoTool::extractTimeMeasurementsFromTrack
void extractTimeMeasurementsFromTrack(const EventContext &ctx, Candidate &candidate) const
extract time measurements from the track associated with the candidate
Definition: MuonStauRecoTool.cxx:262
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
BIL
@ BIL
Definition: RegSelEnums.h:10
MuonCombined::MuonStauRecoTool::Candidate::layerDataVec
LayerDataVec layerDataVec
Definition: MuonStauRecoTool.h:105
Trk::Intersection
Definition: Intersection.h:24
TrkDriftCircleMath::DriftCircle::index
unsigned int index() const
Definition: DriftCircle.h:99
TRTCalib_Extractor.hits
hits
Definition: TRTCalib_Extractor.py:35
get_generator_info.result
result
Definition: get_generator_info.py:21
TrkDriftCircleMath::DCOnTrackVec
std::vector< DCOnTrack > DCOnTrackVec
Definition: DCOnTrack.h:59
MuonCombined::MuonStauRecoTool::MaximumDataVec
std::vector< std::shared_ptr< MaximumData > > MaximumDataVec
Definition: MuonStauRecoTool.h:85
TileDCSDataPlotter.max1
max1
Definition: TileDCSDataPlotter.py:886
python.FPGATrackSimAnalysisConfig.stage
stage
Definition: FPGATrackSimAnalysisConfig.py:898
MuonCombined::MuonStauRecoTool::m_printer
PublicToolHandle< Muon::MuonEDMPrinterTool > m_printer
Definition: MuonStauRecoTool.h:235
MuGirlNS::StauExtras::betaAll
double betaAll
Definition: CandidateSummary.h:86
MuonCombined::MuonStauRecoTool::m_calibDbKey
SG::ReadCondHandleKey< MuonCalib::MdtCalibDataContainer > m_calibDbKey
Definition: MuonStauRecoTool.h:255
TrkDriftCircleMath::SegmentFinder::setChi2DropCut
void setChi2DropCut(double chi2)
Definition: SegmentFinder.cxx:79
Trk::PrepRawDataType::MMPrepData
@ MMPrepData
MuonCombined::MuonStauRecoTool::addCandidatesToNtuple
void addCandidatesToNtuple(const xAOD::TrackParticle &indetTrackParticle, const CandidateVec &candidates, int stage) const
helper function to add Candidate to ntuple
Definition: MuonStauRecoTool.cxx:1441
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
Muon::MdtDriftCircleOnTrack::prepRawData
virtual const MdtPrepData * prepRawData() const override final
Returns the PrepRawData used to create this corrected measurement.
Definition: MdtDriftCircleOnTrack.h:257
Trk::locX
@ locX
Definition: ParamDefs.h:37
MuGirlNS::StauHitTechnology
StauHitTechnology
Definition: CandidateSummary.h:27
TrkDriftCircleMath::MdtId
Definition: MdtId.h:14
Muon::HoughDataPerSec::phiMaxVec
RegionPhiMaximumVec phiMaxVec
Definition: HoughDataPerSec.h:55
MuonCombined::MuonStauRecoTool::m_rpcBetaAssociationCut
Gaudi::Property< double > m_rpcBetaAssociationCut
Definition: MuonStauRecoTool.h:269
Trk::Track
The ATLAS Track class.
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/Track.h:73
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
SegmentFinder.h
MuonHough::MuonLayerHough::m_binsize
float m_binsize
Definition: MuonLayerHough.h:176
MuonCombined::MuonStauRecoTool::m_ptThreshold
Gaudi::Property< double > m_ptThreshold
Definition: MuonStauRecoTool.h:266
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
ClusterSeg::residual
@ residual
Definition: ClusterNtuple.h:20
MuonCombined::MuonStauRecoTool::m_houghDataPerSectorVecKey
SG::ReadHandleKey< Muon::HoughDataPerSectorVec > m_houghDataPerSectorVecKey
storegate
Definition: MuonStauRecoTool.h:228
TrkDriftCircleMath::DCSLFitter::fit
virtual bool fit(Segment &result, const Line &line, const DCOnTrackVec &dcs, double t0Seed=-99999.) const
Definition: Tracking/TrkUtilityPackages/TrkDriftCircleMath/TrkDriftCircleMath/DCSLFitter.h:38
MuonCombined::MuonStauRecoTool::m_doTruth
Gaudi::Property< bool > m_doTruth
Definition: MuonStauRecoTool.h:262
MuonCombined::InDetCandidateToTagMap
Definition: InDetCandidateToTagMap.h:15
Trk::ParametersBase::position
const Amg::Vector3D & position() const
Access method for the position.
Amg::Vector2D
Eigen::Matrix< double, 2, 1 > Vector2D
Definition: GeoPrimitives.h:48
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
index
Definition: index.py:1
drawFromPickle.candidates
candidates
Definition: drawFromPickle.py:271
xAOD::TrackParticle_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition: TrackParticle_v1.cxx:78
MuonCombined::MuonStauRecoTool::m_recoValidationTool
ToolHandle< Muon::IMuonRecoValidationTool > m_recoValidationTool
Definition: MuonStauRecoTool.h:242
MuonCombined::MuonStauRecoTool::m_updator
ToolHandle< Trk::IUpdator > m_updator
Definition: MuonStauRecoTool.h:254
MuonCombined::MuonStauRecoTool::CandidateVec
std::vector< std::shared_ptr< Candidate > > CandidateVec
Definition: MuonStauRecoTool.h:119
MuonCombined::MuonStauRecoTool::m_hitTimingTool
ToolHandle< Muon::IMuonHitTimingTool > m_hitTimingTool
Definition: MuonStauRecoTool.h:245
MuonCombined::MuonStauRecoTool::MaximumData::phiClusterOnTracks
std::vector< std::shared_ptr< const Muon::MuonClusterOnTrack > > phiClusterOnTracks
Definition: MuonStauRecoTool.h:79
MuonHough::MuonLayerHough::m_descriptor
RegionDescriptor m_descriptor
Definition: MuonLayerHough.h:187
TruthParticleContainer.h
Muon::MuonStationIndex::sectorLayerHash
unsigned int sectorLayerHash(DetectorRegionIndex detectorRegionIndex, LayerIndex layerIndex)
create a hash out of region and layer
EventPrimitivesHelpers.h
MuonCombined::MuonStauRecoTool::RpcTimeMeasurement
Definition: MuonStauRecoTool.h:65
TrkDriftCircleMath::HitSelection
std::vector< bool > HitSelection
Definition: HitSelection.h:9
MuonCombined::MuonStauRecoTool::initialize
virtual StatusCode initialize() override
Definition: MuonStauRecoTool.cxx:48
MuonCombined::MuonStauRecoTool::findSegments
void findSegments(const Muon::MuonSystemExtension::Intersection &intersection, MaximumData &maximumData, std::vector< std::shared_ptr< const Muon::MuonSegment >> &t0fittedSegments, const ToolHandle< Muon::IMuonPRDSelectionTool > &muonPRDSelectionTool, const ToolHandle< Muon::IMuonSegmentMaker > &segmentMaker, float beta=1.) const
find segments for a given maximum
Definition: MuonStauRecoTool.cxx:1133
Muon::TimePointBetaFitter
Definition: TimePointBetaFitter.h:15
Muon::MuonStationIndex::stName
const std::string & stName(StIndex index)
convert StIndex into a string
Definition: MuonStationIndex.cxx:104
MuonGM::MuonReadoutElement::GlobalToAmdbLRSTransform
virtual Amg::Transform3D GlobalToAmdbLRSTransform() const
Definition: MuonDetDescr/MuonReadoutGeometry/src/MuonReadoutElement.cxx:154
TrkDriftCircleMath::SegmentFinder::setDeltaCut
void setDeltaCut(double cut)
Definition: SegmentFinder.cxx:81
TransformToLine.h
MuonCombined::MuonStauRecoTool::TruthInfo::toString
std::string toString() const
Definition: MuonStauRecoTool.h:126
MuonCombined::MuonStauRecoTool::m_doSummary
Gaudi::Property< bool > m_doSummary
Definition: MuonStauRecoTool.h:260
TrkDriftCircleMath::DriftCircle::position
const LocVec2D & position() const
access to local position
Definition: DriftCircle.h:74
skel.it
it
Definition: skel.GENtoEVGEN.py:407
TrkDriftCircleMath::DCSLFitter
Definition: Tracking/TrkUtilityPackages/TrkDriftCircleMath/TrkDriftCircleMath/DCSLFitter.h:17
CompetingMuonClustersOnTrack.h
TRTCalib_Extractor.tres
tres
Definition: TRTCalib_Extractor.py:32
TrkDriftCircleMath::DriftCircle::dr
double dr() const
access to error drift radius
Definition: DriftCircle.h:89
TrkDriftCircleMath::SegmentFinder::setMaxDropDepth
void setMaxDropDepth(int max)
Definition: SegmentFinder.cxx:46
AthCommonMsg< AlgTool >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
RpcHitClustering.h
MuonCombined::InDetCandidate
Definition: InDetCandidate.h:18
Segment.h
Muon::MuonDriftCircleErrorStrategy::Moore
@ Moore
Definition: MuonDriftCircleErrorStrategy.h:17
MuonCombined::MuonStauRecoTool::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition: MuonStauRecoTool.h:231
Muon::TimePointBetaFitter::FitResult::beta
float beta
status flag (0 = failed, 1 = ok)
Definition: TimePointBetaFitter.h:43
Muon::TimePointBetaFitter::FitResult::chi2PerDOF
float chi2PerDOF() const
chi2/ndof, return 0 if ndof == 0 or status == 0
Definition: TimePointBetaFitter.h:39
DCSLFitter.h
Muon::RpcClusterOnTrack
Class to represent calibrated clusters formed from RPC strips.
Definition: RpcClusterOnTrack.h:35
SG::ConstAccessor
Helper class to provide constant type-safe access to aux data.
Definition: ConstAccessor.h:55
python.TurnDataReader.dr
dr
Definition: TurnDataReader.py:111
MuonCombined::MuonStauRecoTool::createRpcTimeMeasurementsFromClusters
void createRpcTimeMeasurementsFromClusters(const Muon::MuonSystemExtension::Intersection &intersection, const std::vector< Muon::RpcClusterObj > &clusterObjects, RpcTimeMeasurementVec &rpcTimeMeasurements) const
create Rpc hit timing for a set of clusters
Definition: MuonStauRecoTool.cxx:1260
Trk::locR
@ locR
Definition: ParamDefs.h:44
TrkDriftCircleMath::DriftCircle
This class represents a drift time measurement.
Definition: DriftCircle.h:22
MuonCombined::MuonStauRecoTool::Candidate::betaSeed
BetaSeed betaSeed
Definition: MuonStauRecoTool.h:102
MuonHough::RegionDescriptor::referencePosition
float referencePosition
Definition: MuonLayerHough.h:48
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
Muon::CompetingMuonClustersOnTrack
Definition: CompetingMuonClustersOnTrack.h:54
MdtDriftCircleOnTrack.h
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
TrkDriftCircleMath::DriftCircle::r
double r() const
access to drift radius
Definition: DriftCircle.h:86
Muon::MdtPrepData::adc
int adc() const
Returns the ADC (typically range is 0 to 250)
Definition: MdtPrepData.h:146
x
#define x
MuonCombined::MuonStauRecoTool::RpcTimeMeasurementVec
std::vector< RpcTimeMeasurement > RpcTimeMeasurementVec
Definition: MuonStauRecoTool.h:70
intersection
std::vector< std::string > intersection(std::vector< std::string > &v1, std::vector< std::string > &v2)
Definition: compareFlatTrees.cxx:25
Trk::combinedTrack
void combinedTrack(long int ICH, double *pv0, double *covi, double BMAG, double *par, double *covo)
Definition: XYZtrp.cxx:113
TrkDriftCircleMath::TransformToLine
Definition: TransformToLine.h:15
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
MuonCombined::MuonStauRecoTool::resolveAmbiguities
bool resolveAmbiguities(CandidateVec &candidates) const
resolve ambiguities between the candidates
Definition: MuonStauRecoTool.cxx:748
MuGirlNS::MDTT_STAU_HIT
@ MDTT_STAU_HIT
Definition: CandidateSummary.h:27
MuonCombined::MuonStauRecoTool::extractRpcTimingFromMaximum
void extractRpcTimingFromMaximum(const Muon::MuonSystemExtension::Intersection &intersection, MaximumData &maximumData) const
extract RPC hit timing
Definition: MuonStauRecoTool.cxx:1214
Muon::MdtDriftCircleOnTrack::driftTime
double driftTime() const
Returns the value of the drift time used to obtain the drift radius.
Definition: MdtDriftCircleOnTrack.h:280
MuonCombined::MuonStauRecoTool::extendCandidates
void extendCandidates(CandidateVec &candidates, std::set< const MaximumData * > &usedMaximumData, LayerDataVec::const_iterator it, LayerDataVec::const_iterator it_end) const
extend a CandidateVec with the next LayerData
Definition: MuonStauRecoTool.cxx:936
MuonCombined::MuonStauRecoTool::RpcTimeMeasurement::rpcClusters
std::vector< std::shared_ptr< const Muon::RpcClusterOnTrack > > rpcClusters
Definition: MuonStauRecoTool.h:66
TrkDriftCircleMath::DCOnTrack::errorTrack
void errorTrack(double error)
set track error
Definition: DCOnTrack.h:41
TrkDriftCircleMath::Segment
Definition: Tracking/TrkUtilityPackages/TrkDriftCircleMath/TrkDriftCircleMath/Segment.h:18
MuGirlNS::StauMDTHitExtra
Definition: CandidateSummary.h:71
TrkDriftCircleMath::LocVec2D
Implementation of 2 dimensional vector class.
Definition: LocVec2D.h:16
DetType::Barrel
@ Barrel
Definition: DetType.h:14
Muon::MuonLayerHoughTool::PhiMaximumVec
HoughDataPerSec::PhiMaximumVec PhiMaximumVec
Definition: MuonLayerHoughTool.h:64
PlotCalibFromCool.ie
ie
Definition: PlotCalibFromCool.py:420
Trk::LocalDirection::angleYZ
double angleYZ() const
access method for angle of local YZ projection
Definition: LocalDirection.h:106
Trk::TrackStateOnSurface::Outlier
@ Outlier
This TSoS contains an outlier, that is, it contains a MeasurementBase/RIO_OnTrack which was not used ...
Definition: TrackStateOnSurface.h:122
MuonCombined::MuGirlLowBetaTag
TagBase implementation for a combined fit.
Definition: MuGirlLowBetaTag.h:27
Muon::TimePointBetaFitter::FitResult
simple struct holding the fit result
Definition: TimePointBetaFitter.h:33
TrkDriftCircleMath::Line
Definition: Line.h:17
MuonCombined::MuonStauRecoTool::m_trackAmbibuityResolver
ToolHandle< Trk::ITrackAmbiguityProcessorTool > m_trackAmbibuityResolver
Definition: MuonStauRecoTool.h:243
MuonCombined::InDetCandidateToTagMap::addEntry
void addEntry(const InDetCandidate *idcand, TagBase *tag)
Definition: InDetCandidateToTagMap.cxx:8
MuonCombined::MuonStauRecoTool::segmentTimeCalibration
void segmentTimeCalibration(const Identifier &id, float &time, float &error) const
Definition: MuonStauRecoTool.cxx:1428
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
RpcClusterOnTrack.h
MuonHough::MuonLayerHough::Maximum::theta
float theta
Definition: MuonLayerHough.h:69
MuGirlNS::RPCETA_STAU_HIT
@ RPCETA_STAU_HIT
Definition: CandidateSummary.h:27
MuonCombined::MuonStauRecoTool::m_muonSectorMapping
Muon::MuonSectorMapping m_muonSectorMapping
Definition: MuonStauRecoTool.h:258
MuGirlNS::RPC_STAU_HIT
@ RPC_STAU_HIT
Definition: CandidateSummary.h:27
Muon::MuonDriftCircleErrorStrategyInput
std::bitset< 23 > MuonDriftCircleErrorStrategyInput
Definition: MuonDriftCircleErrorStrategy.h:13
MuonCombined::MuonStauRecoTool::rpcTimeCalibration
void rpcTimeCalibration(const Identifier &id, float &time, float &error) const
Definition: MuonStauRecoTool.cxx:1424
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
TRT::Hit::driftTime
@ driftTime
Definition: HitInfo.h:43
MuonHough::MuonLayerHough::Maximum::max
float max
Definition: MuonLayerHough.h:67
MuonHough::PhiHit::tgc
const Muon::TgcClusterObj3D * tgc
Definition: MuonSpectrometer/MuonReconstruction/MuonRecUtils/MuonLayerHough/MuonLayerHough/Hit.h:127
Trk::locZ
@ locZ
local cylindrical
Definition: ParamDefs.h:42
MuonCombined::MuonStauRecoTool::LayerDataVec
std::vector< LayerData > LayerDataVec
Definition: MuonStauRecoTool.h:91
MuonCombined::MuonStauRecoTool::m_segmentMatchingTool
ToolHandle< Muon::IMuonLayerSegmentMatchingTool > m_segmentMatchingTool
Definition: MuonStauRecoTool.h:239
MuonGM::MdtReadoutElement
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MdtReadoutElement.h:51
dqt_zlumi_pandas.err
err
Definition: dqt_zlumi_pandas.py:183
DataModel_detail::iterator
(Non-const) Iterator class for DataVector/DataList.
Definition: DVLIterator.h:184
MuGirlNS::StauExtras::hits
StauHits hits
Definition: CandidateSummary.h:103
Line.h
lumiFormat.i
int i
Definition: lumiFormat.py:85
TrackCollection
DataVector< Trk::Track > TrackCollection
This typedef represents a collection of Trk::Track objects.
Definition: TrackCollection.h:19
MuonCombined::MuonStauRecoTool::TruthInfo::pdgId
int pdgId
Definition: MuonStauRecoTool.h:123
z
#define z
Muon::RpcPrepData
Class to represent RPC measurements.
Definition: RpcPrepData.h:35
Muon::RpcHitClusteringObj::cluster
bool cluster(const std::vector< const RpcPrepData * > &col)
Definition: RpcHitClustering.cxx:9
MuonCombined::MuonStauRecoTool::m_mdttBetaAssociationCut
Gaudi::Property< double > m_mdttBetaAssociationCut
Definition: MuonStauRecoTool.h:268
MuonCombined::MuonStauRecoTool::m_mdtCreator
ToolHandle< Muon::IMdtDriftCircleOnTrackCreator > m_mdtCreator
Definition: MuonStauRecoTool.h:248
RCU::Shell
Definition: ShellExec.cxx:28
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
MuonHough::MuonPhiLayerHough::Maximum
Definition: MuonPhiLayerHough.h:23
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
urldecode::states
states
Definition: urldecode.h:39
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
Muon::TgcClusterObj3D::phiCluster
HitList phiCluster
Definition: TgcHitClustering.h:27
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
Trk::PrepRawData::type
virtual bool type(PrepRawDataType type) const
Interface method checking the type.
Definition: PrepRawData.h:133
MuonCombined::MuonStauRecoTool::Candidate::allLayers
std::vector< Muon::MuonLayerRecoData > allLayers
Definition: MuonStauRecoTool.h:110
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition: GeoPrimitives.h:46
MuonHough::MuonPhiLayerHough::Maximum::hits
PhiHitVec hits
Definition: MuonPhiLayerHough.h:35
Trk::Segment
Definition: Tracking/TrkEvent/TrkSegment/TrkSegment/Segment.h:56
Muon::RpcHitClusteringObj
Definition: RpcHitClustering.h:76
MuonCombined::MuonStauRecoTool::RpcTimeMeasurement::error
float error
Definition: MuonStauRecoTool.h:68
res
std::pair< std::vector< unsigned int >, bool > res
Definition: JetGroupProductTest.cxx:11
CscClusterOnTrack.h
MuonCombined::MuonStauRecoTool::BetaSeed::beta
float beta
Definition: MuonStauRecoTool.h:61
BindingsTest.cut
cut
This script demonstrates how to call a C++ class from Python Also how to use PyROOT is shown.
Definition: BindingsTest.py:13
MuonCombined::MuonStauRecoTool::m_segmentMDTT
Gaudi::Property< bool > m_segmentMDTT
Definition: MuonStauRecoTool.h:263
MuGirlNS::StauHit
Definition: CandidateSummary.h:40
test_pyathena.parent
parent
Definition: test_pyathena.py:15
python.StandardJetMods.pull
pull
Definition: StandardJetMods.py:305
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
Muon::CscPrepData::time
double time() const
Returns the time.
Definition: CscPrepData.h:157
MuonCombined::MuonStauRecoTool::mdtTimeCalibration
void mdtTimeCalibration(const Identifier &id, float &time, float &error) const
Definition: MuonStauRecoTool.cxx:1420
MuonCombined::MuonStauRecoTool::createCandidates
bool createCandidates(const AssociatedData &associatedData, CandidateVec &candidates) const
create candidates from the beta seeds
Definition: MuonStauRecoTool.cxx:855
Trk::MeasurementBase::type
virtual bool type(MeasurementBaseType::Type type) const =0
Interface method checking the type.
MuonCombined::MuonStauRecoTool::AssociatedData
Definition: MuonStauRecoTool.h:93
Trk::PlaneSurface::globalToLocalDirection
void globalToLocalDirection(const Amg::Vector3D &glodir, Trk::LocalDirection &locdir) const
This method transforms the global direction to a local direction wrt the plane.
Definition: PlaneSurface.cxx:256
MuonCombined::MuonStauRecoTool::Candidate::finalBetaFitResult
Muon::TimePointBetaFitter::FitResult finalBetaFitResult
Definition: MuonStauRecoTool.h:117
MuonCombined::MuonStauRecoTool::MaximumData::maximum
const MuonHough::MuonLayerHough::Maximum * maximum
Definition: MuonStauRecoTool.h:78
MuonCombined::MuonStauRecoTool::BetaSeed
Definition: MuonStauRecoTool.h:59
MuonCombined::MuonStauRecoTool::Candidate::hits
Muon::TimePointBetaFitter::HitVec hits
Definition: MuonStauRecoTool.h:106
Trk::ParametersBase
Definition: ParametersBase.h:55
MuGirlNS::StauExtras::betaAllt
double betaAllt
Definition: CandidateSummary.h:87
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
Muon::MdtDriftCircleOnTrack::driftRadius
double driftRadius() const
Returns the value of the drift radius.
Definition: MdtDriftCircleOnTrack.h:277
IRtResolution.h
MuonHough::MuonLayerHough::Maximum::hough
const MuonLayerHough * hough
Definition: MuonLayerHough.h:83
Muon::MuonDriftCircleErrorStrategy::Segment
@ Segment
Treating a segment or a track.
Definition: MuonDriftCircleErrorStrategy.h:31
Trk::Intersection::position
Amg::Vector3D position
Definition: Intersection.h:25
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
MuonCombined::MuonStauRecoTool::addTag
void addTag(const InDetCandidate &inDetCandidate, Candidate &candidate, InDetCandidateToTagMap *tagMap, TrackCollection *combTracks, Trk::SegmentCollection *segments) const
create final tag object and add it to the inDetCandidate
Definition: MuonStauRecoTool.cxx:695
Trk::LocalDirection
represents the three-dimensional global direction with respect to a planar surface frame.
Definition: LocalDirection.h:81
MuonCombined::MuonStauRecoTool::m_segmentMaker
ToolHandle< Muon::IMuonSegmentMaker > m_segmentMaker
Definition: MuonStauRecoTool.h:236
MuonCombined::MuonStauRecoTool::m_segmentBetaAssociationCut
Gaudi::Property< double > m_segmentBetaAssociationCut
Definition: MuonStauRecoTool.h:270
Muon::MuonLayerHoughTool::MaximumVec
HoughDataPerSec::MaximumVec MaximumVec
Definition: MuonLayerHoughTool.h:63
MuonCombined::MuonStauRecoTool::MaximumData
Definition: MuonStauRecoTool.h:72
Trk::MeasurementBase::localCovariance
const Amg::MatrixX & localCovariance() const
Interface method to get the localError.
Definition: MeasurementBase.h:138
Muon::IMuonHitTimingTool::TimingResult
simple struct holding the result of the tool
Definition: IMuonHitTimingTool.h:38
MuonCombined::MuonStauRecoTool::combineCandidates
bool combineCandidates(const EventContext &ctx, const xAOD::TrackParticle &indetTrackParticle, CandidateVec &candidates) const
combine reconstruction
Definition: MuonStauRecoTool.cxx:800
MuonCombined::printIntersectionToString
std::string printIntersectionToString(const Muon::MuonSystemExtension::Intersection &intersection)
Definition: MuonStauRecoTool.cxx:37
Trk::PrepRawData
Definition: PrepRawData.h:62
Trk::MeasurementBase
Definition: MeasurementBase.h:58
Trk::PrepRawData::identify
Identifier identify() const
return the identifier
GetAllXsec.entry
list entry
Definition: GetAllXsec.py:132
MuonCombined::MuonStauRecoTool::LayerData::maximumDataVec
MaximumDataVec maximumDataVec
Definition: MuonStauRecoTool.h:89
MuonCombined::MuonStauRecoTool::m_selectedPdgs
std::set< int > m_selectedPdgs
Definition: MuonStauRecoTool.h:273
MuonCombined::MuonStauRecoTool::calculateTof
float calculateTof(const float beta, const float dist) const
Calcualte for zero betas.
Definition: MuonStauRecoTool.cxx:1433
MuonCombined::MuonStauRecoTool::associateHoughMaxima
void associateHoughMaxima(const EventContext &ctx, LayerData &layerData) const
associate Hough maxima to intersection
Definition: MuonStauRecoTool.cxx:1301
TrkDriftCircleMath::DCOnTrack::residual
void residual(double res)
set residual
Definition: DCOnTrack.h:35
selection
const std::string selection
Definition: fbtTestBasics.cxx:75
MuonCombined::MuonStauRecoTool::MaximumData::betaSeeds
std::vector< BetaSeed > betaSeeds
Definition: MuonStauRecoTool.h:83
MuonHough::PhiHit::prd
const Trk::PrepRawData * prd
access to assiciated hit, either the prd or the tgc pointer is set in athena
Definition: MuonSpectrometer/MuonReconstruction/MuonRecUtils/MuonLayerHough/MuonLayerHough/Hit.h:126
MuonCombined::MuonStauRecoTool::getBetaSeeds
void getBetaSeeds(MaximumData &maximumData) const
calculate the beta seeds for a give MaximumData
Definition: MuonStauRecoTool.cxx:1116
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
MuonCombined::MuonStauRecoTool::Candidate::stauHits
MuGirlNS::StauHits stauHits
Definition: MuonStauRecoTool.h:115
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
Trk::PrepRawDataType::sTgcPrepData
@ sTgcPrepData
MuonCombined::MuonStauRecoTool::calculateBeta
float calculateBeta(const float time, const float dist) const
In cases of invalid times just return an phyisical value of 20 times the speed of light The subsequen...
Definition: MuonStauRecoTool.cxx:1438
Muon::MdtDriftCircleOnTrack
This class represents the corrected MDT measurements, where the corrections include the effects of wi...
Definition: MdtDriftCircleOnTrack.h:37
Trk::StraightLineSurface::localToGlobal
virtual void localToGlobal(const Amg::Vector2D &locp, const Amg::Vector3D &mom, Amg::Vector3D &glob) const override final
Specified for StraightLineSurface: LocalToGlobal method without dynamic memory allocation.
Definition: StraightLineSurface.cxx:139
MuonHough::MuonLayerHough::Maximum::pos
float pos
Definition: MuonLayerHough.h:68
Muon::RpcClusterOnTrack::time
float time() const
Return the time (ns)
Definition: RpcClusterOnTrack.h:159
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
MuGirlNS::StauExtras::extraMDTHitInfo
std::optional< StauMDTHitExtras > extraMDTHitInfo
Definition: CandidateSummary.h:104
python.PhysicalConstants.c_light
float c_light
Definition: PhysicalConstants.py:73
MuonCombined::MuonStauRecoTool::handleCandidate
void handleCandidate(const EventContext &ctx, const InDetCandidate &inDetCandidate, InDetCandidateToTagMap *tagMap, TrackCollection *combTracks, Trk::SegmentCollection *segments) const
handle a single candidate
Definition: MuonStauRecoTool.cxx:105
MuonCombined::MuonStauRecoTool::LayerData::intersection
Muon::MuonSystemExtension::Intersection intersection
Definition: MuonStauRecoTool.h:88
Muon::MdtPrepData
Class to represent measurements from the Monitored Drift Tubes.
Definition: MdtPrepData.h:33
Muon::CompetingMuonClustersOnTrack::containedROTs
const std::vector< const MuonClusterOnTrack * > & containedROTs() const
returns the vector of SCT_ClusterOnTrack objects .
Definition: CompetingMuonClustersOnTrack.h:184
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
Trk::PlaneSurface::straightLineIntersection
virtual Intersection straightLineIntersection(const Amg::Vector3D &pos, const Amg::Vector3D &dir, bool forceDir, Trk::BoundaryCheck bchk) const override final
fast straight line intersection schema - standard: provides closest intersection and (signed) path le...
Definition: PlaneSurface.cxx:219
Muon::MuonStationIndex::regionName
const std::string & regionName(DetectorRegionIndex index)
convert DetectorRegionIndex into a string
Definition: MuonStationIndex.cxx:138
MuonCombined::MuonStauRecoTool::MaximumData::rpcTimeMeasurements
RpcTimeMeasurementVec rpcTimeMeasurements
Definition: MuonStauRecoTool.h:82
Muon::CscClusterOnTrack::prepRawData
virtual const CscPrepData * prepRawData() const override final
Returns the CscPrepData - is a CscPrepData in this scope.
Definition: CscClusterOnTrack.h:154
Muon::MuonDriftCircleErrorStrategy::setParameter
void setParameter(CreationParameter, bool value)
Definition: MuonDriftCircleErrorStrategy.h:63
Muon::HoughDataPerSec
Definition: HoughDataPerSec.h:20
MuonHough::MuonLayerHough::Maximum::hits
HitVec hits
Definition: MuonLayerHough.h:81
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:16
TrkDriftCircleMath::TransformToLine::toLineY
double toLineY(const LocVec2D &pos) const
Definition: TransformToLine.h:24
Muon::MuonDriftCircleErrorStrategy::setStrategy
void setStrategy(Strategy)
Select the strategy to be used - only one can be set at a time.
Definition: MuonDriftCircleErrorStrategy.h:54
Muon::RpcHitClusteringObj::clustersEta
std::vector< RpcClusterObj > clustersEta
Definition: RpcHitClustering.h:116
Trk::MeasurementBase::localParameters
const LocalParameters & localParameters() const
Interface method to get the LocalParameters.
Definition: MeasurementBase.h:132
MuonCombined::MuonStauRecoTool::m_segmentMakerT0Fit
ToolHandle< Muon::IMuonSegmentMaker > m_segmentMakerT0Fit
Definition: MuonStauRecoTool.h:237
MuonStauRecoTool.h
MuonCombined::MuonStauRecoTool::extend
virtual void extend(const InDetCandidateCollection &inDetCandidates, InDetCandidateToTagMap *tagMap, TrackCollection *combTracks, TrackCollection *meTracks, Trk::SegmentCollection *segments, const EventContext &ctx) const override
IMuonCombinedInDetExtensionTool interface: extend ID candidate.
Definition: MuonStauRecoTool.cxx:82
Trk::ParametersBase::momentum
const Amg::Vector3D & momentum() const
Access method for the momentum.
MuGirlNS::CSC_STAU_HIT
@ CSC_STAU_HIT
Definition: CandidateSummary.h:27
DeMoScan.index
string index
Definition: DeMoScan.py:362
Muon::CscClusterOnTrack
Class to represent the calibrated clusters created from CSC strips.
Definition: CscClusterOnTrack.h:47
Muon::TimePointBetaFitter::HitVec
std::vector< Hit > HitVec
Definition: TimePointBetaFitter.h:30
MuonCombined::MuonStauRecoTool::getTruth
std::unique_ptr< TruthInfo > getTruth(const xAOD::TrackParticle &indetTrackParticle) const
extract truth from the indetTrackParticle
Definition: MuonStauRecoTool.cxx:92
MuonCombined::InDetCandidate::indetTrackParticle
const xAOD::TrackParticle & indetTrackParticle() const
access TrackParticle
Definition: InDetCandidate.cxx:27
Muon::MuonStationIndex::DetectorRegionIndex
DetectorRegionIndex
enum to classify the different layers in the muon spectrometer
Definition: MuonStationIndex.h:47
y
#define y
MuonCombined::MuonStauRecoTool::Candidate::combinedTrack
std::unique_ptr< Trk::Track > combinedTrack
Definition: MuonStauRecoTool.h:114
MuonCombined::InDetCandidate::isSiliconAssociated
bool isSiliconAssociated() const
Returns true if this candidate was formed from a special far forward InDet track.
Definition: InDetCandidate.cxx:35
python.BackTrackingConfig.numThreads
int numThreads
Definition: BackTrackingConfig.py:61
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
python.Constants.INFO
int INFO
Definition: Control/AthenaCommon/python/Constants.py:15
Trk::PlaneSurface
Definition: PlaneSurface.h:64
Muon::MdtDriftCircleOnTrack::associatedSurface
virtual const Trk::StraightLineSurface & associatedSurface() const override final
Returns the surface on which this measurement was taken.
Definition: MdtDriftCircleOnTrack.h:271
IRtRelation.h
MdtFullCalibData.h
MuonCombined
The MuonTagToSegMap is an auxillary construct that links the MuonSegments associated with a combined ...
Definition: IMuonSystemExtensionTool.h:23
Trk::RIO_OnTrack::identify
Identifier identify() const
return the identifier -extends MeasurementBase
Definition: RIO_OnTrack.h:152
DEBUG
#define DEBUG
Definition: page_access.h:11
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
MuonCombined::MuonStauRecoTool::Candidate::stauMDTHitExtras
MuGirlNS::StauMDTHitExtras stauMDTHitExtras
Definition: MuonStauRecoTool.h:116
MuonCombined::MuonStauRecoTool::AssociatedData::layerData
LayerDataVec layerData
Definition: MuonStauRecoTool.h:94
TrkDriftCircleMath::SegmentFinder::dropHits
bool dropHits(Segment &segment, bool &hasDroppedHit, unsigned int &dropDepth) const
Definition: SegmentFinder.cxx:409
RunTileMonitoring.clusters
clusters
Definition: RunTileMonitoring.py:133
MuonCombined::MuonStauRecoTool::m_addMDTExtrasMuGirlLowBeta
Gaudi::Property< bool > m_addMDTExtrasMuGirlLowBeta
Definition: MuonStauRecoTool.h:271
MuonGM::MdtReadoutElement::surface
virtual const Trk::Surface & surface() const override final
Return surface associated with this detector element.
Definition: MuonDetDescr/MuonReadoutGeometry/src/MdtReadoutElement.cxx:885
Muon::MuonSystemExtension::layerIntersections
const std::vector< Intersection > & layerIntersections() const
access to the intersections with the layers.
Definition: MuonSystemExtension.h:62
TrkDriftCircleMath::DCOnTrack
class representing a drift circle meaurement on segment
Definition: DCOnTrack.h:16
MuonCombined::MuonStauRecoTool::m_ignoreSiAssocated
Gaudi::Property< bool > m_ignoreSiAssocated
Definition: MuonStauRecoTool.h:264
MuonCombined::MuonStauRecoTool::m_mdtCreatorStau
ToolHandle< Muon::IMdtDriftCircleOnTrackCreator > m_mdtCreatorStau
Definition: MuonStauRecoTool.h:250
MuonCombined::MuonStauRecoTool::Candidate::betaFitResult
Muon::TimePointBetaFitter::FitResult betaFitResult
Definition: MuonStauRecoTool.h:107
MuonSegment.h
SG::ConstAccessor::isAvailable
bool isAvailable(const ELT &e) const
Test to see if this variable exists in the store.
Muon::MuonCluster
Class representing clusters in the muon system.
Definition: MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonPrepRawData/MuonPrepRawData/MuonCluster.h:37
Muon::MuonSystemExtension::Intersection
data per intersection
Definition: MuonSystemExtension.h:21
TrkDriftCircleMath::SegmentFinder
Definition: SegmentFinder.h:32
Muon::MuonSegment::globalPosition
virtual const Amg::Vector3D & globalPosition() const override final
global position
Definition: MuonSpectrometer/MuonReconstruction/MuonRecEvent/MuonSegment/MuonSegment/MuonSegment.h:157
Muon::MuonStationIndex::ChIndex
ChIndex
enum to classify the different chamber layers in the muon spectrometer
Definition: MuonStationIndex.h:15
MuonCombined::MuonStauRecoTool::m_insideOutRecoTool
ToolHandle< MuonCombined::MuonInsideOutRecoTool > m_insideOutRecoTool
Definition: MuonStauRecoTool.h:252
xAOD::track
@ track
Definition: TrackingPrimitives.h:513
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
Trk::SpaceTimePointBase::time
float time() const
access to the measured time
Definition: SpaceTimePointBase.h:47
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:13
MuonCombined::MuonStauRecoTool::extractTimeMeasurements
bool extractTimeMeasurements(const EventContext &ctx, const Muon::MuonSystemExtension &muonSystemExtension, AssociatedData &associatedData) const
associate Hough maxima and associate time measurements
Definition: MuonStauRecoTool.cxx:997
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
ConstAccessor.h
Helper class to provide constant type-safe access to aux data.
MuonCombined::MuonStauRecoTool::m_muonPRDSelectionTool
ToolHandle< Muon::IMuonPRDSelectionTool > m_muonPRDSelectionTool
Definition: MuonStauRecoTool.h:246
AthAlgTool
Definition: AthAlgTool.h:26
MuonParameters::beta
@ beta
Definition: MuonParamDefs.h:144
get_generator_info.error
error
Definition: get_generator_info.py:40
MuonCombined::MuonStauRecoTool::extendWithPRDs
virtual void extendWithPRDs(const InDetCandidateCollection &inDetCandidates, InDetCandidateToTagMap *tagMap, IMuonCombinedInDetExtensionTool::MuonPrdData prdData, TrackCollection *combTracks, TrackCollection *meTracks, Trk::SegmentCollection *segments, const EventContext &ctx) const override
Definition: MuonStauRecoTool.cxx:73
MuonHough::MuonLayerHough::Maximum::binposmax
int binposmax
Definition: MuonLayerHough.h:77
MuonCombined::MuonStauRecoTool::selectTruth
bool selectTruth(const TruthInfo *truthInfo) const
if truth tracking is enabled, return whether the pdg is selected
Definition: MuonStauRecoTool.h:206
error
Definition: IImpactPoint3dEstimator.h:70
Amg::distance
float distance(const Amg::Vector3D &p1, const Amg::Vector3D &p2)
calculates the distance between two point in 3D space
Definition: GeoPrimitivesHelpers.h:54
dq_make_web_display.cl
cl
print [x.__class__ for x in toList(dqregion.getSubRegions()) ]
Definition: dq_make_web_display.py:25
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
LocVec2D.h
MuonCombined::MuonStauRecoTool::m_pdgsToBeConsidered
Gaudi::Property< std::vector< int > > m_pdgsToBeConsidered
Definition: MuonStauRecoTool.h:265
MuonCombined::MuonStauRecoTool::RpcTimeMeasurement::time
float time
Definition: MuonStauRecoTool.h:67
MuonCombined::MuonStauRecoTool::m_edmHelperSvc
ServiceHandle< Muon::IMuonEDMHelperSvc > m_edmHelperSvc
Definition: MuonStauRecoTool.h:232
MuonCombined::MuonStauRecoTool::MaximumData::t0fittedSegments
std::vector< std::shared_ptr< const Muon::MuonSegment > > t0fittedSegments
Definition: MuonStauRecoTool.h:81
MuonCombined::MuonStauRecoTool::refineCandidates
bool refineCandidates(const EventContext &ctx, CandidateVec &candidates) const
refine candidates: find segments for the given beta
Definition: MuonStauRecoTool.cxx:190
Muon::MuonClusterOnTrack
Base class for Muon cluster RIO_OnTracks.
Definition: MuonClusterOnTrack.h:34
Muon::TimePointBetaFitter::FitResult::status
int status
data members
Definition: TimePointBetaFitter.h:42
MuonCombined::MuonStauRecoTool::LayerData
Definition: MuonStauRecoTool.h:86
xAOD::TrackParticle_v1::phi
virtual double phi() const override final
The azimuthal angle ( ) of the particle (has range to .)
TrkDriftCircleMath::SegmentFinder::debugLevel
void debugLevel(int debugLevel)
Definition: SegmentFinder.h:71
NSWL1::PadTriggerAdapter::segment
Muon::NSW_PadTriggerSegment segment(const NSWL1::PadTrigger &data)
Definition: PadTriggerAdapter.cxx:5
MuonCombined::IMuonCombinedInDetExtensionTool::MuonPrdData::mdtPrds
const Muon::MdtPrepDataContainer * mdtPrds
Definition: IMuonCombinedInDetExtensionTool.h:29
Muon::HoughDataPerSec::maxVec
RegionMaximumVec maxVec
Definition: HoughDataPerSec.h:54
TrkDriftCircleMath::DriftCircle::InTime
@ InTime
drift time too small to be compatible with drift spectrum
Definition: DriftCircle.h:27
Identifier
Definition: IdentifierFieldParser.cxx:14