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