ATLAS Offline Software
Loading...
Searching...
No Matches
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
21namespace Muon {
22
23using MdtRotPtr = MdtDriftCircleOnTrackCreator::MdtRotPtr;
24using CalibrationOutput = MdtDriftCircleOnTrackCreator::CalibrationOutput;
25
26MdtDriftCircleOnTrackCreator::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
35StatusCode 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
139MdtRotPtr 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
277void 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
295CalibrationOutput 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
374MdtRotPtr 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
384Trk::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}
396MdtRotPtr 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
468double 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
476double MdtDriftCircleOnTrackCreator::parametrisedSigma(double r) {
478 return 0.23 * std::exp(-std::abs(r) / 6.06) + 0.0362;
479}
480
481double 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
494double 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
576double 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
666double 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
764double 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}
endmsg
#define endmsg
Definition AnalysisConfig_Ntuple.cxx:63
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition AthMsgStreamMacros.h:33
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition AthMsgStreamMacros.h:34
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition AthMsgStreamMacros.h:28
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition AthMsgStreamMacros.h:32
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition AthMsgStreamMacros.h:29
ss
static Double_t ss
Definition LArPhysWaveHECTool.cxx:37
ToolSettings
MdtCalibrationTool::ToolSettings ToolSettings
Definition MdtCalibrationTool.cxx:28
sign
int sign(int a)
Definition TRT_StrawNeighbourSvc.h:108
AthAlgTool::AthAlgTool
AthAlgTool(const std::string &type, const std::string &name, const IInterface *parent)
Constructor with parameters:
Definition AthAlgTool.cxx:16
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition AthCommonMsg.h:24
MdtCalibInput::setClosestApproach
void setClosestApproach(const Amg::Vector3D &approach)
Sets the closest approach.
Definition MdtCalibInput.cxx:106
MdtCalibInput::timeOfFlight
double timeOfFlight() const
Returns the time of flight.
Definition MdtCalibInput.cxx:115
MdtCalibInput::setTimeOfFlight
void setTimeOfFlight(const double toF)
Sets the time of flight (Usually globPos.mag() * inverseSpeed of light)
Definition MdtCalibInput.cxx:116
MdtCalibInput::triggerTime
double triggerTime() const
Returns the trigger offset time.
Definition MdtCalibInput.cxx:118
MdtCalibInput::setTrackDirection
void setTrackDirection(const Amg::Vector3D &trackDir, bool hasPhi)
Sets the direction of the externally determined track.
Definition MdtCalibInput.cxx:110
MdtCalibInput::setTriggerTime
void setTriggerTime(const double trigTime)
Sets the trigger offset time.
Definition MdtCalibInput.cxx:119
MdtCalibInput::closestApproach
const Amg::Vector3D & closestApproach() const
Returns the point of closest approach to the wire.
Definition MdtCalibInput.cxx:105
MdtCalibInput::identify
const Identifier & identify() const
Returns the Identifier of the hit.
Definition MdtCalibInput.cxx:84
MdtCalibInput::legacySurface
const Trk::StraightLineSurface & legacySurface() const
Returns the assocaited ideal surface (Throw exception if no legacy RE is available)
Definition MdtCalibInput.cxx:138
MdtCalibInput::trackDirection
const Amg::Vector3D & trackDirection() const
Returns the track direction (Can be zero)
Definition MdtCalibInput.cxx:109
MdtCalibOutput::driftRadiusUncert
double driftRadiusUncert() const
Returns the uncertainty on the drift radius.
Definition MdtCalibOutput.cxx:20
MdtCalibOutput::driftRadius
double driftRadius() const
Returns the drift radius of the calibrated object.
Definition MdtCalibOutput.cxx:19
MdtCalibOutput::driftTime
double driftTime() const
Returns the drift time inside the tube.
Definition MdtCalibOutput.cxx:28
MuonGM::MdtReadoutElement::innerTubeRadius
double innerTubeRadius() const
Returns the inner tube radius excluding the aluminium walls.
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::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::m_doFixedError
Gaudi::Property< bool > m_doFixedError
Use parameterised errors.
Definition MdtDriftCircleOnTrackCreator.h:250
Muon::MdtDriftCircleOnTrackCreator::m_scaleMdtCov
Gaudi::Property< bool > m_scaleMdtCov
Fixed error (not tube radius)
Definition MdtDriftCircleOnTrackCreator.h:248
Muon::MdtDriftCircleOnTrackCreator::m_t0Refit
Gaudi::Property< bool > m_t0Refit
Use error strategy for segments by default.
Definition MdtDriftCircleOnTrackCreator.h:261
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
Muon::MdtDriftCircleOnTrackCreator::MdtDriftCircleOnTrackCreator
MdtDriftCircleOnTrackCreator(const std::string &, const std::string &, const IInterface *)
Definition MdtDriftCircleOnTrackCreator.cxx:26
Muon::MdtDriftCircleOnTrackCreator::m_errorStrategy
MuonDriftCircleErrorStrategy m_errorStrategy
< Error strategy for created ROTs
Definition MdtDriftCircleOnTrackCreator.h:238
Muon::MdtDriftCircleOnTrackCreator::initialize
virtual StatusCode initialize() override final
Definition MdtDriftCircleOnTrackCreator.cxx:35
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::MdtDriftCircleOnTrackCreator::mooreErrorStrategyMC
double mooreErrorStrategyMC(const MuonDriftCircleErrorStrategy &myStrategy, double sigmaR, const Identifier &id) const
Definition MdtDriftCircleOnTrackCreator.cxx:494
Muon::MdtDriftCircleOnTrackCreator::getTriggerTime
double getTriggerTime() const
currently returns 0.
Definition MdtDriftCircleOnTrackCreator.h:196
Muon::MdtDriftCircleOnTrackCreator::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition MdtDriftCircleOnTrackCreator.h:221
Muon::MdtDriftCircleOnTrackCreator::m_applyToF
Gaudi::Property< bool > m_applyToF
toggle between loose errors (initial before alignment) and tight after alignment
Definition MdtDriftCircleOnTrackCreator.h:269
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
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::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::mooreErrorStrategyLoose
double mooreErrorStrategyLoose(const MuonDriftCircleErrorStrategy &myStrategy, double sigmaR, const Identifier &id) const
Definition MdtDriftCircleOnTrackCreator.cxx:576
Muon::MdtDriftCircleOnTrackCreator::muonErrorStrategy
double muonErrorStrategy(const MuonDriftCircleErrorStrategy &myStrategy, double sigmaR, const Identifier &id) const
Definition MdtDriftCircleOnTrackCreator.cxx:764
Muon::MdtDriftCircleOnTrackCreator::m_doSegments
Gaudi::Property< bool > m_doSegments
Deweight individual chambers.
Definition MdtDriftCircleOnTrackCreator.h:263
Muon::MdtDriftCircleOnTrackCreator::mooreErrorStrategy
double mooreErrorStrategy(const MuonDriftCircleErrorStrategy &myStrategy, double sigmaR, const Identifier &id) const
Definition MdtDriftCircleOnTrackCreator.cxx:481
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::m_mdtCalibrationTool
ToolHandle< IMdtCalibrationTool > m_mdtCalibrationTool
Definition MdtDriftCircleOnTrackCreator.h:223
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
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
Muon::MdtDriftCircleOnTrackCreator::COSMICS_TRIGGERTIME
@ COSMICS_TRIGGERTIME
case for normal cosmic data with rpc trigger or simulation including TOF.
Definition MdtDriftCircleOnTrackCreator.h:82
Muon::MdtDriftCircleOnTrackCreator::m_createTubeHits
Gaudi::Property< bool > m_createTubeHits
Scale ROTs depending on local alignment (i.e.
Definition MdtDriftCircleOnTrackCreator.h:246
Muon::MdtDriftCircleOnTrackCreator::mooreErrorStrategyTight
double mooreErrorStrategyTight(const MuonDriftCircleErrorStrategy &myStrategy, double sigmaR, const Identifier &id) const
Definition MdtDriftCircleOnTrackCreator.cxx:666
Muon::MdtDriftCircleOnTrackCreator::m_stationError
Gaudi::Property< bool > m_stationError
Add a special error to account for the T0 refit.
Definition MdtDriftCircleOnTrackCreator.h:259
Muon::MdtDriftCircleOnTrackCreator::timeOfFlight
double timeOfFlight(const Amg::Vector3D &pos, const double beta, const double tTrack, const double tShift) const
Definition MdtDriftCircleOnTrackCreator.cxx:468
Muon::MdtDriftCircleOnTrackCreator::m_useErrorParametrisation
Gaudi::Property< bool > m_useErrorParametrisation
Use the predicted track position to correct the Error.
Definition MdtDriftCircleOnTrackCreator.h:252
Muon::MdtDriftCircleOnTrackCreator::m_doMdt
Gaudi::Property< bool > m_doMdt
Process MDT ROTs.
Definition MdtDriftCircleOnTrackCreator.h:226
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
Muon::MdtDriftCircleOnTrack
This class represents the corrected MDT measurements, where the corrections include the effects of wi...
Definition MdtDriftCircleOnTrack.h:37
Muon::MdtDriftCircleOnTrack::driftRadius
double driftRadius() const
Returns the value of the drift radius.
Definition MdtDriftCircleOnTrack.h:277
Muon::MdtDriftCircleOnTrack::driftTime
double driftTime() const
Returns the value of the drift time used to obtain the drift radius.
Definition MdtDriftCircleOnTrack.h:280
Muon::MdtDriftCircleOnTrack::setLocalParameters
virtual void setLocalParameters(const Trk::LocalParameters &locPos)
Sets the local parameters.
Definition MdtDriftCircleOnTrack.h:275
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::MdtDriftCircleOnTrack::clone
virtual MdtDriftCircleOnTrack * clone() const override final
Pseudo-constructor, needed to avoid excessive RTTI.
Definition MdtDriftCircleOnTrack.h:256
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
Muon::MdtPrepData
Class to represent measurements from the Monitored Drift Tubes.
Definition MdtPrepData.h:33
Muon::MuonDriftCircleErrorStrategy::creationParameter
bool creationParameter(CreationParameter) const
Definition MuonDriftCircleErrorStrategy.h:82
Muon::MuonDriftCircleErrorStrategy::getBits
const MuonDriftCircleErrorStrategyInput & getBits() const
Definition MuonDriftCircleErrorStrategy.h:45
Muon::MuonDriftCircleErrorStrategy::setParameter
void setParameter(CreationParameter, bool value)
Definition MuonDriftCircleErrorStrategy.h:63
Muon::MuonDriftCircleErrorStrategy::StationError
@ StationError
A term is added to account for misaligned.
Definition MuonDriftCircleErrorStrategy.h:22
Muon::MuonDriftCircleErrorStrategy::T0Refit
@ T0Refit
A special error was applied to account for the T0 refit (user defined via jobProperties)
Definition MuonDriftCircleErrorStrategy.h:24
Muon::MuonDriftCircleErrorStrategy::FixedError
@ FixedError
A fixed error is given to this hit (user defined via jobProperties)
Definition MuonDriftCircleErrorStrategy.h:20
Muon::MuonDriftCircleErrorStrategy::MagFieldCorrection
@ MagFieldCorrection
Magnetic field correction was applied in calibration.
Definition MuonDriftCircleErrorStrategy.h:28
Muon::MuonDriftCircleErrorStrategy::SlewCorrection
@ SlewCorrection
Slewing correction was applied in calibration.
Definition MuonDriftCircleErrorStrategy.h:29
Muon::MuonDriftCircleErrorStrategy::TofCorrection
@ TofCorrection
Time of flight correction was applied in calibration.
Definition MuonDriftCircleErrorStrategy.h:25
Muon::MuonDriftCircleErrorStrategy::BackgroundCorrection
@ BackgroundCorrection
Background correction was applied in calibration.
Definition MuonDriftCircleErrorStrategy.h:30
Muon::MuonDriftCircleErrorStrategy::PropCorrection
@ PropCorrection
Propagation correction was applied in calibration.
Definition MuonDriftCircleErrorStrategy.h:26
Muon::MuonDriftCircleErrorStrategy::TempCorrection
@ TempCorrection
Temperature correction was applied in calibration.
Definition MuonDriftCircleErrorStrategy.h:27
Property
Support class for PropertyMgr.
Definition Property.h:23
Trk::MeasurementBase::localParameters
const LocalParameters & localParameters() const
Interface method to get the LocalParameters.
Definition MeasurementBase.h:132
Trk::MeasurementBase::localCovariance
const Amg::MatrixX & localCovariance() const
Interface method to get the localError.
Definition MeasurementBase.h:138
Trk::PrepRawData::localPosition
const Amg::Vector2D & localPosition() const
return the local position reference
Trk::PrepRawData::identify
Identifier identify() const
return the identifier
Trk::PrepRawData::type
virtual bool type(PrepRawDataType type) const
Interface method checking the type.
Definition PrepRawData.h:133
Trk::PrepRawData::localCovariance
const Amg::MatrixX & localCovariance() const
return const ref to the error matrix
Trk::RIO_OnTrack
Class to handle RIO On Tracks ROT) for InDet and Muons, it inherits from the common MeasurementBase.
Definition RIO_OnTrack.h:70
Trk::RIO_OnTrack::identify
Identifier identify() const
return the identifier -extends MeasurementBase
Definition RIO_OnTrack.h:152
Trk::Surface
Abstract Base Class for tracking surfaces.
Definition Tracking/TrkDetDescr/TrkSurfaces/TrkSurfaces/Surface.h:79
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...
r
int r
Definition globals.cxx:22
Amg::MatrixX
Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic > MatrixX
Dynamic Matrix - dynamic allocation.
Definition EventPrimitives.h:27
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
Amg::Vector2D
Eigen::Matrix< double, 2, 1 > Vector2D
Definition GeoPrimitives.h:48
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition GeoPrimitives.h:47
Muon::MuonStationIndex::StIndex
StIndex
enum to classify the different station layers in the muon spectrometer
Definition MuonStationIndex.h:23
Muon
NRpcCablingAlg reads raw condition data and writes derived condition data to the condition store.
Definition TrackSystemController.h:45
Muon::CalibrationOutput
MdtDriftCircleOnTrackCreator::CalibrationOutput CalibrationOutput
Definition MdtDriftCircleOnTrackCreator.cxx:24
Muon::MdtRotPtr
MdtDriftCircleOnTrackCreator::MdtRotPtr MdtRotPtr
Definition MdtDriftCircleOnTrackCreator.cxx:23
Trk::DriftCircleSide
DriftCircleSide
Enumerates the 'side' of the wire on which the tracks passed (i.e.
Definition DriftCircleSide.h:16
Trk::LEFT
@ LEFT
the drift radius is negative (see Trk::AtaStraightLine)
Definition DriftCircleSide.h:20
Trk::DriftCircleStatus
DriftCircleStatus
Enumerates the 'status' of the wire on which the tracks passed (based on the TRT_Side enum,...
Definition DriftCircleStatus.h:16
Trk::NODRIFTTIME
@ NODRIFTTIME
drift time was not used - drift radius is 0.
Definition DriftCircleStatus.h:24
Trk::DECIDED
@ DECIDED
sign of drift radius has been determined
Definition DriftCircleStatus.h:18
Trk::UNDECIDED
@ UNDECIDED
sign of drift radius has not been determined
Definition DriftCircleStatus.h:20
Trk::driftRadius
@ driftRadius
trt, straws
Definition ParamDefs.h:53
Trk::locR
@ locR
Definition ParamDefs.h:44
Trk::locZ
@ locZ
local cylindrical
Definition ParamDefs.h:42
Trk::DefinedParameter
std::pair< double, ParamDefs > DefinedParameter
Typedef to of a std::pair<double, ParamDefs> to identify a passed-through double as a specific type o...
Definition DefinedParameter.h:27
Trk::TrackParameters
ParametersBase< TrackParametersDim, Charged > TrackParameters
Definition Tracking/TrkEvent/TrkParameters/TrkParameters/TrackParameters.h:27
Generated on for ATLAS Offline Software by doxygen 1.14.0