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

#include <MuonClusterOnTrackCreator.h>

Inheritance diagram for Muon::MuonClusterOnTrackCreator:
Collaboration diagram for Muon::MuonClusterOnTrackCreator:

Public Member Functions

virtual ~MuonClusterOnTrackCreator ()=default
 
virtual StatusCode initialize () override
 
virtual MuonClusterOnTrack * createRIO_OnTrack (const Trk::PrepRawData &RIO, const Amg::Vector3D &GP) const override
 Create new Muon::MuonClusterOnTrack from a Trk::PrepRawData and a predicted Trk::TrackParameter. More...
 
virtual MuonClusterOnTrack * createRIO_OnTrack (const Trk::PrepRawData &RIO, const Amg::Vector3D &GP, const Amg::Vector3D &GD) const override
 Create new Muon::MuonClusterOnTrack from a Trk::PrepRawData and a prediction of the global position and direction. More...
 
virtual MuonClusterOnTrack * correct (const Trk::PrepRawData &RIO, const Trk::TrackParameters &TP, const EventContext &) const override
 Create new Muon::MuonClusterOnTrack from a Trk::PrepRawData and the predicted Trk::TrackParameter at the measurement surface. More...
 
virtual MuonClusterOnTrack * correct (const Trk::PrepRawData &RIO, const Amg::Vector3D &GP, const Amg::Vector3D &GD) const override
 Create new Muon::MuonClusterOnTrack from a Trk::PrepRawData and a prediction of the global position and direction. More...
 

Private Member Functions

MuonClusterOnTrack * calibratedClusterMMG (const Trk::PrepRawData &RIO, const Amg::Vector3D &GP, const Amg::Vector3D &GD) const
 
MuonClusterOnTrack * calibratedClusterSTG (const Trk::PrepRawData &RIO, const Amg::Vector3D &GP, const Amg::Vector3D &GD) const
 

Private Attributes

ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
 
ToolHandle< Muon::INSWCalibTool > m_calibToolNSW {this, "NSWCalibTool", ""}
 
ToolHandle< Muon::IMMClusterBuilderTool > m_clusterBuilderToolMM {this, "MMClusterBuilder", "Muon::SimpleMMClusterBuilderTool/SimpleMMClusterBuilderTool"}
 
Gaudi::Property< bool > m_doFixedErrorTgcEta {this, "DoFixedErrorTgcEta", false}
 
Gaudi::Property< bool > m_doFixedErrorRpcEta {this, "DoFixedErrorRpcEta", false}
 
Gaudi::Property< bool > m_doFixedErrorTgcPhi {this, "DoFixedErrorTgcPhi", false}
 
Gaudi::Property< bool > m_doFixedErrorRpcPhi {this, "DoFixedErrorRpcPhi", false}
 
Gaudi::Property< double > m_fixedErrorTgcEta {this, "FixedErrorTgcEta", 5.}
 
Gaudi::Property< double > m_fixedErrorRpcEta {this, "FixedErrorRpcEta", 5.}
 
Gaudi::Property< double > m_fixedErrorTgcPhi {this, "FixedErrorTgcPhi", 5.}
 
Gaudi::Property< double > m_fixedErrorRpcPhi {this, "FixedErrorRpcPhi", 5.}
 

Detailed Description

Definition at line 30 of file MuonClusterOnTrackCreator.h.

Constructor & Destructor Documentation

◆ ~MuonClusterOnTrackCreator()

virtual Muon::MuonClusterOnTrackCreator::~MuonClusterOnTrackCreator ( )
virtualdefault

Member Function Documentation

◆ calibratedClusterMMG()

MuonClusterOnTrack * MuonClusterOnTrackCreator::calibratedClusterMMG ( const Trk::PrepRawData &  RIO,
const Amg::Vector3D &  GP,
const Amg::Vector3D &  GD 
) const
private

Definition at line 256 of file MuonClusterOnTrackCreator.cxx.

256  {
257  const EventContext& ctx{Gaudi::Hive::currentContext()};
258  // Make sure RIO has a detector element
259  const MuonGM::MMReadoutElement* mmEL = static_cast<const MuonGM::MMReadoutElement*>(RIO.detectorElement());
260  if (!mmEL) {
261  ATH_MSG_WARNING("RIO does not have associated detectorElement! Skipping cluster calibration");
262  return nullptr;
263  }
264 
265  Amg::MatrixX loce = RIO.localCovariance();
266  Trk::LocalParameters locpar = loce.cols() > 1 ? Trk::LocalParameters{RIO.localPosition()} : Trk::LocalParameters{Trk::DefinedParameter{RIO.localPosition().x(), Trk::locX}};
267 
268  // * Local cluster coordinates to feed to the calibration tools
269  Amg::Vector2D lp{Amg::Vector2D::Zero()};
270 
271  // get localY from the seeded position
272  const Trk::PlaneSurface& rio_surface = mmEL->surface(RIO.identify());
273  if (!rio_surface.globalToLocal(GP, GP, lp)) {
274  Amg::Vector3D lpos = rio_surface.transform().inverse() * GP;
275  ATH_MSG_WARNING("Extrapolated GlobalPosition not on detector surface! Distance " << lpos.z());
276  lp[Trk::locX] = lpos.x();
277  lp[Trk::locY] = lpos.y();
278  }
279  // set localX from the cluster parameters
280  lp[Trk::locX] = locpar[Trk::locX];
281 
282  // * B-Field correction
283  // calibrate the input strips
284  const MMPrepData* mmPRD = static_cast<const MMPrepData*>(&RIO);
285 
286  std::vector<NSWCalib::CalibratedStrip> calibratedStrips;
287  StatusCode sc = m_calibToolNSW->calibrateClus(ctx, mmPRD, GP, calibratedStrips);
288  if (sc != StatusCode::SUCCESS) {
289  ATH_MSG_WARNING("Could not calibrate the MM Cluster in the RIO on track creator");
290  return nullptr;
291  }
292 
293  // calibrate the cluster position along the precision coordinate (updates lp.x())
294  IMMClusterBuilderTool::RIO_Author rotAuthor = m_clusterBuilderToolMM->getCalibratedClusterPosition(ctx,
295  calibratedStrips,
296  NswClustering::toLocal(*mmPRD, GD),
297  lp, loce);
298 
299  if (rotAuthor == IMMClusterBuilderTool::RIO_Author::unKnownAuthor) {
300  ATH_MSG_WARNING("Could not calibrate the MM Cluster in the RIO on track creator");
301  return nullptr;
302  }
303 
304  // * Correct the local cluster coordinates for as-built conditions and B-lines (returns a new 3D vector)
305  Amg::Vector3D localposition3D{Amg::Vector3D::Zero()};
306  if (!mmEL->spacePointPosition(RIO.identify(), lp, localposition3D)){
307  ATH_MSG_WARNING("Application of final as-built parameters failed for channel "<<m_idHelperSvc->toString(RIO.identify())<<" local pos = ("<<lp.x()<<"/"<<lp.y()<<").");
308  }
309 
310  // Get the direction of the track in the local coordinate system and use it to project
311  // the actual hit position onto the nominal surface (locZ = 0), where the intersection
312  // of the track is considered. This "effective" position provides a more accurate residual.
313  Trk::LocalDirection ld;
314  rio_surface.globalToLocalDirection(GD, ld);
315  double a_impact = ld.angleXZ() < 0 ? -M_PI_2 - ld.angleXZ() : M_PI_2 - ld.angleXZ();
316  double x_projected = localposition3D.x() - std::tan(a_impact) * localposition3D.z();
317 
318  // * Set the value of the local parameter (locX) after applying conditions
319  // The position along strip will be set from the seed (there is no better
320  // estimate than that; not used in the track fits anyway)
321  locpar[Trk::locX] = x_projected;
322 
323  ATH_MSG_VERBOSE("generating MMClusterOnTrack in MMClusterBuilder");
324  MMClusterOnTrack* cluster = new MMClusterOnTrack(mmPRD, std::move(locpar), std::move(loce), lp[Trk::locY], {}, {});
325  cluster->setAuthor(rotAuthor);
326 
327  return cluster;
328  }

◆ calibratedClusterSTG()

MuonClusterOnTrack * MuonClusterOnTrackCreator::calibratedClusterSTG ( const Trk::PrepRawData &  RIO,
const Amg::Vector3D &  GP,
const Amg::Vector3D &  GD 
) const
private

Definition at line 332 of file MuonClusterOnTrackCreator.cxx.

332  {
333 
334  // Make sure RIO has a detector element
335  const MuonGM::sTgcReadoutElement* stgEL = static_cast<const MuonGM::sTgcReadoutElement*>(RIO.detectorElement());
336  if (!stgEL) {
337  ATH_MSG_WARNING("RIO does not have associated detectorElement! Skipping cluster calibration");
338  return nullptr;
339  }
340 
341  Amg::MatrixX loce = RIO.localCovariance();
342  // > 1 in case we want to keep pads in the future ?
343  Trk::LocalParameters locpar = loce.cols() > 1 ? Trk::LocalParameters{RIO.localPosition()} : Trk::LocalParameters{Trk::DefinedParameter{RIO.localPosition().x(), Trk::locX}};
344 
345 
346  // * Local cluster coordinates to feed to the calibration tools
347  Amg::Vector2D lp{ Amg::Vector2D::Zero() };
348 
349  // get local y from the seeded position
350  const Trk::PlaneSurface& rio_surface = stgEL->surface(RIO.identify());
351  if (!rio_surface.globalToLocal(GP, GP, lp)) {
352  Amg::Vector3D lpos = rio_surface.transform().inverse() * GP;
353  ATH_MSG_WARNING("Extrapolated GlobalPosition not on detector surface! Distance " << lpos.z());
354  lp[Trk::locX] = lpos.x();
355  lp[Trk::locY] = lpos.y();
356  }
357  // set local x from the cluster parameters
358  lp[Trk::locX] = locpar[Trk::locX];
359 
360  // * Correct the local coordinates for as-built conditions and b-lines
361  Amg::Vector3D localposition3D { Amg::Vector3D::Zero() };
362  stgEL->spacePointPosition(RIO.identify(), lp[Trk::locX], lp[Trk::locY], localposition3D);
363 
364  // Get the direction of the track in the local coordinate system and use it to project
365  // the actual hit position onto the nominal surface (locZ = 0), where the intersection
366  // of the track is considered. This "effective" position provides a more accurate residual.
367  Trk::LocalDirection ld;
368  rio_surface.globalToLocalDirection(GD, ld);
369  double a_impact = ld.angleXZ() < 0 ? -M_PI_2 - ld.angleXZ() : M_PI_2 - ld.angleXZ();
370  double x_projected = localposition3D.x() - std::tan(a_impact) * localposition3D.z();
371 
372  // * Set the value of the local parameter (locX) after applying conditions
373  // The position along strip will be set from the seed (there is no better
374  // estimate than that; not used in the track fits anyway)
375  locpar[Trk::locX] = x_projected;
376 
377  const sTgcPrepData* stgPRD = static_cast<const sTgcPrepData*>(&RIO);
378  ATH_MSG_VERBOSE("generating sTgcClusterOnTrack in MuonClusterBuilder");
379  MuonClusterOnTrack* cluster = new sTgcClusterOnTrack(stgPRD, std::move(locpar), std::move(loce), lp[Trk::locY]);
380 
381  return cluster;
382  }

◆ correct() [1/2]

MuonClusterOnTrack * MuonClusterOnTrackCreator::correct ( const Trk::PrepRawData &  RIO,
const Amg::Vector3D &  GP,
const Amg::Vector3D &  GD 
) const
overridevirtual

Create new Muon::MuonClusterOnTrack from a Trk::PrepRawData and a prediction of the global position and direction.

Parameters
RIOTrk::PrepRawData object to be calibrated
GPPredicted intersect position of the muon with the measurement plane
GDPredicted direction at the intersect position of the muon with the measurement plane
Returns
a pointer to a new Muon::MuonClusterOnTrack object, zero if calibration failed. The ownership of the new Muon::MuonClusterOnTrack is passed to the client calling the tool

Definition at line 237 of file MuonClusterOnTrackCreator.cxx.

237  {
238  ATH_MSG_VERBOSE("Apply calibration correction to "<<RIO);
239 
240  switch (m_idHelperSvc->technologyIndex(RIO.identify())) {
241  using enum Muon::MuonStationIndex::TechnologyIndex;
242  case MM:
243  return calibratedClusterMMG(RIO, GP, GD);
244  case STGC: {
245  if (!m_idHelperSvc->measuresPhi(RIO.identify())){
246  return calibratedClusterSTG(RIO, GP, GD);
247  }
248  return createRIO_OnTrack(RIO, GP);
249  } default:
250  return createRIO_OnTrack(RIO, GP);
251  }
252  }

◆ correct() [2/2]

MuonClusterOnTrack * MuonClusterOnTrackCreator::correct ( const Trk::PrepRawData &  RIO,
const Trk::TrackParameters &  TP,
const EventContext &   
) const
overridevirtual

Create new Muon::MuonClusterOnTrack from a Trk::PrepRawData and the predicted Trk::TrackParameter at the measurement surface.

Parameters
RIOTrk::PrepRawData object to be calibrated
TPPredicted Trk::TrackParameter at the measurement surface
Returns
a pointer to a new Muon::MuonClusterOnTrack object, zero if calibration failed. The ownership of the new Muon::MuonClusterOnTrack is passed to the client calling the tool

Definition at line 232 of file MuonClusterOnTrackCreator.cxx.

232  {
233  return correct(RIO, TP.position(), TP.momentum().unit());
234  }

◆ createRIO_OnTrack() [1/2]

MuonClusterOnTrack * MuonClusterOnTrackCreator::createRIO_OnTrack ( const Trk::PrepRawData &  RIO,
const Amg::Vector3D &  GP 
) const
overridevirtual

Create new Muon::MuonClusterOnTrack from a Trk::PrepRawData and a predicted Trk::TrackParameter.

Parameters
RIOTrk::PrepRawData object to be calibrated
GPPredicted intersect position of the muon with the measurement plane
Returns
a pointer to a new Muon::MuonClusterOnTrack object, zero if calibration failed. The ownership of the new Muon::MuonClusterOnTrack is passed to the client calling the tool

Definition at line 41 of file MuonClusterOnTrackCreator.cxx.

42  {
43  MuonClusterOnTrack* MClT = nullptr;
44 
45  // check whether PrepRawData has detector element, if not there print warning
46  const Trk::TrkDetElementBase* EL = RIO.detectorElement();
47 
48  ATH_MSG_VERBOSE("Create ROT from "<<m_idHelperSvc->toString(RIO.identify())<<".");
49 
50  // in RIO_OnTrack the local param and cov should have the same dimension
51  Trk::LocalParameters locpar(RIO.localPosition());
52 
53  if (RIO.localCovariance().cols() > 1 || (m_idHelperSvc->isTgc(RIO.identify()) && m_idHelperSvc->measuresPhi(RIO.identify()))) {
54  ATH_MSG_VERBOSE("Making 2-dim local parameters: " << m_idHelperSvc->toString(RIO.identify()));
55  } else {
56  Trk::DefinedParameter radiusPar(RIO.localPosition().x(), Trk::locX);
57  locpar = Trk::LocalParameters(radiusPar);
58  ATH_MSG_VERBOSE("Making 1-dim local parameters: " << m_idHelperSvc->toString(RIO.identify()));
59  }
60 
61  Amg::Vector2D lp{Amg::Vector2D::Zero()};
62  double positionAlongStrip{0};
63  double positionAlongZ{0};
64 
65  const Trk::Surface& rio_surface = EL->surface(RIO.identify());
66  if (!rio_surface.globalToLocal(GP, GP, lp)) {
67  Amg::Vector3D lpos = rio_surface.transform().inverse() * GP;
68  ATH_MSG_WARNING("Extrapolated GlobalPosition not on detector surface! Distance " << lpos.z());
69  lp[Trk::locX] = lpos.x();
70  lp[Trk::locY] = lpos.y();
71  positionAlongZ = lpos.z();
72  }
73 
74  positionAlongStrip = lp[Trk::locY];
75 
76  Amg::MatrixX loce = RIO.localCovariance();
77  ATH_MSG_DEBUG("All: new err matrix is " << loce);
78  switch (m_idHelperSvc->technologyIndex(RIO.identify())) {
79  using enum Muon::MuonStationIndex::TechnologyIndex;
80  case RPC: {
81  //***************************
82  // RPC: cast to RpcPrepData
83  //***************************
84  const RpcPrepData* MClus = static_cast<const RpcPrepData*>(&RIO);
85  const bool measphi = m_idHelperSvc->measuresPhi(RIO.identify());
86 
87  if ((m_doFixedErrorRpcEta && !measphi) ||
88  (m_doFixedErrorRpcPhi && measphi) ) {
89  const double fixedError = measphi ? m_fixedErrorRpcPhi
90  : m_fixedErrorRpcEta;
91  Amg::MatrixX mat(1, 1);
92  mat(0, 0) = fixedError * fixedError;
93  loce = mat;
94  }
95 
96  const MuonGM::RpcReadoutElement* re = MClus->detectorElement();
97  Amg::Vector3D clusPos = re->stripPos(RIO.identify());
98 
99  // let's correct rpc time subtracting delay due to the induced electric signal propagation along strip
100  double timeAlongStrip = 0;
101  if (!measphi) {
102  timeAlongStrip = re->distanceToEtaReadout(GP) / 1000. * SIG_VEL;
103  } else {
104  timeAlongStrip = re->distanceToPhiReadout(GP) / 1000. * SIG_VEL;
105  }
106  if (positionAlongZ) timeAlongStrip = 0; // no correction if extrapolated GlobalPosition not on detector surface!
107 
108  // let's evaluate the average delay due to the induced electric signal propagation along strip
109  double assignedTimFromPrd = 0;
110  if (!measphi) {
111  assignedTimFromPrd = re->distanceToEtaReadout(clusPos) / 1000. * SIG_VEL;
112  } else {
113  assignedTimFromPrd = re->distanceToPhiReadout(clusPos) / 1000. * SIG_VEL;
114  }
115 
116  // let's evaluate [real TOF - nominal TOF]
117  double real_TOF_onRPCgap = GP.mag() / 1000. * C_VEL;
118  double nominal_TOF_onRPCgap = clusPos.mag() / 1000. * C_VEL;
119 
120  // let's evaluate the total time correction
121  double correct_time_tot = real_TOF_onRPCgap
122  - nominal_TOF_onRPCgap
123  + timeAlongStrip
124  - assignedTimFromPrd;
125 
126  MClT = new RpcClusterOnTrack(MClus, std::move(locpar), std::move(loce),
127  positionAlongStrip, MClus->time() - correct_time_tot);
128 
129  ATH_MSG_DEBUG(" correct_time_along_strip " << timeAlongStrip << " assignedTimFromPrd "
130  << assignedTimFromPrd << " real_TOF_onRPCgap " << real_TOF_onRPCgap
131  << " nominal_TOF_onRPCgap " << nominal_TOF_onRPCgap << " MClus->time() "
132  << MClus->time() << " correct_time_tot " << correct_time_tot);
133  break;
134 
135  } case TGC: {
136 
137  //***************************
138  // TGC: cast to TgcPrepData
139  //***************************
140 
141  const TgcPrepData* MClus = static_cast<const TgcPrepData*>(&RIO);
142  const TgcIdHelper& idHelper{m_idHelperSvc->tgcIdHelper()};
143 
144  // calculation of 2D error matrix for TGC phi strips
145  if (idHelper.measuresPhi(RIO.identify())) {
146  const int stripNo = idHelper.channel(RIO.identify());
147  const int gasGap = idHelper.gasGap(RIO.identify());
148 
149  const MuonGM::TgcReadoutElement* ele = MClus->detectorElement();
150 
151  double stripLength = ele->stripLength();
152  double stripWidth = std::abs(ele->stripPitch(gasGap, stripNo, lp[Trk::locZ]));
153  const Amg::Vector3D lStripDir = ele->transform(RIO.identify()).inverse().linear()*
154  ele->stripDir(RIO.identify());
155 
156  Amg::MatrixX mat(2, 2);
157 
158  double phistereo = lStripDir.phi() - 90.*Gaudi::Units::deg;
159  double Sn = std::sin(phistereo);
160  double Sn2 = Sn * Sn;
161  double Cs2 = 1. - Sn2;
162 
163  double V0 = stripWidth * stripWidth / 12;
164  if (m_doFixedErrorTgcPhi) V0 = m_fixedErrorTgcPhi * m_fixedErrorTgcPhi;
165  double V1 = stripLength * stripLength / 12;
166  mat(0, 0) = (Cs2 * V0 + Sn2 * V1);
167  mat.fillSymmetric(1, 0, (Sn * std::sqrt(Cs2) * (V0 - V1)));
168  mat(1, 1) = (Sn2 * V0 + Cs2 * V1);
169  loce = mat;
170  } else {
171  if (m_doFixedErrorTgcEta) {
172  Amg::MatrixX mat(1, 1);
173  mat(0, 0) = m_fixedErrorTgcEta * m_fixedErrorTgcEta;
174  loce = mat;
175  }
176  }
177 
178  MClT = new TgcClusterOnTrack(MClus, std::move(locpar), std::move(loce),
179  positionAlongStrip);
180  break;
181 
182  } case STGC: {
183 
184  //***************************
185  // sTGC: cast to sTgcPrepData
186  //***************************
187 
188  const sTgcPrepData* MClus = static_cast<const sTgcPrepData*>(&RIO);
189  Amg::Vector2D localPos(lp[Trk::locX], lp[Trk::locY]);
190 
191  // Dont make RIO On tracks for sTGC wires in inner Q1
192  if (m_idHelperSvc->stgcIdHelper().channelType(MClus->identify()) == sTgcIdHelper::Wire &&
193  MClus->detectorElement()->isEtaZero(MClus->identify(), lp)) {
194  ATH_MSG_DEBUG("sTgcReadoutElement with isEtaZero() ?! "
195  <<m_idHelperSvc->toString(MClus->identify()));
196  return nullptr;
197  }
198  // Wires are already considered in the above check. Dont remove them here
199  if (!rio_surface.insideBounds(localPos) &&
200  m_idHelperSvc->stgcIdHelper().channelType(MClus->identify()) != sTgcIdHelper::Wire) {
201  ATH_MSG_DEBUG("sTgc measurement "<<m_idHelperSvc->toString(MClus->identify())
202  <<" out of bounds. "<<Amg::toString(localPos));
203  return nullptr;
204  }
205  MClT = new sTgcClusterOnTrack(MClus, std::move(locpar),
206  std::move(loce), positionAlongStrip);
207  break;
208 
209  } case MM:{
210  //***************************
211  // MM: cast to MMPrepData
212  //***************************
213  const MMPrepData* mmPRD = static_cast<const MMPrepData*>(&RIO);
214  MClT = new MMClusterOnTrack(mmPRD, std::move(locpar), std::move(loce),
215  positionAlongStrip, {}, {});
216  break;
217  } default:
218  ATH_MSG_WARNING(__FILE__<<":"<<__LINE__<<" Measurement not supported:"
219  <<m_idHelperSvc->toString(RIO.identify()));
220  }
221 
222  return MClT;
223  }

◆ createRIO_OnTrack() [2/2]

MuonClusterOnTrack * MuonClusterOnTrackCreator::createRIO_OnTrack ( const Trk::PrepRawData &  RIO,
const Amg::Vector3D &  GP,
const Amg::Vector3D &  GD 
) const
overridevirtual

Create new Muon::MuonClusterOnTrack from a Trk::PrepRawData and a prediction of the global position and direction.

It is only implemented for the CSCs, for RPC and TGC Trk::PrepRawData the result is the same as for the routine without the direction.

Parameters
RIOTrk::PrepRawData object to be calibrated
GPPredicted intersect position of the muon with the measurement plane
GDPredicted direction at the intersect position of the muon with the measurement plane
Returns
a pointer to a new Muon::MuonClusterOnTrack object, zero if calibration failed. The ownership of the new Muon::MuonClusterOnTrack is passed to the client calling the tool

Definition at line 227 of file MuonClusterOnTrackCreator.cxx.

227  {
228  return createRIO_OnTrack(RIO, GP);
229  }

◆ initialize()

StatusCode MuonClusterOnTrackCreator::initialize ( )
overridevirtual

Definition at line 32 of file MuonClusterOnTrackCreator.cxx.

32  {
33  ATH_CHECK(m_idHelperSvc.retrieve());
34 
35  ATH_CHECK(m_clusterBuilderToolMM.retrieve(DisableTool{m_calibToolNSW.empty()}));
36  ATH_CHECK(m_calibToolNSW.retrieve(DisableTool{m_calibToolNSW.empty()}));
37  return StatusCode::SUCCESS;
38  }

Member Data Documentation

◆ m_calibToolNSW

ToolHandle<Muon::INSWCalibTool> Muon::MuonClusterOnTrackCreator::m_calibToolNSW {this, "NSWCalibTool", ""}
private

Definition at line 83 of file MuonClusterOnTrackCreator.h.

◆ m_clusterBuilderToolMM

ToolHandle<Muon::IMMClusterBuilderTool> Muon::MuonClusterOnTrackCreator::m_clusterBuilderToolMM {this, "MMClusterBuilder", "Muon::SimpleMMClusterBuilderTool/SimpleMMClusterBuilderTool"}
private

Definition at line 84 of file MuonClusterOnTrackCreator.h.

◆ m_doFixedErrorRpcEta

Gaudi::Property<bool> Muon::MuonClusterOnTrackCreator::m_doFixedErrorRpcEta {this, "DoFixedErrorRpcEta", false}
private

Definition at line 90 of file MuonClusterOnTrackCreator.h.

◆ m_doFixedErrorRpcPhi

Gaudi::Property<bool> Muon::MuonClusterOnTrackCreator::m_doFixedErrorRpcPhi {this, "DoFixedErrorRpcPhi", false}
private

Definition at line 92 of file MuonClusterOnTrackCreator.h.

◆ m_doFixedErrorTgcEta

Gaudi::Property<bool> Muon::MuonClusterOnTrackCreator::m_doFixedErrorTgcEta {this, "DoFixedErrorTgcEta", false}
private

Definition at line 89 of file MuonClusterOnTrackCreator.h.

◆ m_doFixedErrorTgcPhi

Gaudi::Property<bool> Muon::MuonClusterOnTrackCreator::m_doFixedErrorTgcPhi {this, "DoFixedErrorTgcPhi", false}
private

Definition at line 91 of file MuonClusterOnTrackCreator.h.

◆ m_fixedErrorRpcEta

Gaudi::Property<double> Muon::MuonClusterOnTrackCreator::m_fixedErrorRpcEta {this, "FixedErrorRpcEta", 5.}
private

Definition at line 94 of file MuonClusterOnTrackCreator.h.

◆ m_fixedErrorRpcPhi

Gaudi::Property<double> Muon::MuonClusterOnTrackCreator::m_fixedErrorRpcPhi {this, "FixedErrorRpcPhi", 5.}
private

Definition at line 96 of file MuonClusterOnTrackCreator.h.

◆ m_fixedErrorTgcEta

Gaudi::Property<double> Muon::MuonClusterOnTrackCreator::m_fixedErrorTgcEta {this, "FixedErrorTgcEta", 5.}
private

Definition at line 93 of file MuonClusterOnTrackCreator.h.

◆ m_fixedErrorTgcPhi

Gaudi::Property<double> Muon::MuonClusterOnTrackCreator::m_fixedErrorTgcPhi {this, "FixedErrorTgcPhi", 5.}
private

Definition at line 95 of file MuonClusterOnTrackCreator.h.

◆ m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> Muon::MuonClusterOnTrackCreator::m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
private

Definition at line 81 of file MuonClusterOnTrackCreator.h.

The documentation for this class was generated from the following files:
Trk::LocalParameters
Definition: LocalParameters.h:98
Trk::PlaneSurface::globalToLocal
virtual bool globalToLocal(const Amg::Vector3D &glob, const Amg::Vector3D &mom, Amg::Vector2D &loc) const override final
Specified for PlaneSurface: GlobalToLocal method without dynamic memory allocation - boolean checks i...
Definition: PlaneSurface.cxx:209
MuonGM::MuonClusterReadoutElement::transform
virtual const Amg::Transform3D & transform() const override
Return local to global transform.
Definition: MuonClusterReadoutElement.h:124
STGC
@ STGC
Definition: RegSelEnums.h:39
dumpTgcDigiDeadChambers.gasGap
list gasGap
Definition: dumpTgcDigiDeadChambers.py:33
Muon::MuonClusterOnTrackCreator::createRIO_OnTrack
virtual MuonClusterOnTrack * createRIO_OnTrack(const Trk::PrepRawData &RIO, const Amg::Vector3D &GP) const override
Create new Muon::MuonClusterOnTrack from a Trk::PrepRawData and a predicted Trk::TrackParameter.
Definition: MuonClusterOnTrackCreator.cxx:41
Amg::MatrixX
Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic > MatrixX
Dynamic Matrix - dynamic allocation.
Definition: EventPrimitives.h:27
Trk::PrepRawDataType::TgcPrepData
@ TgcPrepData
Trk::PrepRawDataType::MMPrepData
@ MMPrepData
Trk::locX
@ locX
Definition: ParamDefs.h:37
Trk::locY
@ locY
local cartesian
Definition: ParamDefs.h:38
FlavorTagInference::SaltModelVersion::V0
@ V0
Muon::MuonClusterOnTrackCreator::m_doFixedErrorRpcPhi
Gaudi::Property< bool > m_doFixedErrorRpcPhi
Definition: MuonClusterOnTrackCreator.h:92
Muon::MuonClusterOnTrackCreator::m_clusterBuilderToolMM
ToolHandle< Muon::IMMClusterBuilderTool > m_clusterBuilderToolMM
Definition: MuonClusterOnTrackCreator.h:84
Muon::MuonClusterOnTrackCreator::m_fixedErrorRpcPhi
Gaudi::Property< double > m_fixedErrorRpcPhi
Definition: MuonClusterOnTrackCreator.h:96
TgcIdHelper
Definition: TgcIdHelper.h:50
Trk::ParametersBase::position
const Amg::Vector3D & position() const
Access method for the position.
Amg::Vector2D
Eigen::Matrix< double, 2, 1 > Vector2D
Definition: GeoPrimitives.h:48
mat
GeoMaterial * mat
Definition: LArDetectorConstructionTBEC.cxx:55
Trk::PrepRawData::localCovariance
const Amg::MatrixX & localCovariance() const
return const ref to the error matrix
Muon::MuonStationIndex::TechnologyIndex
TechnologyIndex
enum to classify the different layers in the muon spectrometer
Definition: MuonStationIndex.h:54
deg
#define deg
Definition: SbPolyhedron.cxx:17
MM
@ MM
Definition: RegSelEnums.h:38
MuonGM::TgcReadoutElement::stripLength
double stripLength() const
Returns the length of each strip which is equal to the height of the chamber.
MuonGM::RpcReadoutElement
An RpcReadoutElement corresponds to a single RPC module; therefore typicaly a barrel muon station con...
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/RpcReadoutElement.h:55
Trk::TrkDetElementBase
Definition: TrkDetElementBase.h:52
MuonGM::sTgcReadoutElement::spacePointPosition
virtual bool spacePointPosition(const Identifier &phiId, const Identifier &etaId, Amg::Vector2D &pos) const override final
space point position for a given pair of phi and eta identifiers The LocalPosition is expressed in th...
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/sTgcReadoutElement.h:436
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
Trk::PrepRawDataType::RpcPrepData
@ RpcPrepData
MuonGM::TgcReadoutElement::stripDir
Amg::Vector3D stripDir(int gasGap, int strip) const
Returns the direction of a strip.
Muon::MuonClusterOnTrackCreator::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition: MuonClusterOnTrackCreator.h:81
MuonGM::MuonClusterReadoutElement::surface
virtual const Trk::PlaneSurface & surface() const override
access to chamber surface (phi orientation), uses the first gas gap
Definition: MuonClusterReadoutElement.h:123
Muon::IMMClusterBuilderTool::RIO_Author
MMClusterOnTrack::Author RIO_Author
Refinement of the cluster position after the cluster calibration loop is ran with a complete external...
Definition: IMMClusterBuilderTool.h:48
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
Trk::DefinedParameter
std::pair< double, ParamDefs > DefinedParameter
Definition: DefinedParameter.h:27
FlavorTagInference::SaltModelVersion::V1
@ V1
Muon::MuonClusterOnTrackCreator::m_doFixedErrorRpcEta
Gaudi::Property< bool > m_doFixedErrorRpcEta
Definition: MuonClusterOnTrackCreator.h:90
Amg::toString
std::string toString(const Translation3D &translation, int precision=4)
GeoPrimitvesToStringConverter.
Definition: GeoPrimitivesToStringConverter.h:40
Muon::NswClustering::toLocal
Amg::Vector3D toLocal(const Amg::Transform3D &toLocalTrans, const Amg::Vector3D &dir)
Rotates a direction vector into a local frame: x-axis : Parallell to the radial direction of the dete...
Definition: NswClusteringUtils.h:21
Trk::locZ
@ locZ
local cylindrical
Definition: ParamDefs.h:42
TGC
Definition: TgcBase.h:6
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
sTgcIdHelper::Wire
@ Wire
Definition: sTgcIdHelper.h:190
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
MuonGM::sTgcReadoutElement
An sTgcReadoutElement corresponds to a single STGC module; therefore typicaly a barrel muon station c...
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/sTgcReadoutElement.h:30
Muon::MuonClusterOnTrackCreator::m_fixedErrorTgcEta
Gaudi::Property< double > m_fixedErrorTgcEta
Definition: MuonClusterOnTrackCreator.h:93
MuonGM::TgcReadoutElement
A TgcReadoutElement corresponds to a single TGC chamber; therefore typically a TGC station contains s...
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/TgcReadoutElement.h:42
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
EL
This module defines the arguments passed from the BATCH driver to the BATCH worker.
Definition: AsgComponentFactories.h:16
Trk::PlaneSurface::globalToLocalDirection
void globalToLocalDirection(const Amg::Vector3D &glodir, Trk::LocalDirection &locdir) const
This method transforms the global direction to a local direction wrt the plane.
Definition: PlaneSurface.cxx:256
drawFromPickle.tan
tan
Definition: drawFromPickle.py:36
Trk::LocalDirection
represents the three-dimensional global direction with respect to a planar surface frame.
Definition: LocalDirection.h:81
Trk::PrepRawData::identify
Identifier identify() const
return the identifier
RPC
@ RPC
Definition: RegSelEnums.h:32
Muon::MuonClusterOnTrackCreator::m_doFixedErrorTgcPhi
Gaudi::Property< bool > m_doFixedErrorTgcPhi
Definition: MuonClusterOnTrackCreator.h:91
Trk::PrepRawData::localPosition
const Amg::Vector2D & localPosition() const
return the local position reference
Trk::PrepRawDataType::sTgcPrepData
@ sTgcPrepData
Trk::Surface::insideBounds
virtual bool insideBounds(const Amg::Vector2D &locpos, double tol1=0., double tol2=0.) const =0
virtual methods to be overwritten by the inherited surfaces
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
MuonGM::TgcReadoutElement::stripPitch
double stripPitch(int gasGap, int strip) const
Returns the pitch of the given strip in gasGap i.
Definition: MuonDetDescr/MuonReadoutGeometry/src/TgcReadoutElement.cxx:182
Trk::ParametersBase::momentum
const Amg::Vector3D & momentum() const
Access method for the momentum.
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...
MuonGM::MMReadoutElement::spacePointPosition
virtual bool spacePointPosition(const Identifier &phiId, const Identifier &etaId, Amg::Vector2D &pos) const override final
space point position for a given pair of phi and eta identifiers The LocalPosition is expressed in th...
Definition: MMReadoutElement.h:307
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
Trk::PlaneSurface
Definition: PlaneSurface.h:64
Muon::MuonClusterOnTrackCreator::m_calibToolNSW
ToolHandle< Muon::INSWCalibTool > m_calibToolNSW
Definition: MuonClusterOnTrackCreator.h:83
re
const boost::regex re(r_e)
Muon::MuonClusterOnTrackCreator::m_fixedErrorTgcPhi
Gaudi::Property< double > m_fixedErrorTgcPhi
Definition: MuonClusterOnTrackCreator.h:95
MuonGM::MMReadoutElement
An MMReadoutElement corresponds to a single STGC module; therefore typicaly a barrel muon station con...
Definition: MMReadoutElement.h:25
Muon::MuonClusterOnTrackCreator::calibratedClusterSTG
MuonClusterOnTrack * calibratedClusterSTG(const Trk::PrepRawData &RIO, const Amg::Vector3D &GP, const Amg::Vector3D &GD) const
Definition: MuonClusterOnTrackCreator.cxx:332
Muon::MuonClusterOnTrackCreator::m_doFixedErrorTgcEta
Gaudi::Property< bool > m_doFixedErrorTgcEta
Definition: MuonClusterOnTrackCreator.h:89
Muon::MuonClusterOnTrackCreator::correct
virtual MuonClusterOnTrack * correct(const Trk::PrepRawData &RIO, const Trk::TrackParameters &TP, const EventContext &) const override
Create new Muon::MuonClusterOnTrack from a Trk::PrepRawData and the predicted Trk::TrackParameter at ...
Definition: MuonClusterOnTrackCreator.cxx:232
Muon::MuonClusterOnTrackCreator::calibratedClusterMMG
MuonClusterOnTrack * calibratedClusterMMG(const Trk::PrepRawData &RIO, const Amg::Vector3D &GP, const Amg::Vector3D &GD) const
Definition: MuonClusterOnTrackCreator.cxx:256
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
Trk::Surface
Definition: Tracking/TrkDetDescr/TrkSurfaces/TrkSurfaces/Surface.h:79
Trk::Surface::transform
const Amg::Transform3D & transform() const
Returns HepGeom::Transform3D by reference.
Muon::MuonClusterOnTrackCreator::m_fixedErrorRpcEta
Gaudi::Property< double > m_fixedErrorRpcEta
Definition: MuonClusterOnTrackCreator.h:94
geometry_dat_to_json.ld
ld
Definition: geometry_dat_to_json.py:33
generate::Zero
void Zero(TH1D *hin)
Definition: generate.cxx:32
Trk::PrepRawData::detectorElement
virtual const TrkDetElementBase * detectorElement() const =0
return the detector element corresponding to this PRD The pointer will be zero if the det el is not d...
Generated on Mon Oct 27 2025 21:59:23 for ATLAS Offline Software by   doxygen 1.8.18