ATLAS Offline Software
MdtDriftCircleOnTrackCreator.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 "MdtDriftCircleOnTrackCreator.h"
6 
7 #include "EventPrimitives/EventPrimitivesHelpers.h"
8 #include "MdtCalibData/IRtRelation.h"
9 #include "MdtCalibData/IRtResolution.h"
10 #include "MdtCalibData/MdtFullCalibData.h"
11 #include "MdtCalibData/MdtRtRelation.h"
12 #include "MuonPrepRawData/MdtPrepData.h"
13 #include "MuonRIO_OnTrack/MdtDriftCircleOnTrack.h"
14 #include "MuonRIO_OnTrack/MuonDriftCircleErrorStrategy.h"
15 #include "MuonReadoutGeometry/MdtReadoutElement.h"
16 #include "TrkParameters/TrackParameters.h"
17 #include "TrkSurfaces/StraightLineSurface.h"
18 
19 #include <optional>
20 
21 namespace Muon {
22 
23 using MdtRotPtr = MdtDriftCircleOnTrackCreator::MdtRotPtr;
24 using CalibrationOutput = MdtDriftCircleOnTrackCreator::CalibrationOutput;
25 
26 MdtDriftCircleOnTrackCreator::MdtDriftCircleOnTrackCreator(const std::string& ty,
27  const std::string& na,
28  const IInterface* pa)
29  : AthAlgTool(ty, na, pa) {
30  // algtool interface - necessary!
31  declareInterface<IMdtDriftCircleOnTrackCreator>(this);
32  declareInterface<IRIO_OnTrackCreator>(this);
33 }
34 
35 StatusCode MdtDriftCircleOnTrackCreator::initialize() {
36  ATH_CHECK(m_mdtCalibrationTool.retrieve());
37  ATH_CHECK(m_idHelperSvc.retrieve());
38  m_BME_idx = m_idHelperSvc->mdtIdHelper().stationNameIndex("BME");
39 
40 
41  m_errorStrategy.setParameter(MuonDriftCircleErrorStrategy::BroadError, m_createTubeHits);
42  m_errorStrategy.setParameter(MuonDriftCircleErrorStrategy::ScaledError, m_scaleMdtCov);
43  m_errorStrategy.setParameter(MuonDriftCircleErrorStrategy::FixedError, m_doFixedError);
44  m_errorStrategy.setParameter(MuonDriftCircleErrorStrategy::ParameterisedErrors, m_useErrorParametrisation);
45  m_errorStrategy.setParameter(MuonDriftCircleErrorStrategy::StationError, m_stationError);
46  m_errorStrategy.setParameter(MuonDriftCircleErrorStrategy::ErrorAtPredictedPosition, m_errorAtPredictedPosition);
47  m_errorStrategy.setParameter(MuonDriftCircleErrorStrategy::T0Refit, m_t0Refit);
48  m_errorStrategy.setParameter(MuonDriftCircleErrorStrategy::Segment, m_doSegments);
49  using ToolSettings = IMdtCalibrationTool::ToolSettings;
50  using Property = ToolSettings::Property;
51  ToolSettings calibSettings = m_mdtCalibrationTool->getSettings();
52  m_errorStrategy.setParameter(MuonDriftCircleErrorStrategy::TofCorrection,
53  calibSettings.isActive(Property::TofCorrection));
54  m_errorStrategy.setParameter(MuonDriftCircleErrorStrategy::PropCorrection,
55  calibSettings.isActive(Property::PropCorrection));
56  m_errorStrategy.setParameter(MuonDriftCircleErrorStrategy::TempCorrection,
57  calibSettings.isActive(Property::TempCorrection));
58  m_errorStrategy.setParameter(MuonDriftCircleErrorStrategy::MagFieldCorrection,
59  calibSettings.isActive(Property::MagFieldCorrection));
60  m_errorStrategy.setParameter(MuonDriftCircleErrorStrategy::SlewCorrection,
61  calibSettings.isActive(Property::SlewCorrection));
62  m_errorStrategy.setParameter(MuonDriftCircleErrorStrategy::BackgroundCorrection,
63  calibSettings.isActive(Property::BackgroundCorrection));
64  m_errorStrategy.setCalibWindow(calibSettings.window);
65 
66  if ("Moore" == m_defaultStrategy) {
67  m_errorStrategy.setStrategy(MuonDriftCircleErrorStrategy::Moore);
68  } else if ("Muon" == m_defaultStrategy) {
69  m_errorStrategy.setStrategy(MuonDriftCircleErrorStrategy::Muon);
70  } else {
71  // By default use one of the real strategies - don't default to unknown!
72  m_errorStrategy.setStrategy(MuonDriftCircleErrorStrategy::Muon);
73  ATH_MSG_FATAL("Unknown error strategy "<<m_errorStrategy);
74  return StatusCode::FAILURE;
75  }
76  if (msgLevel(MSG::INFO)) {
77  std::stringstream ss;
78  ss << "Constructed default MuonDriftCircleErrorStrategy:";
79  if (m_errorStrategy.creationParameter(MuonDriftCircleErrorStrategy::BroadError))
80  ss << " Broad";
81  if (m_errorStrategy.creationParameter(MuonDriftCircleErrorStrategy::ScaledError))
82  ss << " Scaled";
83  if (m_errorStrategy.creationParameter(MuonDriftCircleErrorStrategy::FixedError))
84  ss << " Fixed";
85  if (m_errorStrategy.creationParameter(MuonDriftCircleErrorStrategy::ParameterisedErrors))
86  ss << " Parm";
87  if (m_errorStrategy.creationParameter(MuonDriftCircleErrorStrategy::StationError))
88  ss << " Station";
89  if (m_errorStrategy.creationParameter(MuonDriftCircleErrorStrategy::ErrorAtPredictedPosition))
90  ss << " ErrAtPos";
91  if (m_errorStrategy.creationParameter(MuonDriftCircleErrorStrategy::T0Refit))
92  ss << " T0";
93  if (m_errorStrategy.creationParameter(MuonDriftCircleErrorStrategy::TofCorrection))
94  ss << " TOF";
95  if (m_errorStrategy.creationParameter(MuonDriftCircleErrorStrategy::PropCorrection))
96  ss << " Prop";
97  if (m_errorStrategy.creationParameter(MuonDriftCircleErrorStrategy::TempCorrection))
98  ss << " Temp";
99  if (m_errorStrategy.creationParameter(MuonDriftCircleErrorStrategy::MagFieldCorrection))
100  ss << " Mag";
101  if (m_errorStrategy.creationParameter(MuonDriftCircleErrorStrategy::SlewCorrection))
102  ss << " Slew";
103  if (m_errorStrategy.creationParameter(MuonDriftCircleErrorStrategy::BackgroundCorrection))
104  ss << " Back";
105  if (m_errorStrategy.creationParameter(MuonDriftCircleErrorStrategy::Segment))
106  ss << " Seg";
107  ss << ". ";
108  if (!m_isMC && m_looseErrors)
109  ss << "Using Data Loose error tuning";
110  if (!m_isMC && !m_looseErrors)
111  ss << "Using Data Tight error tuning";
112 
113  msg(MSG::INFO) << ss.str() << endmsg;
114  }
115  if (m_isMC)
116  ATH_MSG_DEBUG("Using MC error tuning");
117  ATH_MSG_VERBOSE("A correction is made if set to true: do_MDT = " << m_doMdt);
118 
119  if (m_timeCorrectionType == COSMICS_TOF) {
120  if (!m_errorStrategy.creationParameter(MuonDriftCircleErrorStrategy::TofCorrection)) {
121  ATH_MSG_ERROR("Detected bad default configuration, using Cosmic TOF without "
122  <<"time of flight corrections does not work");
123  return StatusCode::FAILURE;
124  }
125  }
126  ATH_MSG_DEBUG("Timing mode set to " << m_timeCorrectionType);
127  if (m_timeCorrectionType >= NumberOfTimingModes) {
128  ATH_MSG_ERROR("Time Correction Type too large! Aborting.");
129  return StatusCode::FAILURE;
130  }
131 
132  if (!m_wasConfigured) {
133  ATH_MSG_ERROR("This tool is too complicated to rely on defaults. Potential configuration issue.");
134  return StatusCode::FAILURE;
135  }
136  return StatusCode::SUCCESS;
137 }
138 
139 MdtRotPtr MdtDriftCircleOnTrackCreator::createRIO_OnTrack(const MdtPrepData& mdtPrd,
140  const Amg::Vector3D& GP,
141  const Amg::Vector3D* GD,
142  const double t0Shift,
143  const MuonDriftCircleErrorStrategy* strategy,
144  const double beta,
145  const double tTrack) const {
146 
147  const EventContext& ctx{Gaudi::Hive::currentContext()};
148 
149  const MuonDriftCircleErrorStrategy& myStrategy{!strategy ? m_errorStrategy : *strategy};
150 
151  const Identifier iD = mdtPrd.identify();
152 
153  MdtCalibInput calibInput{mdtPrd};
154  calibInput.setClosestApproach(GP);
155  if (GD) calibInput.setTrackDirection((*GD).unit(), true);
156 
157  switch (m_timeCorrectionType) {
158  case ATLTIME:
159  // normal time of flight corrections assuming IP + light speed
160  calibInput.setTimeOfFlight(calibInput.closestApproach().mag() * s_inverseSpeedOfLight);
161  ATH_MSG_VERBOSE(" running in ATLTIME mode, tof: " << calibInput.timeOfFlight());
162  break;
163  case NO_CORRECTIONS:
164  // special case for cosmics taken with scintilator trigger or
165  // cosmic simulation without TOF
166  calibInput.setTimeOfFlight(0);
167  ATH_MSG_VERBOSE("running in NO_CORRECTIONS mode, tof: " << calibInput.timeOfFlight());
168  break;
169  case COSMICS_TRIGGERTIME:
170  // special case for cosmics taken with scintilator trigger which
171  // is read out so the offset with respect to the clock is known
172  // getTriggerTime() NOT IMPLEMENETED YET!!!!!!
173  calibInput.setTriggerTime(getTriggerTime());
174  ATH_MSG_VERBOSE(" running in COSMICS_TRIGGERTIME mode, triggerOffset: "
175  << calibInput.triggerTime());
176  break;
177  case COSMICS_TOF:
178  calibInput.setTimeOfFlight(timeOfFlight(calibInput.closestApproach(), beta, tTrack, t0Shift));
179  ATH_MSG_VERBOSE(" running in COSMICS_TOF mode, tof: "
180  << calibInput.timeOfFlight() << " tTrack: " << tTrack
181  << " t0Shift: " << t0Shift
182  << " applyToF: " << m_applyToF);
183  break;
184  default:
185  // default, no tof. Indicates wrong configuration
186  ATH_MSG_WARNING("No valid mode selected, cannot apply tof correction");
187  calibInput.setTimeOfFlight(0);
188  break;
189  }
190 
191  Amg::Vector2D posOnWire{Amg::Vector2D::Zero()};
192  // if wire sag is taken into account, cast the surface to
193  // StraightLineSurface so it can be added to the ROT
194  const Trk::Surface& surf{calibInput.legacySurface()};
195  std::optional<Amg::Vector2D> posOnIdealWire = surf.globalToLocal(GP, m_globalToLocalTolerance);
196  if (!posOnIdealWire) {
197  ATH_MSG_WARNING(__FILE__<<":"<<__LINE__<<" globalToLocal() failed for ideal surface");
198  return nullptr;
199  }
200  posOnWire = std::move(*posOnIdealWire);
201 
202  double positionAlongWire = posOnWire[Trk::locZ];
203  // set driftcirclestatus, NODRIFTTIME if creating tube hits else UNDECIDED
204  Trk::DriftCircleStatus dcstatus = m_doMdt ? Trk::UNDECIDED : Trk::NODRIFTTIME;
205 
206  CalibrationOutput calibOutput = getLocalMeasurement(ctx, mdtPrd, calibInput, myStrategy);
207  // This basically determines the error etc and is where the bulk of the work
208  // is done.
209 
210  // hack to determine whether we are before or after the spectrum, until we
211  // sort this out properly
212  if (!calibOutput.calibOk && calibOutput.driftTime > 500.) {
213  ATH_MSG_WARNING("Unable to perform calibration ");
214  return nullptr;
215  }
216 
217  std::unique_ptr<MdtDriftCircleOnTrack> rot{};
218 
219  // we have to calculate sign, check whether direction is given
220  if (m_doMdt && GD) {
221  // calculate sign using surface
222  const Trk::Surface& surf{calibInput.legacySurface()};
223  std::optional<Amg::Vector2D> pos = surf.globalToLocal(GP, calibInput.trackDirection());
224 
225  // check this might still fail....
226  if (!pos) {
227  ATH_MSG_WARNING("Unexpected globalToLocal failure, cannot create MDT ROT ");
228  return nullptr;
229  }
230 
231  // calculate sign
232  double sign = (*pos)[Trk::driftRadius] < 0 ? -1.0 : 1.0;
233  calibOutput.locPars[Trk::driftRadius] *= sign;
234  rot = std::make_unique<MdtDriftCircleOnTrack>(&mdtPrd,
235  std::move(calibOutput.locPars),
236  std::move(calibOutput.locErr),
237  calibOutput.driftTime,
238  Trk::DECIDED,
239  calibInput.trackDirection(),
240  positionAlongWire,
241  myStrategy);
242 
243  } else {
244  // If the track direction is missing, the B-field correction was not
245  // applied
246  if (GD) {
247  // do not have access to direction, so have to use partial
248  // constructor:
249  rot = std::make_unique<MdtDriftCircleOnTrack>(&mdtPrd,
250  std::move(calibOutput.locPars),
251  std::move(calibOutput.locErr),
252  calibOutput.driftTime,
253  dcstatus,
254  positionAlongWire,
255  myStrategy);
256  } else {
257  MuonDriftCircleErrorStrategy tmpStrategy(myStrategy.getBits());
258  tmpStrategy.setParameter(MuonDriftCircleErrorStrategy::MagFieldCorrection, false);
259  rot = std::make_unique<MdtDriftCircleOnTrack>(&mdtPrd,
260  std::move(calibOutput.locPars),
261  std::move(calibOutput.locErr),
262  calibOutput.driftTime,
263  dcstatus,
264  positionAlongWire,
265  tmpStrategy);
266  }
267  }
268  ATH_MSG_DEBUG("MDT ROT: radius = "
269  << rot->localParameters().get(Trk::driftRadius) << " error = "
270  << Amg::error(rot->localCovariance(), Trk::locR)
271  <<" ,channel "
272  << m_idHelperSvc->toString(iD));
273 
274  return rot.release();
275 }
276 
277 void MdtDriftCircleOnTrackCreator::updateSign(MdtDriftCircleOnTrack& caliDriftCircle,
278  Trk::DriftCircleSide si) const {
279  // ************************
280  // Apply additional corrections to local position
281  Trk::LocalParameters lpos(caliDriftCircle.localParameters());
282 
283  // set sign LocalPosition
284  if (si == Trk::LEFT) {
285  lpos[Trk::driftRadius] = -std::abs(lpos[Trk::driftRadius]);
286  } else {
287  lpos[Trk::driftRadius] = std::abs(lpos[Trk::driftRadius]);
288  }
289 
290  caliDriftCircle.setLocalParameters(lpos);
291  caliDriftCircle.m_status = Trk::DECIDED;
292  ATH_MSG_VERBOSE("MDT DriftCircleOnTrack made with radius = " << lpos);
293 }
294 
295 CalibrationOutput MdtDriftCircleOnTrackCreator::getLocalMeasurement(const EventContext& ctx,
296  const MdtPrepData& DC,
297  const MdtCalibInput& calibInput,
298  const MuonDriftCircleErrorStrategy& myStrategy) const {
299 
300 
301  ATH_MSG_VERBOSE("getLocalMeasurement "<<calibInput<<" with m_doMdt=" << m_doMdt << " and " << myStrategy);
302  const Amg::Vector3D& gpos{calibInput.closestApproach()};
303  const Amg::Vector3D& gdir{calibInput.trackDirection()};
304 
305  double sigmaR{1.}, driftTime{0.}, radius{0.}, errRadius{0.};
306  MdtCalibOutput calibOutput{};
307  if (m_doMdt) {
308  // call the calibration service providing the time when the particle
309  // passed the tube
310  calibOutput = m_mdtCalibrationTool->calibrate(ctx, calibInput);
311  ATH_MSG_VERBOSE("getLocalMeasurement() - Calibrated output "<<calibOutput);
312  driftTime = calibOutput.driftTime();
313  radius = calibOutput.driftRadius();
314  errRadius = radius;
315 
316  if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::ErrorAtPredictedPosition)) {
317  const Trk::Surface& surf{calibInput.legacySurface()};
318  std::optional<Amg::Vector2D> myLocalPosition = surf.globalToLocal(gpos, gdir);
319  if (myLocalPosition) {
320  errRadius = (*myLocalPosition)[Trk::driftRadius];
321  } else {
322  ATH_MSG_WARNING(__FILE__<<":"<<__LINE__<<" ErrorAtPredictedPosition failed because local position "<<
323  "transformation didn't succeed. Using measured radius instead.");
324  errRadius = radius;
325  }
326  }
327  } else {
328  // use PRD values
329  radius = DC.localPosition().x();
330  errRadius = radius;
331  // check consistency of error matrix
332  if (DC.localCovariance().cols() > 1) {
333  ATH_MSG_WARNING("Error matrix of DC doesn't have dimension 1 "<< DC.localCovariance());
334  ATH_MSG_WARNING("Reducing size to 1 dim");
335  }
336  }
337 
338  // Handle the errors here. Begin by getting the first part of the
339  // resolution term
340  if (!m_doMdt) {
341  sigmaR = Amg::error(DC.localCovariance(), Trk::driftRadius);
342  } else if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::ParameterisedErrors)) {
343  sigmaR = parametrisedSigma(errRadius);
344  } else {
345  sigmaR = calibOutput.driftRadiusUncert();
346  }
347  ATH_MSG_DEBUG("Tube : " << m_idHelperSvc->toString(calibInput.identify())
348  << " SigmaR = " << sigmaR);
349  double sigmaR2 = 0.0;
350  // Handle the errors scaling / addition of fixed terms
351  if (myStrategy.strategy() == MuonDriftCircleErrorStrategy::Moore) {
352  sigmaR2 = mooreErrorStrategy(myStrategy, sigmaR * sigmaR, calibInput.identify());
353  ATH_MSG_DEBUG("After scaling etc:\t Moore sigmaR2 = " << sigmaR2);
354  } else if (myStrategy.strategy() == MuonDriftCircleErrorStrategy::Muon) {
355  sigmaR2 = muonErrorStrategy(myStrategy, sigmaR * sigmaR, calibInput.identify());
356  ATH_MSG_DEBUG("After scaling etc:\t Muon ErrorStrategy sigmaR2 = " << sigmaR2);
357  }
359  // update or copy drift radius and error
360 
361  // new radius
362  Trk::DefinedParameter radiusPar(radius, Trk::driftRadius);
363 
364  // create new error matrix
365  Amg::MatrixX newLocalCov(1, 1);
366  newLocalCov(0, 0) = sigmaR2;
367 
368  // return new values
369  bool ok = true;
370  return {Trk::LocalParameters(radiusPar), newLocalCov, driftTime,
371  ok};
372 }
373 
374 MdtRotPtr MdtDriftCircleOnTrackCreator::correct(const MdtPrepData& prd,
375  const Trk::TrackParameters& tp,
376  const MuonDriftCircleErrorStrategy* strategy,
377  const double beta,
378  const double tTrack) const {
379 
380  const Amg::Vector3D& momentum = tp.momentum();
381  return createRIO_OnTrack(prd, tp.position(), &momentum, 0, strategy, beta, tTrack);
382 }
383 
384 Trk::RIO_OnTrack* MdtDriftCircleOnTrackCreator::correct(const Trk::PrepRawData& prd,
385  const Trk::TrackParameters& tp,
386  const EventContext& /*ctx*/) const {
387  if (!prd.type(Trk::PrepRawDataType::MdtPrepData)){
388  ATH_MSG_WARNING(__FILE__<<":"<<__LINE__<<" Incorrect hit type: "
389  <<" Trk::PrepRawData not a MdtPrepData!! No rot created ");
390  return nullptr;
391  }
392  Amg::Vector3D momentum = tp.momentum();
393 
394  return createRIO_OnTrack(static_cast<const MdtPrepData&>(prd), tp.position(), &momentum);
395 }
396 MdtRotPtr MdtDriftCircleOnTrackCreator::updateError(const MdtDriftCircleOnTrack& DCT,
397  const Trk::TrackParameters* ,
398  const MuonDriftCircleErrorStrategy* strategy) const {
399 
400  const MuonDriftCircleErrorStrategy& myStrategy = (!strategy) ? m_errorStrategy : *strategy;
401 
402  // calculate error
403  double sigmaR(1.);
404  double t = DCT.driftTime();
405 
406  const MuonGM::MdtReadoutElement* detEl = DCT.detectorElement();
407  if (!detEl) {
408  ATH_MSG_WARNING("MdtDriftCircleOnTrack without MdtReadoutElement "
409  << m_idHelperSvc->toString(DCT.identify()));
410  return nullptr;
411  }
412 
413  double radius = DCT.driftRadius();
414 
415  if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::BroadError) &&
416  !myStrategy.creationParameter(MuonDriftCircleErrorStrategy::ScaledError) &&
417  !myStrategy.creationParameter(MuonDriftCircleErrorStrategy::FixedError)) {
418  sigmaR = detEl->innerTubeRadius() / std::sqrt(3.0); // Tube hit
419  } else {
420  if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::ErrorAtPredictedPosition))
421  ATH_MSG_WARNING("updateError: ErrorAtPredictedPosition is not yet supported!");
422  // get error
423  if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::ParameterisedErrors)) {
424  if (myStrategy.strategy() == MuonDriftCircleErrorStrategy::Moore) {
425  sigmaR = parametrisedSigma(radius);
426  } else if (myStrategy.strategy() == MuonDriftCircleErrorStrategy::Muon) {
427  sigmaR = parametrisedSigma(radius);
428  ATH_MSG_DEBUG("Muon drift errors:" << sigmaR
429  << " for radius=" << radius);
430  }
431  } else {
432  const EventContext& ctx{Gaudi::Hive::currentContext()};
433  sigmaR = m_mdtCalibrationTool->getResolutionFromRt(ctx,
434  DCT.identify(),
435  DCT.driftTime());
436  if (sigmaR < 0.0001 || sigmaR * sigmaR < 0.0001) {
437  ATH_MSG_WARNING("Bad obtained from calibration service: error "
438  << m_idHelperSvc->toString(DCT.identify())
439  << " reso " << sigmaR << " sigma2 "
440  << sigmaR * sigmaR << " drift time " << t
441  << " original " << DCT.driftTime());
442  return nullptr;
443  }
444  }
445 
446  } // end of tube hit check
447 
448  double sigmaR2 = 0.0;
449  // Handle the errors scaling / addition of fixed terms
450  if (myStrategy.strategy() == MuonDriftCircleErrorStrategy::Moore) {
451  sigmaR2 = mooreErrorStrategy(myStrategy, sigmaR * sigmaR, DCT.identify());
452  } else if (myStrategy.strategy() == MuonDriftCircleErrorStrategy::Muon) {
453  sigmaR2 = muonErrorStrategy(myStrategy, sigmaR * sigmaR, DCT.identify());
454  ATH_MSG_DEBUG("After scaling etc:\t Muon ErrorStrategy sigmaR2 = " << sigmaR2);
455  }
456  std::unique_ptr<MdtDriftCircleOnTrack> rot{DCT.clone()};
457  rot->m_localCovariance(0, 0) = sigmaR2;
458  rot->setErrorStrategy(myStrategy);
459 
460  ATH_MSG_VERBOSE("updated error for "
461  << m_idHelperSvc->toString(DCT.identify()) << " new error "
462  << Amg::error(rot->localCovariance(), Trk::locR)
463  << " old error "
464  << Amg::error(DCT.localCovariance(), Trk::locR));
465  return rot.release();
466 }
467 
468 double MdtDriftCircleOnTrackCreator::timeOfFlight(const Amg::Vector3D& pos,
469  const double beta,
470  const double tTrack,
471  const double tShift) const {
472  return m_applyToF * (pos.mag() * s_inverseSpeedOfLight / beta) +
473  tTrack + tShift;
474 }
475 
476 double MdtDriftCircleOnTrackCreator::parametrisedSigma(double r) {
478  return 0.23 * std::exp(-std::abs(r) / 6.06) + 0.0362;
479 }
480 
481 double MdtDriftCircleOnTrackCreator::mooreErrorStrategy(const MuonDriftCircleErrorStrategy& myStrategy,
482  double sigmaR2,
483  const Identifier& id) const {
484  if (m_isMC)
485  return mooreErrorStrategyMC(myStrategy, sigmaR2, id);
486 
487  if (m_looseErrors)
488  return mooreErrorStrategyLoose(myStrategy, sigmaR2, id);
489  else
490  return mooreErrorStrategyTight(myStrategy, sigmaR2, id);
491 
492 }
493 
494 double MdtDriftCircleOnTrackCreator::mooreErrorStrategyMC(const MuonDriftCircleErrorStrategy& myStrategy,
495  double sigmaR2,
496  const Identifier& id) const {
497  ATH_MSG_DEBUG("mooreErrorStrategy sigmaR2=" << sigmaR2<<" "<<m_idHelperSvc->toString(id));
498 
499  // Moore error strategy. Hard coding numbers for the time being - hope to
500  // make them configurable some day
501  if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::Segment)) {
502  if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::FixedError) &&
503  myStrategy.creationParameter(MuonDriftCircleErrorStrategy::ScaledError)) {
504  if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::T0Refit)) {
505  ATH_MSG_VERBOSE(" segment error, t0fit ");
506  return sigmaR2 + 0.005; // Collisions with T0 refit (input)
507  } else if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::BroadError)) {
508  ATH_MSG_VERBOSE(" segment error, broad ");
509  return 4 * sigmaR2 + 0.16; // Output segments - broad errors
510  } else {
511  ATH_MSG_VERBOSE(" segment error, precise ");
512  return sigmaR2 + 0.005; // Input segments , no T0 refit
513  }
514  }
515  // Don't know how to handle other cases - error?
516  } else { // Track
517 
518  using namespace MuonStationIndex;
519  const StIndex stIdx = m_idHelperSvc->stationIndex(id);
520  if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::StationError)) {
521  if (stIdx == StIndex::BE) {
522  ATH_MSG_VERBOSE(" track error BEE ");
523  return 1.44 * sigmaR2 + 1.44; // 1.2* + 1.2 mm
524  } else if (stIdx == StIndex::EE) {
525  ATH_MSG_VERBOSE(" track error EE ");
526  if (!m_isMC && m_idHelperSvc->stationEta(id) < 0)
527  return 1.44 * sigmaR2 + 0.16; // 1.2* + 0.4 mm
528  return 1.44 * sigmaR2 + 1.; // 1.2* + 1. mm
529  } else if (m_idHelperSvc->chamberIndex(id) == ChIndex::BIS &&
530  std::abs(m_idHelperSvc->stationEta(id)) >= 7) {
531  ATH_MSG_VERBOSE(" track error BIS78 ");
532  if (std::abs(m_idHelperSvc->stationEta(id)) == 7)
533  return 1.44 * sigmaR2 + 1.; // 1.2* + 1. mm
534  else
535  return 4 * sigmaR2 + 25; // 2* + 5. mm
536  }
537  ATH_MSG_VERBOSE(" track station error ");
538  return 1.44 * sigmaR2 + 1.; // 1.2* + 1. mm
539 
540  } else if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::FixedError)) {
541 
542  if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::BroadError)) {
543  ATH_MSG_VERBOSE(" track error Fixed/Broad ");
544  return 4 * sigmaR2 + 49.; // 2* + 7 mm -> barrel/endcap overlaps
545  } else {
546  ATH_MSG_VERBOSE(" track error Fixed ");
547  return 4 * sigmaR2 + 4.; // 2* + 2mm S/L overlaps
548  }
549 
550  } else if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::ScaledError)) {
551 
552  if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::BroadError)) {
553  ATH_MSG_VERBOSE(" track error Scaled/Broad ");
554  return 2.25 * sigmaR2 + 0.09;
555  } else {
556  // use slightly smaller errors for the barrel
557  double fixedTerm = (stIdx == StIndex::BI || stIdx == StIndex::BM || stIdx == StIndex::BO)
558  ? 0.014 : 0.04;
559  if (m_doIndividualChamberReweights &&
560  m_idHelperSvc->chamberIndex(id) == ChIndex::BIL &&
561  m_idHelperSvc->stationEta(id) == 1 &&
562  m_idHelperSvc->sector(id) == 13 &&
563  m_idHelperSvc->mdtIdHelper().multilayer(id) == 1) {
564  fixedTerm = 1;
565  ATH_MSG_VERBOSE(" track error Scaled: BIL1A13, first multi layer ");
566  } else {
567  ATH_MSG_VERBOSE(" track error Scaled ");
568  }
569  return 1.44 * sigmaR2 + fixedTerm;
570  }
571  }
572  } // End of segment or track
573  return sigmaR2;
574 }
575 
576 double MdtDriftCircleOnTrackCreator::mooreErrorStrategyLoose(const MuonDriftCircleErrorStrategy& myStrategy,
577  double sigmaR2,
578  const Identifier& id) const {
579  ATH_MSG_DEBUG("mooreErrorStrategy sigmaR2=" << sigmaR2<<" "<<m_idHelperSvc->toString(id));
580 
581  // Moore error strategy. Hard coding numbers for the time being - hope to
582  // make them configurable some day
583  if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::Segment)) {
584  if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::FixedError) &&
585  myStrategy.creationParameter(MuonDriftCircleErrorStrategy::ScaledError)) {
586  if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::T0Refit)) {
587  ATH_MSG_VERBOSE(" segment error, t0fit ");
588  return sigmaR2 + 0.005; // Collisions with T0 refit (input)
589  } else if (myStrategy.creationParameter(
590  MuonDriftCircleErrorStrategy::BroadError)) {
591  ATH_MSG_VERBOSE(" segment error, broad ");
592  return 4 * sigmaR2 + 0.16; // Output segments - broad errors
593  } else {
594  ATH_MSG_VERBOSE(" segment error, precise ");
595  return sigmaR2 + 0.005; // Input segments , no T0 refit
596  }
597  }
598  // Don't know how to handle other cases - error?
599  } else { // Track
600  using namespace MuonStationIndex;
601  StIndex stIdx = m_idHelperSvc->stationIndex(id);
602  if (myStrategy.creationParameter(
603  MuonDriftCircleErrorStrategy::StationError)) {
604  if (stIdx == StIndex::BE) {
605  ATH_MSG_VERBOSE(" track error BEE ");
606  return 1.44 * sigmaR2 + 4; // 1.2* + 2 mm
607  } else if (stIdx == StIndex::EE) {
608  ATH_MSG_VERBOSE(" track error EE ");
609  return 1.44 * sigmaR2 + 0.04; // 1.2* + 0.2 mm
610  } else if (m_idHelperSvc->chamberIndex(id) == ChIndex::BIS &&
611  std::abs(m_idHelperSvc->stationEta(id)) >= 7) {
612  ATH_MSG_VERBOSE(" track error BIS78 ");
613  if (std::abs(m_idHelperSvc->stationEta(id)) == 7)
614  return 1.44 * sigmaR2 + 1.; // 1.2* + 1. mm
615  return 4 * sigmaR2 + 25; // 2* + 5. mm
616  } else if (m_idHelperSvc->mdtIdHelper().stationName(id) == m_BME_idx &&
617  m_idHelperSvc->stationPhi(id) == 7) {
618  ATH_MSG_VERBOSE(" track error BME ");
619  return 1.44 * sigmaR2 + 0.25; // 1.2* + 0.5 mm
620  }
622  else if (m_idHelperSvc->chamberIndex(id) == ChIndex::BOL && std::abs(m_idHelperSvc->stationEta(id)) == 7 &&
623  m_idHelperSvc->stationPhi(id) == 7) {
624  ATH_MSG_VERBOSE(" track error BOE ");
625  return 1.44 * sigmaR2 + 0.25; // 1.2* + 0.5 mm
626  }
627  ATH_MSG_VERBOSE(" track station error ");
628  return 1.44 * sigmaR2 + 0.04; // 1.2* + 0.2 mm
629 
630  } else if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::FixedError)) {
631 
632  if (myStrategy.creationParameter(
633  MuonDriftCircleErrorStrategy::BroadError)) {
634  ATH_MSG_VERBOSE(" track error Fixed/Broad ");
635  return 4 * sigmaR2 + 4.; // 2* + 2 mm -> barrel/endcap overlaps
636  } else {
637  ATH_MSG_VERBOSE(" track error Fixed ");
638  return 4 * sigmaR2 + 4.; // 2* + 2mm S/L overlaps
639  }
640 
641  } else if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::ScaledError)) {
642 
643  if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::BroadError)) {
644  ATH_MSG_VERBOSE(" track error Scaled/Broad ");
645  return 2.25 * sigmaR2 + 0.09;
646  } else {
647  // use slightly smaller errors for the barrel
648  double fixedTerm = (stIdx == StIndex::BI || stIdx == StIndex::BM || stIdx == StIndex::BO)
649  ? 0.015 : 0.015;
650  if (m_doIndividualChamberReweights &&
651  m_idHelperSvc->chamberIndex(id) == ChIndex::BIL && m_idHelperSvc->stationEta(id) == 1 &&
652  m_idHelperSvc->sector(id) == 13 && m_idHelperSvc->mdtIdHelper().multilayer(id) == 1) {
653  fixedTerm = 1;
654  ATH_MSG_VERBOSE(" track error Scaled: BIL1A13, first multi layer ");
655  } else {
656  ATH_MSG_VERBOSE(" track error Scaled ");
657  }
658 
659  return 1.44 * sigmaR2 + fixedTerm;
660  }
661  }
662  } // End of segment or track
663  return sigmaR2;
664 }
665 
666 double MdtDriftCircleOnTrackCreator::mooreErrorStrategyTight(const MuonDriftCircleErrorStrategy& myStrategy,
667  double sigmaR2,
668  const Identifier& id) const {
669  ATH_MSG_DEBUG("mooreErrorStrategy sigmaR2=" << sigmaR2);
670 
671  // Moore error strategy. Hard coding numbers for the time being - hope to
672  // make them configurable some day
673  if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::Segment)) {
674  if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::FixedError) &&
675  myStrategy.creationParameter(MuonDriftCircleErrorStrategy::ScaledError)) {
676  if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::T0Refit)) {
677  ATH_MSG_VERBOSE(" segment error, t0fit ");
678  return sigmaR2 + 0.005; // Collisions with T0 refit (input)
679  } else if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::BroadError)) {
680  ATH_MSG_VERBOSE(" segment error, broad ");
681  return 4 * sigmaR2 + 0.16; // Output segments - broad errors
682  } else {
683  ATH_MSG_VERBOSE(" segment error, precise ");
684  return sigmaR2 + 0.005; // Input segments , no T0 refit
685  }
686  }
687  // Don't know how to handle other cases - error?
688  } else { // Track
689  using namespace MuonStationIndex;
690  StIndex stIdx = m_idHelperSvc->stationIndex(id);
691  if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::StationError)) {
692  if (stIdx == StIndex::BE) {
693  ATH_MSG_VERBOSE(" track error BEE ");
694  return 1.44 * sigmaR2 + 0.04; // 1.2* + 0.2 mm
695  } else if (stIdx == StIndex::EE) {
696  ATH_MSG_VERBOSE(" track error EE ");
697  if (m_idHelperSvc->isSmallChamber(id))
698  return 1.21 * sigmaR2 + 0.01; // 1.1* + 0.1 mm
699  else
700  return 1.21 * sigmaR2 + 0.01; // 1.1* + 0.1 mm
701  } else if (m_idHelperSvc->chamberIndex(id) == ChIndex::BIS &&
702  std::abs(m_idHelperSvc->stationEta(id)) >= 7) {
703  ATH_MSG_VERBOSE(" track error BIS78 ");
704  if (std::abs(m_idHelperSvc->stationEta(id)) == 7)
705  return 1.44 * sigmaR2 + 1.; // 1.2* + 1. mm
706 
707  return 4 * sigmaR2 + 1.; // 2* + 1. mm
708  } else if (stIdx == StIndex::BM &&
709  m_idHelperSvc->stationPhi(id) == 7 &&
710  (m_idHelperSvc->mdtIdHelper()).stationName(id) == m_BME_idx) {
711  ATH_MSG_VERBOSE(" track error BME ");
712  return 1.21 * sigmaR2 + 0.25; // 1.1* + 0.5 mm
713  }
715  else if (m_idHelperSvc->chamberIndex(id) == ChIndex::BOL && std::abs(m_idHelperSvc->stationEta(id)) == 7 &&
716  m_idHelperSvc->stationPhi(id) == 7) {
717  ATH_MSG_VERBOSE(" track error BOE ");
718  return 1.21 * sigmaR2 + 0.25; // 1.1* + 0.5 mm
719  } else if (m_idHelperSvc->chamberIndex(id) == ChIndex::EEL && m_idHelperSvc->stationEta(id) < 0 &&
720  m_idHelperSvc->stationPhi(id) == 3) {
721  ATH_MSG_VERBOSE(" track error EEL1C05 ");
722  return 1.21 * sigmaR2 + 25.; // 1.1* + 5 mm
723  }
724  ATH_MSG_VERBOSE(" track station error ");
725  return 1.21 * sigmaR2 + 0.04; // 1.1* + 0.2 mm
726 
727  } else if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::FixedError)) {
728 
729  if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::BroadError)) {
730  ATH_MSG_VERBOSE(" track error Fixed/Broad ");
731  return 4 * sigmaR2 + 4.; // 2* + 2 mm -> barrel/endcap overlaps
732  } else {
733  ATH_MSG_VERBOSE(" track error Fixed ");
734  return 4 * sigmaR2 + 4.; // 2* + 2mm S/L overlaps
735  }
736 
737  } else if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::ScaledError)) {
738 
739  if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::BroadError)) {
740  ATH_MSG_VERBOSE(" track error Scaled/Broad ");
741  return 2.25 * sigmaR2 + 0.09;
742  } else {
743 
744  // use slightly smaller errors for the barrel
745  //
746  double fixedTerm = 0.01;
747  if (m_doIndividualChamberReweights) {
748  if (m_idHelperSvc->chamberIndex(id) == ChIndex::BIL && m_idHelperSvc->stationEta(id) == 1 &&
749  m_idHelperSvc->sector(id) == 13 && m_idHelperSvc->mdtIdHelper().multilayer(id) == 1) {
750  fixedTerm = 1;
751  ATH_MSG_VERBOSE(" track error Scaled: BIL1A13, first multi layer ");
752  }
753  } else {
754  ATH_MSG_VERBOSE(" track error Scaled ");
755  }
756 
757  return 1.21 * sigmaR2 + fixedTerm;
758  }
759  }
760  } // End of segment or track
761  return sigmaR2;
762 }
763 
764 double MdtDriftCircleOnTrackCreator::muonErrorStrategy(const MuonDriftCircleErrorStrategy& myStrategy,
765  double sigmaR2,
766  const Identifier& /*id*/) const {
767 
768  //
769  // the new muonErrorStrategy is identical for Data and MC
770  // it assumes that for tracks the alignment uncertainties are added later
771  // this is done by the AignmentErrorTool where AlignmentEffectsOnTrack are
772  // used. (for segment errors the mooreStrategy is coded)
773  //
774  // it is inspired by the mooreErrorStrategyTight but does not need a constant term
775  //
776 
777  ATH_MSG_DEBUG("muonErrorStrategy sigmaR2=" << sigmaR2);
778 
779  // Muon error strategy. Hard coding numbers for the time being - hope to
780  // make them configurable some day
781  if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::Segment)) {
782  if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::FixedError) &&
783  myStrategy.creationParameter(MuonDriftCircleErrorStrategy::ScaledError)) {
784  if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::T0Refit)) {
785  ATH_MSG_VERBOSE(" segment error, t0fit ");
786  return sigmaR2 + 0.005; // Collisions with T0 refit (input)
787  } else if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::BroadError)) {
788  ATH_MSG_VERBOSE(" segment error, broad ");
789  return 4 * sigmaR2 + 0.16; // Output segments - broad errors
790  } else {
791  ATH_MSG_VERBOSE(" segment error, precise ");
792  return sigmaR2 + 0.005; // Input segments , no T0 refit
793  }
794  }
795  } else { // Track
796  if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::StationError)) {
797  ATH_MSG_VERBOSE(" track station error ");
798  return 1.21 * sigmaR2; // 1.1* mm
799  } else if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::FixedError)) {
800  ATH_MSG_VERBOSE(" track error Fixed ");
801  return 4 * sigmaR2; // 2*
802  } else if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::ScaledError)) {
803  if (myStrategy.creationParameter(MuonDriftCircleErrorStrategy::BroadError)) {
804  ATH_MSG_VERBOSE(" track error Scaled/Broad ");
805  return 2.25 * sigmaR2;
806  } else {
807  ATH_MSG_VERBOSE(" Track scaled error ");
808  return 1.21 * sigmaR2;
809  }
810  }
811  } // End of segment or track
812  return sigmaR2;
813 }
814 }
Muon::MdtDriftCircleOnTrackCreator::mooreErrorStrategyTight
double mooreErrorStrategyTight(const MuonDriftCircleErrorStrategy &myStrategy, double sigmaR, const Identifier &id) const
Definition: MdtDriftCircleOnTrackCreator.cxx:666
Muon::MdtDriftCircleOnTrackCreator::parametrisedSigma
static double parametrisedSigma(double r)
Definition: MdtDriftCircleOnTrackCreator.cxx:476
xAOD::strategy
strategy
Definition: L2CombinedMuon_v1.cxx:108
Muon::MdtDriftCircleOnTrackCreator::mooreErrorStrategy
double mooreErrorStrategy(const MuonDriftCircleErrorStrategy &myStrategy, double sigmaR, const Identifier &id) const
Definition: MdtDriftCircleOnTrackCreator.cxx:481
beamspotman.r
def r
Definition: beamspotman.py:672
Trk::LocalParameters
Definition: LocalParameters.h:98
Muon::MdtDriftCircleOnTrackCreator::CalibrationOutput::calibOk
bool calibOk
Definition: MdtDriftCircleOnTrackCreator.h:177
Muon::MuonDriftCircleErrorStrategy
Definition: MuonDriftCircleErrorStrategy.h:15
Trk::PrepRawDataType::MdtPrepData
@ MdtPrepData
MdtReadoutElement.h
Muon::MuonDriftCircleErrorStrategy::Muon
@ Muon
Definition: MuonDriftCircleErrorStrategy.h:17
MuonDriftCircleErrorStrategy.h
Muon::MdtDriftCircleOnTrackCreator::CalibrationOutput::locPars
Trk::LocalParameters locPars
Definition: MdtDriftCircleOnTrackCreator.h:174
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
Muon::MdtDriftCircleOnTrackCreator::m_errorAtPredictedPosition
Gaudi::Property< bool > m_errorAtPredictedPosition
Add a term to the error to account for very poorly aligned stations.
Definition: MdtDriftCircleOnTrackCreator.h:257
Muon::MdtDriftCircleOnTrackCreator::COSMICS_TRIGGERTIME
@ COSMICS_TRIGGERTIME
case for normal cosmic data with rpc trigger or simulation including TOF.
Definition: MdtDriftCircleOnTrackCreator.h:82
Amg::MatrixX
Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic > MatrixX
Dynamic Matrix - dynamic allocation.
Definition: EventPrimitives.h:27
StraightLineSurface.h
TrackParameters.h
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
Muon::MuonDriftCircleErrorStrategy::setCalibWindow
void setCalibWindow(unsigned long)
Only the first nCalibWindowBits bits will be stored!
Definition: MuonDriftCircleErrorStrategy.h:69
Muon::MdtDriftCircleOnTrackCreator::m_stationError
Gaudi::Property< bool > m_stationError
Add a special error to account for the T0 refit.
Definition: MdtDriftCircleOnTrackCreator.h:259
Trk::DriftCircleStatus
DriftCircleStatus
Enumerates the 'status' of the wire on which the tracks passed (based on the TRT_Side enum,...
Definition: DriftCircleStatus.h:16
MdtCalibInput
Definition: MdtCalibInput.h:34
Muon::MuonStationIndex::ChIndex::EEL
@ EEL
MuonGM::MdtReadoutElement::innerTubeRadius
double innerTubeRadius() const
Returns the inner tube radius excluding the aluminium walls.
Amg::Vector2D
Eigen::Matrix< double, 2, 1 > Vector2D
Definition: GeoPrimitives.h:48
MdtCalibInput::legacySurface
const Trk::StraightLineSurface & legacySurface() const
Returns the assocaited ideal surface (Throw exception if no legacy RE is available)
Definition: MdtCalibInput.cxx:138
Muon::MuonStationIndex::ChIndex::BIL
@ BIL
EventPrimitivesHelpers.h
Trk::PrepRawData::localCovariance
const Amg::MatrixX & localCovariance() const
return const ref to the error matrix
ParticleTest.tp
tp
Definition: ParticleTest.py:25
MdtCalibInput::closestApproach
const Amg::Vector3D & closestApproach() const
Returns the point of closest approach to the wire.
Definition: MdtCalibInput.cxx:105
Muon::MdtDriftCircleOnTrackCreator::m_doMdt
Gaudi::Property< bool > m_doMdt
Process MDT ROTs.
Definition: MdtDriftCircleOnTrackCreator.h:226
Muon::MuonDriftCircleErrorStrategy::Moore
@ Moore
Definition: MuonDriftCircleErrorStrategy.h:17
Trk::RIO_OnTrack
Definition: RIO_OnTrack.h:70
Muon::MdtDriftCircleOnTrackCreator::m_globalToLocalTolerance
Gaudi::Property< double > m_globalToLocalTolerance
Definition: MdtDriftCircleOnTrackCreator.h:233
MdtPrepData.h
Muon::MdtDriftCircleOnTrackCreator::ATLTIME
@ ATLTIME
normal time of flight corrections assuming IP + light speed to be used for simulated data and collisi...
Definition: MdtDriftCircleOnTrackCreator.h:74
Trk::locR
@ locR
Definition: ParamDefs.h:44
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
Muon::MdtDriftCircleOnTrack::detectorElement
virtual const MuonGM::MdtReadoutElement * detectorElement() const override final
Returns the detector element, assoicated with the PRD of this class.
Definition: MdtDriftCircleOnTrack.h:268
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
Muon::MdtDriftCircleOnTrackCreator::NO_CORRECTIONS
@ NO_CORRECTIONS
special case for cosmics taken with scintilator trigger which is read out so the offset with respect ...
Definition: MdtDriftCircleOnTrackCreator.h:77
MdtDriftCircleOnTrack.h
Muon::MdtDriftCircleOnTrackCreator::muonErrorStrategy
double muonErrorStrategy(const MuonDriftCircleErrorStrategy &myStrategy, double sigmaR, const Identifier &id) const
Definition: MdtDriftCircleOnTrackCreator.cxx:764
Muon::MdtDriftCircleOnTrackCreator::MdtDriftCircleOnTrackCreator
MdtDriftCircleOnTrackCreator(const std::string &, const std::string &, const IInterface *)
Definition: MdtDriftCircleOnTrackCreator.cxx:26
Muon
NRpcCablingAlg reads raw condition data and writes derived condition data to the condition store.
Definition: TrackSystemController.h:45
drawFromPickle.exp
exp
Definition: drawFromPickle.py:36
Muon::MdtDriftCircleOnTrackCreator::m_BME_idx
int m_BME_idx
Definition: MdtDriftCircleOnTrackCreator.h:279
Muon::MdtDriftCircleOnTrackCreator::updateSign
virtual void updateSign(MdtDriftCircleOnTrack &rot, const Trk::DriftCircleSide si) const override final
Update of the sign of the drift radius.
Definition: MdtDriftCircleOnTrackCreator.cxx:277
Property
Support class for PropertyMgr.
Definition: Property.h:23
Muon::IMdtDriftCircleOnTrackCreator::MdtRotPtr
MdtDriftCircleOnTrack * MdtRotPtr
Definition: IMdtDriftCircleOnTrackCreator.h:26
Muon::MuonDriftCircleErrorStrategy::PropCorrection
@ PropCorrection
Propagation correction was applied in calibration.
Definition: MuonDriftCircleErrorStrategy.h:26
MdtCalibInput::identify
const Identifier & identify() const
Returns the Identifier of the hit.
Definition: MdtCalibInput.cxx:84
Muon::MuonDriftCircleErrorStrategy::TempCorrection
@ TempCorrection
Temperature correction was applied in calibration.
Definition: MuonDriftCircleErrorStrategy.h:27
Muon::MdtDriftCircleOnTrack::driftTime
double driftTime() const
Returns the value of the drift time used to obtain the drift radius.
Definition: MdtDriftCircleOnTrack.h:280
Muon::MdtDriftCircleOnTrackCreator::m_mdtCalibrationTool
ToolHandle< IMdtCalibrationTool > m_mdtCalibrationTool
Definition: MdtDriftCircleOnTrackCreator.h:223
Trk::DefinedParameter
std::pair< double, ParamDefs > DefinedParameter
Definition: DefinedParameter.h:27
Muon::MuonDriftCircleErrorStrategy::T0Refit
@ T0Refit
A special error was applied to account for the T0 refit (user defined via jobProperties)
Definition: MuonDriftCircleErrorStrategy.h:24
Trk::UNDECIDED
@ UNDECIDED
sign of drift radius has not been determined
Definition: DriftCircleStatus.h:20
Trk::StraightLineSurface::globalToLocal
virtual bool globalToLocal(const Amg::Vector3D &glob, const Amg::Vector3D &mom, Amg::Vector2D &loc) const override final
Specified for StraightLineSurface: GlobalToLocal method without dynamic memory allocation This method...
Definition: StraightLineSurface.cxx:164
Muon::MdtDriftCircleOnTrackCreator::m_errorStrategy
MuonDriftCircleErrorStrategy m_errorStrategy
< Error strategy for created ROTs
Definition: MdtDriftCircleOnTrackCreator.h:238
Muon::MdtDriftCircleOnTrackCreator::COSMICS_TOF
@ COSMICS_TOF
Definition: MdtDriftCircleOnTrackCreator.h:86
Muon::MuonDriftCircleErrorStrategy::SlewCorrection
@ SlewCorrection
Slewing correction was applied in calibration.
Definition: MuonDriftCircleErrorStrategy.h:29
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
TRT::Hit::driftTime
@ driftTime
Definition: HitInfo.h:43
Trk::locZ
@ locZ
local cylindrical
Definition: ParamDefs.h:42
Muon::MuonDriftCircleErrorStrategy::FixedError
@ FixedError
A fixed error is given to this hit (user defined via jobProperties)
Definition: MuonDriftCircleErrorStrategy.h:20
ParticleGun_EoverP_Config.momentum
momentum
Definition: ParticleGun_EoverP_Config.py:63
Muon::MuonStationIndex::ChIndex::BIS
@ BIS
MuonGM::MdtReadoutElement
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MdtReadoutElement.h:51
Muon::MdtDriftCircleOnTrackCreator::initialize
virtual StatusCode initialize() override final
Definition: MdtDriftCircleOnTrackCreator.cxx:35
MdtRtRelation.h
Muon::MdtDriftCircleOnTrackCreator::m_looseErrors
Gaudi::Property< bool > m_looseErrors
Definition: MdtDriftCircleOnTrackCreator.h:272
Muon::MuonDriftCircleErrorStrategy::TofCorrection
@ TofCorrection
Time of flight correction was applied in calibration.
Definition: MuonDriftCircleErrorStrategy.h:25
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
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
Trk::driftRadius
@ driftRadius
trt, straws
Definition: ParamDefs.h:53
Trk::PrepRawData::type
virtual bool type(PrepRawDataType type) const
Interface method checking the type.
Definition: PrepRawData.h:133
Muon::MdtDriftCircleOnTrackCreator::m_t0Refit
Gaudi::Property< bool > m_t0Refit
Use error strategy for segments by default.
Definition: MdtDriftCircleOnTrackCreator.h:261
sign
int sign(int a)
Definition: TRT_StrawNeighbourSvc.h:108
Muon::MdtDriftCircleOnTrackCreator::mooreErrorStrategyLoose
double mooreErrorStrategyLoose(const MuonDriftCircleErrorStrategy &myStrategy, double sigmaR, const Identifier &id) const
Definition: MdtDriftCircleOnTrackCreator.cxx:576
Muon::MdtDriftCircleOnTrackCreator::m_doIndividualChamberReweights
Gaudi::Property< bool > m_doIndividualChamberReweights
toggle between MC and data alignment errors (to be removed in rel.
Definition: MdtDriftCircleOnTrackCreator.h:265
Muon::MdtDriftCircleOnTrackCreator::s_inverseSpeedOfLight
static constexpr double s_inverseSpeedOfLight
Definition: MdtDriftCircleOnTrackCreator.h:277
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
Muon::MuonDriftCircleErrorStrategy::BackgroundCorrection
@ BackgroundCorrection
Background correction was applied in calibration.
Definition: MuonDriftCircleErrorStrategy.h:30
Muon::MdtDriftCircleOnTrack::clone
virtual MdtDriftCircleOnTrack * clone() const override final
Pseudo-constructor, needed to avoid excessive RTTI.
Definition: MdtDriftCircleOnTrack.h:256
Trk::NODRIFTTIME
@ NODRIFTTIME
drift time was not used - drift radius is 0.
Definition: DriftCircleStatus.h:24
Trk::ParametersBase
Definition: ParametersBase.h:55
Muon::MdtDriftCircleOnTrack::driftRadius
double driftRadius() const
Returns the value of the drift radius.
Definition: MdtDriftCircleOnTrack.h:277
IRtResolution.h
Muon::MuonDriftCircleErrorStrategy::Segment
@ Segment
Treating a segment or a track.
Definition: MuonDriftCircleErrorStrategy.h:31
Muon::MdtDriftCircleOnTrack::m_status
Trk::DriftCircleStatus m_status
information on the status of the Mdt measurement - see Trk::DriftCircleStatus for definitions
Definition: MdtDriftCircleOnTrack.h:220
Muon::MdtDriftCircleOnTrackCreator::mooreErrorStrategyMC
double mooreErrorStrategyMC(const MuonDriftCircleErrorStrategy &myStrategy, double sigmaR, const Identifier &id) const
Definition: MdtDriftCircleOnTrackCreator.cxx:494
Muon::MuonDriftCircleErrorStrategy::ErrorAtPredictedPosition
@ ErrorAtPredictedPosition
Definition: MuonDriftCircleErrorStrategy.h:23
MdtCalibOutput
Definition: MdtCalibOutput.h:10
Muon::MuonDriftCircleErrorStrategy::MagFieldCorrection
@ MagFieldCorrection
Magnetic field correction was applied in calibration
Definition: MuonDriftCircleErrorStrategy.h:28
Trk::MeasurementBase::localCovariance
const Amg::MatrixX & localCovariance() const
Interface method to get the localError.
Definition: MeasurementBase.h:138
Trk::DECIDED
@ DECIDED
sign of drift radius has been determined
Definition: DriftCircleStatus.h:18
Muon::MuonStationIndex::StIndex::BO
@ BO
Muon::MuonStationIndex::StIndex
StIndex
enum to classify the different station layers in the muon spectrometer
Definition: MuonStationIndex.h:23
Trk::PrepRawData
Definition: PrepRawData.h:62
Trk::PrepRawData::identify
Identifier identify() const
return the identifier
Muon::MuonDriftCircleErrorStrategy::StationError
@ StationError
A term is added to account for misaligned.
Definition: MuonDriftCircleErrorStrategy.h:22
Muon::MdtDriftCircleOnTrackCreator::m_doSegments
Gaudi::Property< bool > m_doSegments
Deweight individual chambers.
Definition: MdtDriftCircleOnTrackCreator.h:263
Muon::MuonStationIndex::StIndex::BE
@ BE
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
Trk::PrepRawData::localPosition
const Amg::Vector2D & localPosition() const
return the local position reference
Muon::MdtDriftCircleOnTrackCreator::m_useErrorParametrisation
Gaudi::Property< bool > m_useErrorParametrisation
Use the predicted track position to correct the Error.
Definition: MdtDriftCircleOnTrackCreator.h:252
Muon::MdtDriftCircleOnTrack
This class represents the corrected MDT measurements, where the corrections include the effects of wi...
Definition: MdtDriftCircleOnTrack.h:37
Muon::MdtDriftCircleOnTrack::setLocalParameters
virtual void setLocalParameters(const Trk::LocalParameters &locPos)
Sets the local parameters.
Definition: MdtDriftCircleOnTrack.h:275
Muon::MdtDriftCircleOnTrackCreator::getLocalMeasurement
CalibrationOutput getLocalMeasurement(const EventContext &ctx, const MdtPrepData &DC, const MdtCalibInput &calibInput, const MuonDriftCircleErrorStrategy &strategy) const
preform the mdt calibration
Definition: MdtDriftCircleOnTrackCreator.cxx:295
Muon::MdtPrepData
Class to represent measurements from the Monitored Drift Tubes.
Definition: MdtPrepData.h:33
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
ParticleGun_SamplingFraction.radius
radius
Definition: ParticleGun_SamplingFraction.py:96
Muon::MuonDriftCircleErrorStrategy::setParameter
void setParameter(CreationParameter, bool value)
Definition: MuonDriftCircleErrorStrategy.h:63
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:16
Muon::MuonDriftCircleErrorStrategy::setStrategy
void setStrategy(Strategy)
Select the strategy to be used - only one can be set at a time.
Definition: MuonDriftCircleErrorStrategy.h:54
Trk::MeasurementBase::localParameters
const LocalParameters & localParameters() const
Interface method to get the LocalParameters.
Definition: MeasurementBase.h:132
Muon::MdtDriftCircleOnTrackCreator::timeOfFlight
double timeOfFlight(const Amg::Vector3D &pos, const double beta, const double tTrack, const double tShift) const
Definition: MdtDriftCircleOnTrackCreator.cxx:468
Trk::DriftCircleSide
DriftCircleSide
Enumerates the 'side' of the wire on which the tracks passed (i.e.
Definition: DriftCircleSide.h:16
Muon::MuonDriftCircleErrorStrategy::ParameterisedErrors
@ ParameterisedErrors
Use parameterised errors.
Definition: MuonDriftCircleErrorStrategy.h:21
Muon::MdtDriftCircleOnTrackCreator::m_isMC
Gaudi::Property< bool > m_isMC
toggle whether the time of flight is included in the t0 shifts
Definition: MdtDriftCircleOnTrackCreator.h:267
Trk::MeasurementBase::m_localCovariance
Amg::MatrixX m_localCovariance
Definition: MeasurementBase.h:112
Muon::MdtDriftCircleOnTrackCreator::m_wasConfigured
Gaudi::Property< bool > m_wasConfigured
Definition: MdtDriftCircleOnTrackCreator.h:274
Muon::MdtDriftCircleOnTrackCreator::m_createTubeHits
Gaudi::Property< bool > m_createTubeHits
Scale ROTs depending on local alignment (i.e.
Definition: MdtDriftCircleOnTrackCreator.h:246
Trk::Surface::globalToLocal
virtual bool globalToLocal(const Amg::Vector3D &glob, const Amg::Vector3D &mom, Amg::Vector2D &loc) const =0
Specified by each surface type: GlobalToLocal method without dynamic memory allocation - boolean chec...
Muon::MdtDriftCircleOnTrackCreator::getTriggerTime
double getTriggerTime() const
currently returns 0.
Definition: MdtDriftCircleOnTrackCreator.h:196
Muon::MdtDriftCircleOnTrackCreator::m_applyToF
Gaudi::Property< bool > m_applyToF
toggle between loose errors (initial before alignment) and tight after alignment
Definition: MdtDriftCircleOnTrackCreator.h:269
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
python.Constants.INFO
int INFO
Definition: Control/AthenaCommon/python/Constants.py:15
IRtRelation.h
MdtFullCalibData.h
Trk::RIO_OnTrack::identify
Identifier identify() const
return the identifier -extends MeasurementBase
Definition: RIO_OnTrack.h:152
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
Muon::MdtDriftCircleOnTrackCreator::correct
virtual Trk::RIO_OnTrack * correct(const Trk::PrepRawData &prd, const Trk::TrackParameters &tp, const EventContext &) const override
Base class method for correct.
Definition: MdtDriftCircleOnTrackCreator.cxx:384
Muon::MuonDriftCircleErrorStrategy::BroadError
@ BroadError
Definition: MuonDriftCircleErrorStrategy.h:18
Muon::MdtDriftCircleOnTrackCreator::m_timeCorrectionType
Gaudi::Property< int > m_timeCorrectionType
Definition: MdtDriftCircleOnTrackCreator.h:228
Muon::MdtDriftCircleOnTrackCreator::CalibrationOutput::locErr
Amg::MatrixX locErr
Definition: MdtDriftCircleOnTrackCreator.h:175
Muon::MuonDriftCircleErrorStrategy::ScaledError
@ ScaledError
Definition: MuonDriftCircleErrorStrategy.h:19
Trk::LEFT
@ LEFT
the drift radius is negative (see Trk::AtaStraightLine)
Definition: DriftCircleSide.h:20
Muon::MdtDriftCircleOnTrackCreator::createRIO_OnTrack
virtual MdtRotPtr createRIO_OnTrack(const MdtPrepData &prd, const Amg::Vector3D &globalPos, const Amg::Vector3D *gdir=nullptr, const double t0Shift=0., const MuonDriftCircleErrorStrategy *strategy=nullptr, const double beta=1, const double tTrack=1) const override final
Calibrate a MdtPrepData object.
Definition: MdtDriftCircleOnTrackCreator.cxx:139
Muon::MdtDriftCircleOnTrackCreator::m_scaleMdtCov
Gaudi::Property< bool > m_scaleMdtCov
Fixed error (not tube radius)
Definition: MdtDriftCircleOnTrackCreator.h:248
ToolSettings
MdtCalibrationTool::ToolSettings ToolSettings
Definition: MdtCalibrationTool.cxx:28
AthAlgTool
Definition: AthAlgTool.h:26
Muon::MuonStationIndex::StIndex::BI
@ BI
MdtCalibInput::trackDirection
const Amg::Vector3D & trackDirection() const
Returns the track direction (Can be zero)
Definition: MdtCalibInput.cxx:109
MuonParameters::beta
@ beta
Definition: MuonParamDefs.h:144
Muon::MuonStationIndex::StIndex::BM
@ BM
Muon::CalibrationOutput
MdtDriftCircleOnTrackCreator::CalibrationOutput CalibrationOutput
Definition: MdtDriftCircleOnTrackCreator.cxx:24
Muon::MdtDriftCircleOnTrackCreator::NumberOfTimingModes
@ NumberOfTimingModes
Definition: MdtDriftCircleOnTrackCreator.h:88
Trk::Surface
Definition: Tracking/TrkDetDescr/TrkSurfaces/TrkSurfaces/Surface.h:79
Muon::MdtDriftCircleOnTrackCreator::CalibrationOutput
struct to hold output of calibration
Definition: MdtDriftCircleOnTrackCreator.h:168
Muon::MuonDriftCircleErrorStrategy::creationParameter
bool creationParameter(CreationParameter) const
Definition: MuonDriftCircleErrorStrategy.h:82
Muon::MdtDriftCircleOnTrackCreator::updateError
virtual MdtRotPtr updateError(const MdtDriftCircleOnTrack &DCT, const Trk::TrackParameters *pars=nullptr, const MuonDriftCircleErrorStrategy *strategy=nullptr) const override
Update error of a ROT without changing the drift radius.
Definition: MdtDriftCircleOnTrackCreator.cxx:396
Muon::MdtDriftCircleOnTrackCreator::CalibrationOutput::driftTime
double driftTime
Definition: MdtDriftCircleOnTrackCreator.h:176
Muon::MdtDriftCircleOnTrackCreator::m_doFixedError
Gaudi::Property< bool > m_doFixedError
Use parameterised errors.
Definition: MdtDriftCircleOnTrackCreator.h:250
Muon::MdtDriftCircleOnTrackCreator::m_defaultStrategy
Gaudi::Property< std::string > m_defaultStrategy
if set to true, the ROT creator create 'tube' hits with a local position of 0 and an error of tube ra...
Definition: MdtDriftCircleOnTrackCreator.h:241
generate::Zero
void Zero(TH1D *hin)
Definition: generate.cxx:32
Muon::MuonDriftCircleErrorStrategy::strategy
Strategy strategy() const
Definition: MuonDriftCircleErrorStrategy.h:102
Muon::MuonStationIndex::ChIndex::BOL
@ BOL
Identifier
Definition: IdentifierFieldParser.cxx:14
MdtDriftCircleOnTrackCreator.h
Muon::MdtDriftCircleOnTrackCreator::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition: MdtDriftCircleOnTrackCreator.h:221
Generated on Mon Sep 29 2025 21:14:29 for ATLAS Offline Software by   doxygen 1.8.18