ATLAS Offline Software
TgcRoadDefiner.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "TgcRoadDefiner.h"
6 #include "MdtRegion.h"
7 #include "xAODTrigMuon/L2StandAloneMuonAuxContainer.h"
8 #include "xAODTrigMuon/TrigMuonDefs.h"
9 
10 #include "AthenaBaseComps/AthMsgStreamMacros.h"
11 
12 #include <cmath>
13 
14 // --------------------------------------------------------------------------------
15 // --------------------------------------------------------------------------------
16 
17 TrigL2MuonSA::TgcRoadDefiner::TgcRoadDefiner(const std::string& type,
18  const std::string& name,
19  const IInterface* parent):
20  AthAlgTool(type, name, parent)
21 {
22 }
23 
24 // --------------------------------------------------------------------------------
25 // --------------------------------------------------------------------------------
26 
27 StatusCode TrigL2MuonSA::TgcRoadDefiner::initialize()
28 {
29 
30  ATH_CHECK(AthAlgTool::initialize());
31 
32  ATH_CHECK(m_regionSelector.retrieve());
33  ATH_MSG_DEBUG("Retrieved the RegionSelector tool ");
34 
35  ATH_CHECK(m_tgcFit.retrieve());
36  ATH_MSG_DEBUG("Retrieved service " << m_tgcFit);
37 
38  ATH_CHECK(m_idHelperSvc.retrieve());
39 
40  return StatusCode::SUCCESS;
41 }
42 
43 // --------------------------------------------------------------------------------
44 // --------------------------------------------------------------------------------
45 
46 StatusCode TrigL2MuonSA::TgcRoadDefiner::defineRoad(const EventContext& ctx,
47  const TrigRoiDescriptor* p_roids,
48  const bool insideOut,
49  const TrigL2MuonSA::TgcHits& tgcHits,
50  TrigL2MuonSA::MuonRoad& muonRoad,
51  TrigL2MuonSA::TgcFitResult& tgcFitResult) const
52 {
53  const int N_STATION = 10;
54  const int N_LAYER = 8;
55 
56  bool isMiddleFailure = true;
57 
58  // Define road by using TGC fit result
59  const double R_WIDTH_DEFAULT = 100;
60  const double R_WIDTH_INNER_NO_HIT = 200;
61 
62  const double ZERO_LIMIT = 1e-5;
63 
64  muonRoad.isEndcap = true;
65 
66  int side;
67  double roiEta;
68  double theta;
69  double aw;
70  int endcap_inner = xAOD::L2MuonParameters::Chamber::EndcapInner;
71  int endcap_middle = xAOD::L2MuonParameters::Chamber::EndcapMiddle;
72  int endcap_outer = xAOD::L2MuonParameters::Chamber::EndcapOuter;
73  int endcap_extra = xAOD::L2MuonParameters::Chamber::EndcapExtra;
74  int barrel_inner = xAOD::L2MuonParameters::Chamber::BarrelInner;
75  int csc = xAOD::L2MuonParameters::Chamber::CSC;
76  int bee = xAOD::L2MuonParameters::Chamber::BEE;
77 
78  TrigL2MuonSA::TgcFit::PointArray tgcStripMidPoints; // List of TGC strip middle station points.
79  TrigL2MuonSA::TgcFit::PointArray tgcWireMidPoints; // List of TGC wire middle station points.
80  TrigL2MuonSA::TgcFit::PointArray tgcStripInnPoints; // List of TGC strip inner station points.
81  TrigL2MuonSA::TgcFit::PointArray tgcWireInnPoints; // List of TGC wire inner station points.
82 
83  if (tgcHits.size()>0) {
84  // TGC data is properly read
85 
86  // Split digits to Strip/Wire points.
87  if( ! prepareTgcPoints(tgcHits, tgcStripInnPoints, tgcWireInnPoints, tgcStripMidPoints, tgcWireMidPoints) ) {
88  ATH_MSG_ERROR("Preparation of Tgc points failed");
89  return StatusCode::FAILURE;
90  }
91 
92 
93  // Fit lines to TGC middle station
94  isMiddleFailure = false;
95  TgcFit::Status status = m_tgcFit->runTgcMiddle(tgcStripMidPoints, tgcWireMidPoints, tgcFitResult);
96  if (status == TgcFit::FIT_NONE) {
97  ATH_MSG_WARNING("Fit to TGC middle station points failed");
98  isMiddleFailure = true;
99  }
100  else if (status == TgcFit::FIT_POINT) {
101  ATH_MSG_DEBUG("Fit to TGC middle station returns only a point");
102  }
103 
104  // Fit lines to TGC inner station
105  status = m_tgcFit->runTgcInner(tgcStripInnPoints, tgcWireInnPoints, tgcFitResult);
106  if (status == TgcFit::FIT_NONE) {
107  ATH_MSG_DEBUG("Fit to TGC inner station points failed");
108  }
109  else if (status == TgcFit::FIT_POINT) {
110  ATH_MSG_DEBUG("Fit to TGC inner station returns only a point");
111  }
112 
113  ATH_MSG_DEBUG("tgcFitResult.tgcInn[0/1/2/3]=" << tgcFitResult.tgcInn[0] << "/" << tgcFitResult.tgcInn[1]
114  << "/" << tgcFitResult.tgcInn[2] << "/" << tgcFitResult.tgcInn[3]);
115  ATH_MSG_DEBUG("tgcFitResult.tgcMid1[0/1/2/3]=" << tgcFitResult.tgcMid1[0] << "/" << tgcFitResult.tgcMid1[1]
116  << "/" << tgcFitResult.tgcMid1[2] << "/" << tgcFitResult.tgcMid1[3]);
117  ATH_MSG_DEBUG("tgcFitResult.tgcMid2[0/1/2/3]=" << tgcFitResult.tgcMid2[0] << "/" << tgcFitResult.tgcMid2[1]
118  << "/" << tgcFitResult.tgcMid2[2] << "/" << tgcFitResult.tgcMid2[3]);
119  } else {
120  ATH_MSG_DEBUG("Skip TGC Fit due to zero-tgcHits");
121  }
122 
123  if (tgcHits.size()>0 && !isMiddleFailure){
124 
125  tgcFitResult.isSuccess = true;
126 
127  // PT calculation by using TGC fit result
128  const double PHI_RANGE = 12./(M_PI/8.);
129  side = (tgcFitResult.tgcMid2[3]<=0) ? 0 : 1;
130  double alpha = (*m_ptEndcapLUT)->alpha(tgcFitResult.tgcMid1[3], tgcFitResult.tgcMid1[2],
131  tgcFitResult.tgcMid2[3], tgcFitResult.tgcMid2[2]);
132 
133  int Octant = (int)(tgcFitResult.tgcMid1[1] / (M_PI/4.));
134  double PhiInOctant = std::abs(tgcFitResult.tgcMid1[1] - Octant * (M_PI/4.));
135  if (PhiInOctant > (M_PI/8.)) PhiInOctant = (M_PI/4.) - PhiInOctant;
136 
137  int phiBin = static_cast<int>(PhiInOctant * PHI_RANGE);
138  int etaBin = static_cast<int>((std::abs(tgcFitResult.tgcMid1[0]) - 1.)/0.05);
139 
140  int charge = (tgcFitResult.intercept * tgcFitResult.tgcMid2[3]) < 0.0 ? 0: 1;
141 
142  tgcFitResult.tgcPT = (*m_ptEndcapLUT)->lookup(side, charge, PtEndcapLUT::TGCALPHAPOL2, etaBin, phiBin, alpha) / 1000.;
143  if (charge==0) tgcFitResult.tgcPT = -1.*tgcFitResult.tgcPT;
144 
145  // Determine phi direction
146  if (std::abs(tgcFitResult.tgcMid1[3])<=ZERO_LIMIT || std::abs(tgcFitResult.tgcMid2[3])<=ZERO_LIMIT) {
147 
148  tgcFitResult.isPhiDir = false;
149  if (std::abs(tgcFitResult.tgcMid1[3])>=0.) tgcFitResult.phi = tgcFitResult.tgcMid1[1];
150  if (std::abs(tgcFitResult.tgcMid2[3])>=0.) tgcFitResult.phi = tgcFitResult.tgcMid2[1];
151 
152  } else {
153 
154  tgcFitResult.isPhiDir = true;
155 
156  if( tgcFitResult.tgcMid1[1]*tgcFitResult.tgcMid2[1] < 0
157  && std::abs(tgcFitResult.tgcMid1[1])>M_PI/2. ) {
158 
159  double tmp1 = (tgcFitResult.tgcMid1[1]>0)?
160  tgcFitResult.tgcMid1[1] - M_PI : tgcFitResult.tgcMid1[1] + M_PI;
161 
162  double tmp2 = (tgcFitResult.tgcMid2[1]>0)?
163  tgcFitResult.tgcMid2[1] - M_PI : tgcFitResult.tgcMid2[1] + M_PI;
164 
165  double tmp = (tmp1+tmp2)/2.;
166 
167  tgcFitResult.dPhidZ = (std::abs(tgcFitResult.tgcMid2[3]-tgcFitResult.tgcMid1[3]) > ZERO_LIMIT)?
168  (tmp2-tmp1)/std::abs(tgcFitResult.tgcMid2[3]-tgcFitResult.tgcMid1[3]): 0;
169 
170  tgcFitResult.phi = (tmp>0.)? tmp - M_PI : tmp + M_PI;
171 
172  } else {
173 
174  tgcFitResult.dPhidZ = (std::abs(tgcFitResult.tgcMid2[3]-tgcFitResult.tgcMid1[3]) > ZERO_LIMIT)?
175  (tgcFitResult.tgcMid2[1]-tgcFitResult.tgcMid1[1])/std::abs(tgcFitResult.tgcMid2[3]-tgcFitResult.tgcMid1[3]): 0;
176  tgcFitResult.phi = (tgcFitResult.tgcMid2[1]+tgcFitResult.tgcMid1[1])/2.;
177 
178  }
179  }
180  float X1 = tgcFitResult.tgcMid1[3] * std::cos(tgcFitResult.tgcMid1[1]);
181  float Y1 = tgcFitResult.tgcMid1[3] * std::sin(tgcFitResult.tgcMid1[1]);
182  float X2 = tgcFitResult.tgcMid2[3] * std::cos(tgcFitResult.tgcMid2[1]);
183  float Y2 = tgcFitResult.tgcMid2[3] * std::sin(tgcFitResult.tgcMid2[1]);
184  if (X1>ZERO_LIMIT && X2>ZERO_LIMIT) tgcFitResult.phiDir = (Y1/X1 + Y2/X2)/2.;
185 
186  muonRoad.aw[endcap_middle][0] = tgcFitResult.slope;
187  muonRoad.bw[endcap_middle][0] = tgcFitResult.intercept;
188  muonRoad.aw[endcap_outer][0] = tgcFitResult.slope;
189  muonRoad.bw[endcap_outer][0] = tgcFitResult.intercept;
190  muonRoad.aw[endcap_extra][0] = tgcFitResult.slope;
191  muonRoad.bw[endcap_extra][0] = tgcFitResult.intercept;
192  muonRoad.aw[bee][0] = tgcFitResult.slope;
193  muonRoad.bw[bee][0] = tgcFitResult.intercept;
194  for (int i_layer=0; i_layer<N_LAYER; i_layer++) {
195  muonRoad.rWidth[endcap_middle][i_layer] = R_WIDTH_DEFAULT;
196  muonRoad.rWidth[endcap_outer][i_layer] = R_WIDTH_DEFAULT;
197  muonRoad.rWidth[endcap_extra][i_layer] = R_WIDTH_DEFAULT;
198  muonRoad.rWidth[bee][i_layer] = R_WIDTH_DEFAULT;
199  }
200 
201  if( std::abs(tgcFitResult.tgcInn[3]) > ZERO_LIMIT ) {
202  muonRoad.aw[endcap_inner][0] = tgcFitResult.tgcInn[2]/tgcFitResult.tgcInn[3];
203  muonRoad.aw[barrel_inner][0] = tgcFitResult.tgcInn[2]/tgcFitResult.tgcInn[3];
204  muonRoad.aw[csc][0] = tgcFitResult.tgcInn[2]/tgcFitResult.tgcInn[3];
205  for (int i_layer=0; i_layer<N_LAYER; i_layer++) muonRoad.rWidth[endcap_inner][i_layer] = R_WIDTH_DEFAULT;
206  for (int i_layer=0; i_layer<N_LAYER; i_layer++) muonRoad.rWidth[barrel_inner][i_layer] = R_WIDTH_DEFAULT;
207  for (int i_layer=0; i_layer<N_LAYER; i_layer++) muonRoad.rWidth[csc][i_layer] = R_WIDTH_DEFAULT;
208  } else {
209  // use the back extrapolator to retrieve the Etain the Innermost
210 
211  double etaMiddle = (tgcFitResult.tgcMid1[3])? tgcFitResult.tgcMid1[0] : tgcFitResult.tgcMid2[0];
212  double phiMiddle = (tgcFitResult.tgcMid1[3])? tgcFitResult.tgcMid1[1] : tgcFitResult.tgcMid2[1];
213  double eta;
214  double sigma_eta;
215  double extrInnerEta = 0;
216 
217  xAOD::L2StandAloneMuon* muonSA = new xAOD::L2StandAloneMuon();
218  muonSA->makePrivateStore();
219  muonSA->setSAddress(-1);
220  muonSA->setPt(tgcFitResult.tgcPT);
221  muonSA->setEtaMS(etaMiddle);
222  muonSA->setPhiMS(phiMiddle);
223  muonSA->setRMS(0.);
224  muonSA->setZMS(0.);
225 
226  double phi;
227  double sigma_phi;
228 
229  if (m_backExtrapolatorTool) {
230  StatusCode sc
231  = (*m_backExtrapolatorTool)->give_eta_phi_at_vertex(muonSA, eta,sigma_eta,phi,sigma_phi,0.);
232  if (sc.isSuccess() ){
233  extrInnerEta = eta;
234  } else {
235  extrInnerEta = etaMiddle;
236  }
237  } else {
238  ATH_MSG_ERROR("Null pointer to ITrigMuonBackExtrapolator");
239  return StatusCode::FAILURE;
240  }
241 
242  if (muonSA) delete muonSA;
243 
244  double theta = 0.;
245  if (extrInnerEta != 0.) {
246  theta = std::atan(std::exp(-std::abs(extrInnerEta)))*2.;
247  muonRoad.aw[endcap_inner][0] = std::tan(theta)*(std::abs(extrInnerEta)/extrInnerEta);
248  muonRoad.aw[barrel_inner][0] = std::tan(theta)*(std::abs(extrInnerEta)/extrInnerEta);
249  muonRoad.aw[csc][0] = std::tan(theta)*(std::abs(extrInnerEta)/extrInnerEta);
250  } else {
251  muonRoad.aw[endcap_inner][0] = 0;
252  muonRoad.aw[barrel_inner][0] = 0;
253  muonRoad.aw[csc][0] = 0;
254  }
255 
256  for (int i_layer=0; i_layer<N_LAYER; i_layer++) muonRoad.rWidth[endcap_inner][i_layer] = R_WIDTH_INNER_NO_HIT;
257  for (int i_layer=0; i_layer<N_LAYER; i_layer++) muonRoad.rWidth[barrel_inner][i_layer] = R_WIDTH_INNER_NO_HIT;
258  for (int i_layer=0; i_layer<N_LAYER; i_layer++) muonRoad.rWidth[csc][i_layer] = R_WIDTH_INNER_NO_HIT;
259 
260  }
261 
262  muonRoad.bw[endcap_inner][0] = 0.;
263  muonRoad.bw[barrel_inner][0] = 0.;
264  muonRoad.bw[csc][0] = 0.;
265 
266  } else {
267  // If no TGC hit are available, estimate the road from RoI
268  // or if inside-out mode, width is tuned based on FTF track extrapolation resolution
269  ATH_MSG_DEBUG("Because no TGC hits are available, estimate the road from RoI");
270 
271  roiEta = p_roids->eta();
272  theta = std::atan(std::exp(-std::abs(roiEta)))*2.;
273  aw = (std::abs(roiEta) > ZERO_LIMIT)? std::tan(theta)*(std::abs(roiEta)/roiEta): 0.;
274 
275  muonRoad.aw[endcap_inner][0] = aw;
276  muonRoad.bw[endcap_inner][0] = 0;
277  muonRoad.aw[endcap_middle][0] = aw;
278  muonRoad.bw[endcap_middle][0] = 0;
279  muonRoad.aw[endcap_outer][0] = aw;
280  muonRoad.bw[endcap_outer][0] = 0;
281  muonRoad.aw[endcap_extra][0] = aw;
282  muonRoad.bw[endcap_extra][0] = 0;
283  muonRoad.aw[barrel_inner][0] = aw;
284  muonRoad.bw[barrel_inner][0] = 0;
285  muonRoad.aw[bee][0] = aw;
286  muonRoad.bw[bee][0] = 0;
287  muonRoad.aw[csc][0] = aw;
288  muonRoad.bw[csc][0] = 0;
289  for (int i_layer=0; i_layer<N_LAYER; i_layer++) {
290  if(insideOut) {
291  muonRoad.rWidth[endcap_inner][i_layer] = 300;
292  muonRoad.rWidth[endcap_middle][i_layer] = 400;
293  muonRoad.rWidth[endcap_outer][i_layer] = 600;
294  muonRoad.rWidth[endcap_extra][i_layer] = 400;
295  muonRoad.rWidth[barrel_inner][i_layer] = 250;
296  muonRoad.rWidth[bee][i_layer] = 500;
297  muonRoad.rWidth[csc][i_layer] = 200;
298  } else {
299  muonRoad.rWidth[endcap_inner][i_layer] = m_rWidth_TGC_Failed;
300  muonRoad.rWidth[endcap_middle][i_layer] = m_rWidth_TGC_Failed;
301  muonRoad.rWidth[endcap_outer][i_layer] = m_rWidth_TGC_Failed;
302  muonRoad.rWidth[endcap_extra][i_layer] = m_rWidth_TGC_Failed;
303  muonRoad.rWidth[barrel_inner][i_layer] = m_rWidth_TGC_Failed;
304  muonRoad.rWidth[bee][i_layer] = m_rWidth_TGC_Failed;
305  muonRoad.rWidth[csc][i_layer] = m_rWidth_TGC_Failed;
306  }
307  }
308  }
309 
310  for(int i=0; i<N_STATION; i++) {
311  muonRoad.aw[i][1] = muonRoad.aw[i][0];
312  muonRoad.bw[i][1] = muonRoad.bw[i][0];
313  }
314 
315  //
316  side = 0;
317  float phiMiddle = 0;
318  if( ! isMiddleFailure ) {
319  side = (tgcFitResult.tgcMid1[3]<0.)? 0 : 1;
320  phiMiddle = tgcFitResult.tgcMid1[1];
321  } else {
322  side = (p_roids->eta()<0.)? 0 : 1;
323  phiMiddle = p_roids->phi();
324  }
325  muonRoad.side = side;
326  muonRoad.phiMiddle = phiMiddle;
327  muonRoad.phiRoI = p_roids->phi();
328 
329  int sector_trigger = 99;
330  int sector_overlap = 99;
331  int temp_sector=99;
332  float deltaPhi=99;
333  float tempDeltaPhi=99;
334  std::vector<Identifier> stationList;
335  std::vector<IdentifierHash> mdtHashList;
336 
337  // get sector_trigger and sector_overlap by using the region selector
338  IdContext context = m_idHelperSvc->mdtIdHelper().module_context();
339 
340  double etaMin = p_roids->eta()-.02;
341  double etaMax = p_roids->eta()+.02;
342  double phiMin = muonRoad.phiMiddle-.01;
343  double phiMax = muonRoad.phiMiddle+.01;
344  if(phiMax > M_PI) phiMax -= M_PI*2.;
345  if(phiMin < M_PI*-1) phiMin += M_PI*2.;
346  TrigRoiDescriptor* roi = new TrigRoiDescriptor( p_roids->eta(), etaMin, etaMax, p_roids->phi(), phiMin, phiMax );
347  const IRoiDescriptor* iroi = static_cast<IRoiDescriptor*> (roi);
348  if (iroi) m_regionSelector->lookup(ctx)->HashIDList(*iroi, mdtHashList);
349  else {
350  TrigRoiDescriptor fullscan_roi( true );
351  m_regionSelector->lookup(ctx)->HashIDList(fullscan_roi, mdtHashList);
352  }
353  if(roi) delete roi;
354 
355  for(const IdentifierHash& i_hash : mdtHashList ){
356  Identifier id;
357  int convert = m_idHelperSvc->mdtIdHelper().get_id(i_hash, id, &context);
358 
359  if(convert!=0) ATH_MSG_ERROR("problem converting hash list to id");
360 
361  muonRoad.stationList.push_back(id);
362  std::string name = m_idHelperSvc->mdtIdHelper().stationNameString(m_idHelperSvc->mdtIdHelper().stationName(id));
363  if ( name.substr(0, 1) == "B" ) continue;
364  if ( name.substr(1, 1) != "M" ) continue;
365  int stationPhi = m_idHelperSvc->mdtIdHelper().stationPhi(id);
366  float floatPhi = (stationPhi-1)*M_PI/4;
367  if (name[2]=='S' || name[2]=='E') floatPhi = floatPhi + M_PI/8;
368  tempDeltaPhi = std::abs(floatPhi-muonRoad.phiMiddle);
369  if (phiMiddle<0) tempDeltaPhi = std::abs(floatPhi-muonRoad.phiMiddle-2*M_PI);
370  if(tempDeltaPhi > M_PI) tempDeltaPhi = std::abs(tempDeltaPhi - 2*M_PI);
371 
372  int LargeSmall = 0;
373  if(name[2]=='S' || name[2]=='E') LargeSmall = 1;
374  int sector = (stationPhi-1)*2 + LargeSmall;
375  if(sector_trigger == 99)
376  sector_trigger = sector;
377  else if(sector_trigger != sector)
378  sector_overlap = sector;
379 
380  if(tempDeltaPhi < deltaPhi){
381  deltaPhi = tempDeltaPhi;
382  temp_sector = sector;
383  muonRoad.LargeSmall=LargeSmall;
384  }
385 
386  }
387  if(temp_sector != sector_trigger){
388  sector_overlap = sector_trigger;
389  sector_trigger = temp_sector;
390  }
391 
392  muonRoad.MDT_sector_trigger = sector_trigger;
393  muonRoad.MDT_sector_overlap = sector_overlap;
394 
395  if (insideOut) {
396  muonRoad.side = (muonRoad.extFtfMiddleEta<0.)? 0 : 1;
397  muonRoad.phiMiddle = muonRoad.extFtfMiddlePhi;
398  muonRoad.phiRoI = p_roids->phi();
399  for (int i_sector=0; i_sector<N_SECTOR; i_sector++) {
400  ATH_MSG_DEBUG("Use aw_ftf and bw_ftf as aw and bw");
401  muonRoad.aw[endcap_inner][i_sector] = muonRoad.aw_ftf[3][0];
402  muonRoad.bw[endcap_inner][i_sector] = muonRoad.bw_ftf[3][0];
403  muonRoad.aw[endcap_middle][i_sector] = muonRoad.aw_ftf[4][0];
404  muonRoad.bw[endcap_middle][i_sector] = muonRoad.bw_ftf[4][0];
405  muonRoad.aw[endcap_outer][i_sector] = muonRoad.aw_ftf[5][0];
406  muonRoad.bw[endcap_outer][i_sector] = muonRoad.bw_ftf[5][0];
407  muonRoad.aw[endcap_extra][i_sector] = muonRoad.aw_ftf[6][0];
408  muonRoad.bw[endcap_extra][i_sector] = muonRoad.bw_ftf[6][0];
409  muonRoad.aw[csc][i_sector] = muonRoad.aw_ftf[7][0];
410  muonRoad.bw[csc][i_sector] = muonRoad.bw_ftf[7][0];
411  muonRoad.aw[bee][i_sector] = muonRoad.aw_ftf[8][0];
412  muonRoad.bw[bee][i_sector] = muonRoad.bw_ftf[8][0];
413  muonRoad.aw[barrel_inner][i_sector] = muonRoad.aw_ftf[0][0];
414  muonRoad.bw[barrel_inner][i_sector] = muonRoad.bw_ftf[0][0];
415  }
416  }
417 
418  //
419  return StatusCode::SUCCESS;
420 }
421 
422 // --------------------------------------------------------------------------------
423 // --------------------------------------------------------------------------------
424 
425 bool TrigL2MuonSA::TgcRoadDefiner::prepareTgcPoints(const TrigL2MuonSA::TgcHits& tgcHits,
426  TrigL2MuonSA::TgcFit::PointArray& tgcStripInnPoints,
427  TrigL2MuonSA::TgcFit::PointArray& tgcWireInnPoints,
428  TrigL2MuonSA::TgcFit::PointArray& tgcStripMidPoints,
429  TrigL2MuonSA::TgcFit::PointArray& tgcWireMidPoints) const
430 {
431  const double PHI_BOUNDARY = 0.2;
432 
433  tgcStripMidPoints.clear();
434  tgcStripInnPoints.clear();
435  tgcWireMidPoints.clear();
436  tgcWireInnPoints.clear();
437 
438  // loop over TGC digits.
439  unsigned int iHit;
440  for (iHit = 0; iHit < tgcHits.size(); iHit++)
441  {
442  // Get the digit point.
443  const TrigL2MuonSA::TgcHitData& hit = tgcHits[iHit];
444 
445  // reject width=0 hits
446  const double ZERO_LIMIT = 1e-5;
447  if( std::abs(hit.width) < ZERO_LIMIT ) continue;
448 
449  double w = 12.0 / hit.width / hit.width;
450  if (hit.isStrip)
451  {
452  w *= hit.r * hit.r;
453  double phi = hit.phi;
454  if( phi < 0 && ( (M_PI+phi)<PHI_BOUNDARY) ) phi += M_PI*2;
455  if ( hit.sta < 3 ) { tgcStripMidPoints.push_back(TgcFit::Point(iHit + 1, hit.sta, hit.z, phi, w)); }
456  else if ( hit.sta ==3 ) { tgcStripInnPoints.push_back(TgcFit::Point(iHit + 1, hit.sta, hit.z, phi, w)); }
457  }
458  else
459  {
460  if ( hit.sta < 3 ) { tgcWireMidPoints.push_back(TgcFit::Point(iHit + 1, hit.sta, hit.z, hit.r, w)); }
461  else if ( hit.sta ==3 ) { tgcWireInnPoints.push_back(TgcFit::Point(iHit + 1, hit.sta, hit.z, hit.r, w)); }
462  }
463  }
464 
465  ATH_MSG_DEBUG(", tgcStripMidPoints.size()=" << tgcStripMidPoints.size() <<
466  ", tgcStripInnPoints.size()=" << tgcStripInnPoints.size() <<
467  ", tgcWireMidPoints.size()=" << tgcWireMidPoints.size() <<
468  ", tgcWireInnPoints.size()=" << tgcWireInnPoints.size());
469 
470  return true;
471 }
TrigL2MuonSA::MuonRoad::MDT_sector_overlap
int MDT_sector_overlap
Definition: MuonRoad.h:89
TrigL2MuonSA::N_SECTOR
constexpr int N_SECTOR
Definition: MuonRoad.h:16
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
add-xsec-uncert-quadrature-N.alpha
alpha
Definition: add-xsec-uncert-quadrature-N.py:110
DeMoUpdate.tmp2
string tmp2
Definition: DeMoUpdate.py:1168
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
AthMsgStreamMacros.h
TrigL2MuonSA::TgcHitData::sta
int sta
Definition: TgcData.h:34
TrigL2MuonSA::TgcHitData::phi
double phi
Definition: TgcData.h:30
TrigL2MuonSA::MuonRoad::phiMiddle
double phiMiddle
Definition: MuonRoad.h:81
TrigL2MuonSA::N_LAYER
constexpr int N_LAYER
Definition: MuonRoad.h:17
xAOD::L2StandAloneMuon_v2
Class describing standalone muons reconstructed in the LVL2 trigger.
Definition: L2StandAloneMuon_v2.h:36
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
TrigL2MuonSA::TgcFit::Status
Status
Definition: TgcFit.h:25
TrigL2MuonSA::TgcFit::FIT_POINT
@ FIT_POINT
Definition: TgcFit.h:27
xAOD::deltaPhi
setSAddress setEtaMS setDirPhiMS setDirZMS setBarrelRadius setEndcapAlpha setEndcapRadius setInterceptInner setEtaMap setEtaBin setIsTgcFailure setDeltaPt deltaPhi
Definition: L2StandAloneMuon_v1.cxx:161
initialize
void initialize()
Definition: run_EoverP.cxx:894
xAOD::L2MuonParameters::BEE
@ BEE
BEE measurement point.
Definition: TrigMuonDefs.h:24
xAOD::L2MuonParameters::EndcapExtra
@ EndcapExtra
Extra station in the endcap spectrometer.
Definition: TrigMuonDefs.h:22
TrigL2MuonSA::TgcFitResult
Definition: TgcFitResult.h:11
theta
Scalar theta() const
theta method
Definition: AmgMatrixBasePlugin.h:75
TrigL2MuonSA::TgcHits
std::vector< TgcHitData > TgcHits
Definition: TgcData.h:43
TrigL2MuonSA::MuonRoad::bw
double bw[N_STATION][N_SECTOR]
Definition: MuonRoad.h:84
xAOD::L2StandAloneMuon_v2::setPt
void setPt(float pt)
Set the transverse momentum ( ) of the muon.
M_PI
#define M_PI
Definition: ActiveFraction.h:11
TrigL2MuonSA::MuonRoad::isEndcap
bool isEndcap
Definition: MuonRoad.h:74
xAOD::L2MuonParameters::BarrelInner
@ BarrelInner
Inner station in the barrel spectrometer.
Definition: TrigMuonDefs.h:16
xAOD::etaMax
etaMax
Definition: HIEventShape_v2.cxx:46
xAOD::L2StandAloneMuon_v2::setPhiMS
void setPhiMS(float value)
Set the phi at muon spectrometer.
xAOD::L2StandAloneMuon_v2::setEtaMS
void setEtaMS(float value)
Set the eta at muon spectrometer.
TrigRoiDescriptor
nope - should be used for standalone also, perhaps need to protect the class def bits #ifndef XAOD_AN...
Definition: TrigRoiDescriptor.h:56
xAOD::roiEta
setTeId setLumiBlock setRoiId setRoiSubsystem setRoiNumber roiEta
Definition: L2StandAloneMuon_v2.cxx:344
TrigL2MuonSA::TgcFitResult::phiDir
double phiDir
Definition: TgcFitResult.h:68
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
drawFromPickle.exp
exp
Definition: drawFromPickle.py:36
xAOD::L2StandAloneMuon_v2::setRMS
void setRMS(float value)
Set the R at muon spectrometer.
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
TrigL2MuonSA::MuonRoad::aw
double aw[N_STATION][N_SECTOR]
Definition: MuonRoad.h:83
drawFromPickle.atan
atan
Definition: drawFromPickle.py:36
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
TrigL2MuonSA::TgcHitData::isStrip
bool isStrip
Definition: TgcData.h:35
TrigL2MuonSA::MuonRoad::side
int side
Definition: MuonRoad.h:78
TrigL2MuonSA::MuonRoad::phiRoI
double phiRoI
Definition: MuonRoad.h:82
TRT::Hit::side
@ side
Definition: HitInfo.h:83
TrigL2MuonSA::MuonRoad::stationList
std::vector< Identifier > stationList
Definition: MuonRoad.h:102
xAOD::etaBin
setSAddress setEtaMS setDirPhiMS setDirZMS setBarrelRadius setEndcapAlpha setEndcapRadius setInterceptInner setEtaMap etaBin
Definition: L2StandAloneMuon_v1.cxx:149
TrigL2MuonSA::TgcFit::Point
Definition: TgcFit.h:35
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
TrigL2MuonSA::TgcFitResult::tgcMid2
float tgcMid2[4]
Definition: TgcFitResult.h:46
TrigL2MuonSA::TgcFitResult::isSuccess
bool isSuccess
Definition: TgcFitResult.h:39
lumiFormat.i
int i
Definition: lumiFormat.py:85
xAOD::L2StandAloneMuon_v2::setSAddress
void setSAddress(int value)
Set the station address of the muon.
TrigL2MuonSA::MuonRoad
Definition: MuonRoad.h:20
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
IRoiDescriptor
Describes the API of the Region of Ineterest geometry.
Definition: IRoiDescriptor.h:23
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
TrigL2MuonSA::TgcFitResult::intercept
float intercept
Definition: TgcFitResult.h:66
TrigL2MuonSA::TgcFit::FIT_NONE
@ FIT_NONE
Definition: TgcFit.h:26
TrigL2MuonSA::MuonRoad::MDT_sector_trigger
int MDT_sector_trigger
Definition: MuonRoad.h:88
test_pyathena.parent
parent
Definition: test_pyathena.py:15
TgcRoadDefiner.h
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
TrigL2MuonSA::TgcFitResult::tgcMid1
float tgcMid1[4]
Definition: TgcFitResult.h:45
TrigL2MuonSA::TgcHitData
Definition: TgcData.h:14
drawFromPickle.tan
tan
Definition: drawFromPickle.py:36
TrigL2MuonSA::TgcHitData::width
double width
Definition: TgcData.h:33
TrigL2MuonSA::TgcRoadDefiner::defineRoad
StatusCode defineRoad(const EventContext &ctx, const TrigRoiDescriptor *p_roids, const bool insideOut, const TrigL2MuonSA::TgcHits &tgcHits, TrigL2MuonSA::MuonRoad &muonRoad, TrigL2MuonSA::TgcFitResult &tgcFitResult) const
Definition: TgcRoadDefiner.cxx:46
DeMoUpdate.tmp
string tmp
Definition: DeMoUpdate.py:1167
TrigL2MuonSA::TgcHitData::r
double r
Definition: TgcData.h:31
TrigL2MuonSA::TgcFitResult::slope
float slope
Definition: TgcFitResult.h:65
MdtRegion.h
ZERO_LIMIT
const float ZERO_LIMIT
Definition: VP1TriggerHandleL2.cxx:37
TrigL2MuonSA::TgcFitResult::dPhidZ
double dPhidZ
Definition: TgcFitResult.h:71
xAOD::L2MuonParameters::EndcapMiddle
@ EndcapMiddle
Middle station in the endcap spectrometer.
Definition: TrigMuonDefs.h:20
id
SG::auxid_t id
Definition: Control/AthContainers/Root/debug.cxx:239
TrigL2MuonSA::MuonRoad::bw_ftf
double bw_ftf[N_STATION][N_SECTOR]
Definition: MuonRoad.h:95
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
xAOD::phiBin
setSAddress setEtaMS setDirPhiMS setDirZMS setBarrelRadius setEndcapAlpha setEndcapRadius setPhiMap phiBin
Definition: L2StandAloneMuon_v2.cxx:145
charge
double charge(const T &p)
Definition: AtlasPID.h:991
TrigL2MuonSA::TgcFitResult::phi
double phi
Definition: TgcFitResult.h:70
SG::AuxElement::makePrivateStore
void makePrivateStore()
Create a new (empty) private store for this object.
Definition: AuxElement.cxx:192
TrigL2MuonSA::TgcFitResult::tgcInn
float tgcInn[4]
Definition: TgcFitResult.h:55
TrigL2MuonSA::N_STATION
constexpr int N_STATION
Definition: MuonRoad.h:15
TMVAToMVAUtils::convert
std::unique_ptr< MVAUtils::BDT > convert(TMVA::MethodBDT *bdt, bool isRegression=true, bool useYesNoLeaf=false)
Definition: TMVAToMVAUtils.h:114
TrigL2MuonSA::PtEndcapLUT::TGCALPHAPOL2
@ TGCALPHAPOL2
Definition: PtEndcapLUT.h:24
TrigMuonDefs.h
xAOD::L2StandAloneMuon_v2::setZMS
void setZMS(float value)
Set the Z at muon spectrometer.
TrigL2MuonSA::MuonRoad::LargeSmall
int LargeSmall
Definition: MuonRoad.h:79
TrigL2MuonSA::TgcRoadDefiner::prepareTgcPoints
bool prepareTgcPoints(const TrigL2MuonSA::TgcHits &tgcHits, TrigL2MuonSA::TgcFit::PointArray &tgcStripInnPoints, TrigL2MuonSA::TgcFit::PointArray &tgcWireInnPoints, TrigL2MuonSA::TgcFit::PointArray &tgcStripMidPoints, TrigL2MuonSA::TgcFit::PointArray &tgcWireMidPoints) const
Definition: TgcRoadDefiner.cxx:425
TrigL2MuonSA::TgcFitResult::tgcPT
float tgcPT
Definition: TgcFitResult.h:63
LArCellBinning.etaMin
etaMin
Definition: LArCellBinning.py:84
TrigL2MuonSA::MuonRoad::rWidth
double rWidth[N_STATION][N_LAYER]
Definition: MuonRoad.h:86
python.CaloAddPedShiftConfig.int
int
Definition: CaloAddPedShiftConfig.py:45
TrigL2MuonSA::TgcHitData::z
double z
Definition: TgcData.h:32
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
RoiDescriptor::phi
virtual double phi() const override final
Methods to retrieve data members.
Definition: RoiDescriptor.h:100
xAOD::L2MuonParameters::EndcapInner
@ EndcapInner
Inner station in the endcap spectrometer.
Definition: TrigMuonDefs.h:19
TrigL2MuonSA::MuonRoad::extFtfMiddlePhi
double extFtfMiddlePhi
Definition: MuonRoad.h:93
RoiDescriptor::eta
virtual double eta() const override final
Definition: RoiDescriptor.h:101
TrigL2MuonSA::MuonRoad::aw_ftf
double aw_ftf[N_STATION][N_SECTOR]
Definition: MuonRoad.h:94
TrigL2MuonSA::TgcFit::PointArray
std::vector< Point > PointArray
Definition: TgcFit.h:86
TrigRoiDescriptor
Athena::TPCnvVers::Current TrigRoiDescriptor
Definition: TrigSteeringEventTPCnv.cxx:68
merge.status
status
Definition: merge.py:16
CSC
@ CSC
Definition: RegSelEnums.h:34
TrigL2MuonSA::TgcRoadDefiner::TgcRoadDefiner
TgcRoadDefiner(const std::string &type, const std::string &name, const IInterface *parent)
Definition: TgcRoadDefiner.cxx:17
TrigL2MuonSA::TgcFitResult::isPhiDir
bool isPhiDir
Definition: TgcFitResult.h:69
TrigL2MuonSA::MuonRoad::extFtfMiddleEta
double extFtfMiddleEta
Definition: MuonRoad.h:92
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
AthAlgTool
Definition: AthAlgTool.h:26
xAOD::L2StandAloneMuon
L2StandAloneMuon_v2 L2StandAloneMuon
Define the latest version of the muon SA class.
Definition: L2StandAloneMuon.h:17
IdentifierHash
This is a "hash" representation of an Identifier. This encodes a 32 bit index which can be used to lo...
Definition: IdentifierHash.h:25
python.IoTestsLib.w
def w
Definition: IoTestsLib.py:198
TrigL2MuonSA::TgcRoadDefiner::initialize
virtual StatusCode initialize() override
Definition: TgcRoadDefiner.cxx:27
IdContext
This class saves the "context" of an expanded identifier (ExpandedIdentifier) for compact or hash ver...
Definition: IdContext.h:26
xAOD::L2MuonParameters::EndcapOuter
@ EndcapOuter
Outer station in the endcap spectrometer.
Definition: TrigMuonDefs.h:21
L2StandAloneMuonAuxContainer.h
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Mon Sep 29 2025 21:20:11 for ATLAS Offline Software by   doxygen 1.8.18