ATLAS Offline Software
Loading...
Searching...
No Matches
TgcRoadDefiner.cxx
Go to the documentation of this file.
1/*
2 Copyright (C) 2002-2026 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
17TrigL2MuonSA::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
27StatusCode 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
46StatusCode 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 delete muonSA;
240 return StatusCode::FAILURE;
241 }
242
243 delete muonSA;
244
245 double theta = 0.;
246 if (extrInnerEta != 0.) {
247 theta = std::atan(std::exp(-std::abs(extrInnerEta)))*2.;
248 muonRoad.aw[endcap_inner][0] = std::tan(theta)*(std::abs(extrInnerEta)/extrInnerEta);
249 muonRoad.aw[barrel_inner][0] = std::tan(theta)*(std::abs(extrInnerEta)/extrInnerEta);
250 muonRoad.aw[csc][0] = std::tan(theta)*(std::abs(extrInnerEta)/extrInnerEta);
251 } else {
252 muonRoad.aw[endcap_inner][0] = 0;
253 muonRoad.aw[barrel_inner][0] = 0;
254 muonRoad.aw[csc][0] = 0;
255 }
256
257 for (int i_layer=0; i_layer<N_LAYER; i_layer++) muonRoad.rWidth[endcap_inner][i_layer] = R_WIDTH_INNER_NO_HIT;
258 for (int i_layer=0; i_layer<N_LAYER; i_layer++) muonRoad.rWidth[barrel_inner][i_layer] = R_WIDTH_INNER_NO_HIT;
259 for (int i_layer=0; i_layer<N_LAYER; i_layer++) muonRoad.rWidth[csc][i_layer] = R_WIDTH_INNER_NO_HIT;
260
261 }
262
263 muonRoad.bw[endcap_inner][0] = 0.;
264 muonRoad.bw[barrel_inner][0] = 0.;
265 muonRoad.bw[csc][0] = 0.;
266
267 } else {
268 // If no TGC hit are available, estimate the road from RoI
269 // or if inside-out mode, width is tuned based on FTF track extrapolation resolution
270 ATH_MSG_DEBUG("Because no TGC hits are available, estimate the road from RoI");
271
272 roiEta = p_roids->eta();
273 theta = std::atan(std::exp(-std::abs(roiEta)))*2.;
274 aw = (std::abs(roiEta) > ZERO_LIMIT)? std::tan(theta)*(std::abs(roiEta)/roiEta): 0.;
275
276 muonRoad.aw[endcap_inner][0] = aw;
277 muonRoad.bw[endcap_inner][0] = 0;
278 muonRoad.aw[endcap_middle][0] = aw;
279 muonRoad.bw[endcap_middle][0] = 0;
280 muonRoad.aw[endcap_outer][0] = aw;
281 muonRoad.bw[endcap_outer][0] = 0;
282 muonRoad.aw[endcap_extra][0] = aw;
283 muonRoad.bw[endcap_extra][0] = 0;
284 muonRoad.aw[barrel_inner][0] = aw;
285 muonRoad.bw[barrel_inner][0] = 0;
286 muonRoad.aw[bee][0] = aw;
287 muonRoad.bw[bee][0] = 0;
288 muonRoad.aw[csc][0] = aw;
289 muonRoad.bw[csc][0] = 0;
290 for (int i_layer=0; i_layer<N_LAYER; i_layer++) {
291 if(insideOut) {
292 muonRoad.rWidth[endcap_inner][i_layer] = 300;
293 muonRoad.rWidth[endcap_middle][i_layer] = 400;
294 muonRoad.rWidth[endcap_outer][i_layer] = 600;
295 muonRoad.rWidth[endcap_extra][i_layer] = 400;
296 muonRoad.rWidth[barrel_inner][i_layer] = 250;
297 muonRoad.rWidth[bee][i_layer] = 500;
298 muonRoad.rWidth[csc][i_layer] = 200;
299 } else {
300 muonRoad.rWidth[endcap_inner][i_layer] = m_rWidth_TGC_Failed;
301 muonRoad.rWidth[endcap_middle][i_layer] = m_rWidth_TGC_Failed;
302 muonRoad.rWidth[endcap_outer][i_layer] = m_rWidth_TGC_Failed;
303 muonRoad.rWidth[endcap_extra][i_layer] = m_rWidth_TGC_Failed;
304 muonRoad.rWidth[barrel_inner][i_layer] = m_rWidth_TGC_Failed;
305 muonRoad.rWidth[bee][i_layer] = m_rWidth_TGC_Failed;
306 muonRoad.rWidth[csc][i_layer] = m_rWidth_TGC_Failed;
307 }
308 }
309 }
310
311 for(int i=0; i<N_STATION; i++) {
312 muonRoad.aw[i][1] = muonRoad.aw[i][0];
313 muonRoad.bw[i][1] = muonRoad.bw[i][0];
314 }
315
316 //
317 side = 0;
318 float phiMiddle = 0;
319 if( ! isMiddleFailure ) {
320 side = (tgcFitResult.tgcMid1[3]<0.)? 0 : 1;
321 phiMiddle = tgcFitResult.tgcMid1[1];
322 } else {
323 side = (p_roids->eta()<0.)? 0 : 1;
324 phiMiddle = p_roids->phi();
325 }
326 muonRoad.side = side;
327 muonRoad.phiMiddle = phiMiddle;
328 muonRoad.phiRoI = p_roids->phi();
329
330 int sector_trigger = 99;
331 int sector_overlap = 99;
332 int temp_sector=99;
333 float deltaPhi=99;
334 float tempDeltaPhi=99;
335 std::vector<Identifier> stationList;
336 std::vector<IdentifierHash> mdtHashList;
337
338 // get sector_trigger and sector_overlap by using the region selector
339 IdContext context = m_idHelperSvc->mdtIdHelper().module_context();
340
341 double etaMin = p_roids->eta()-.02;
342 double etaMax = p_roids->eta()+.02;
343 double phiMin = muonRoad.phiMiddle-.01;
344 double phiMax = muonRoad.phiMiddle+.01;
345 if(phiMax > M_PI) phiMax -= M_PI*2.;
346 if(phiMin < M_PI*-1) phiMin += M_PI*2.;
347 TrigRoiDescriptor* roi = new TrigRoiDescriptor( p_roids->eta(), etaMin, etaMax, p_roids->phi(), phiMin, phiMax );
348 const IRoiDescriptor* iroi = static_cast<IRoiDescriptor*> (roi);
349 if (iroi) m_regionSelector->lookup(ctx)->HashIDList(*iroi, mdtHashList);
350 else {
351 TrigRoiDescriptor fullscan_roi( true );
352 m_regionSelector->lookup(ctx)->HashIDList(fullscan_roi, mdtHashList);
353 }
354 if(roi) delete roi;
355
356 for(const IdentifierHash& i_hash : mdtHashList ){
357 Identifier id;
358 int convert = m_idHelperSvc->mdtIdHelper().get_id(i_hash, id, &context);
359
360 if(convert!=0) ATH_MSG_ERROR("problem converting hash list to id");
361
362 muonRoad.stationList.push_back(id);
363 std::string name = m_idHelperSvc->mdtIdHelper().stationNameString(m_idHelperSvc->mdtIdHelper().stationName(id));
364 if ( name.substr(0, 1) == "B" ) continue;
365 if ( name.substr(1, 1) != "M" ) continue;
366 int stationPhi = m_idHelperSvc->mdtIdHelper().stationPhi(id);
367 float floatPhi = (stationPhi-1)*M_PI/4;
368 if (name[2]=='S' || name[2]=='E') floatPhi = floatPhi + M_PI/8;
369 tempDeltaPhi = std::abs(floatPhi-muonRoad.phiMiddle);
370 if (phiMiddle<0) tempDeltaPhi = std::abs(floatPhi-muonRoad.phiMiddle-2*M_PI);
371 if(tempDeltaPhi > M_PI) tempDeltaPhi = std::abs(tempDeltaPhi - 2*M_PI);
372
373 int LargeSmall = 0;
374 if(name[2]=='S' || name[2]=='E') LargeSmall = 1;
375 int sector = (stationPhi-1)*2 + LargeSmall;
376 if(sector_trigger == 99)
377 sector_trigger = sector;
378 else if(sector_trigger != sector)
379 sector_overlap = sector;
380
381 if(tempDeltaPhi < deltaPhi){
382 deltaPhi = tempDeltaPhi;
383 temp_sector = sector;
384 muonRoad.LargeSmall=LargeSmall;
385 }
386
387 }
388 if(temp_sector != sector_trigger){
389 sector_overlap = sector_trigger;
390 sector_trigger = temp_sector;
391 }
392
393 muonRoad.MDT_sector_trigger = sector_trigger;
394 muonRoad.MDT_sector_overlap = sector_overlap;
395
396 if (insideOut) {
397 muonRoad.side = (muonRoad.extFtfMiddleEta<0.)? 0 : 1;
398 muonRoad.phiMiddle = muonRoad.extFtfMiddlePhi;
399 muonRoad.phiRoI = p_roids->phi();
400 for (int i_sector=0; i_sector<N_SECTOR; i_sector++) {
401 ATH_MSG_DEBUG("Use aw_ftf and bw_ftf as aw and bw");
402 muonRoad.aw[endcap_inner][i_sector] = muonRoad.aw_ftf[3][0];
403 muonRoad.bw[endcap_inner][i_sector] = muonRoad.bw_ftf[3][0];
404 muonRoad.aw[endcap_middle][i_sector] = muonRoad.aw_ftf[4][0];
405 muonRoad.bw[endcap_middle][i_sector] = muonRoad.bw_ftf[4][0];
406 muonRoad.aw[endcap_outer][i_sector] = muonRoad.aw_ftf[5][0];
407 muonRoad.bw[endcap_outer][i_sector] = muonRoad.bw_ftf[5][0];
408 muonRoad.aw[endcap_extra][i_sector] = muonRoad.aw_ftf[6][0];
409 muonRoad.bw[endcap_extra][i_sector] = muonRoad.bw_ftf[6][0];
410 muonRoad.aw[csc][i_sector] = muonRoad.aw_ftf[7][0];
411 muonRoad.bw[csc][i_sector] = muonRoad.bw_ftf[7][0];
412 muonRoad.aw[bee][i_sector] = muonRoad.aw_ftf[8][0];
413 muonRoad.bw[bee][i_sector] = muonRoad.bw_ftf[8][0];
414 muonRoad.aw[barrel_inner][i_sector] = muonRoad.aw_ftf[0][0];
415 muonRoad.bw[barrel_inner][i_sector] = muonRoad.bw_ftf[0][0];
416 }
417 }
418
419 //
420 return StatusCode::SUCCESS;
421}
422
423// --------------------------------------------------------------------------------
424// --------------------------------------------------------------------------------
425
426bool TrigL2MuonSA::TgcRoadDefiner::prepareTgcPoints(const TrigL2MuonSA::TgcHits& tgcHits,
427 TrigL2MuonSA::TgcFit::PointArray& tgcStripInnPoints,
428 TrigL2MuonSA::TgcFit::PointArray& tgcWireInnPoints,
429 TrigL2MuonSA::TgcFit::PointArray& tgcStripMidPoints,
430 TrigL2MuonSA::TgcFit::PointArray& tgcWireMidPoints) const
431{
432 const double PHI_BOUNDARY = 0.2;
433
434 tgcStripMidPoints.clear();
435 tgcStripInnPoints.clear();
436 tgcWireMidPoints.clear();
437 tgcWireInnPoints.clear();
438
439 // loop over TGC digits.
440 unsigned int iHit;
441 for (iHit = 0; iHit < tgcHits.size(); iHit++)
442 {
443 // Get the digit point.
444 const TrigL2MuonSA::TgcHitData& hit = tgcHits[iHit];
445
446 // reject width=0 hits
447 const double ZERO_LIMIT = 1e-5;
448 if( std::abs(hit.width) < ZERO_LIMIT ) continue;
449
450 double w = 12.0 / hit.width / hit.width;
451 if (hit.isStrip)
452 {
453 w *= hit.r * hit.r;
454 double phi = hit.phi;
455 if( phi < 0 && ( (M_PI+phi)<PHI_BOUNDARY) ) phi += M_PI*2;
456 if ( hit.sta < 3 ) { tgcStripMidPoints.push_back(TgcFit::Point(iHit + 1, hit.sta, hit.z, phi, w)); }
457 else if ( hit.sta ==3 ) { tgcStripInnPoints.push_back(TgcFit::Point(iHit + 1, hit.sta, hit.z, phi, w)); }
458 }
459 else
460 {
461 if ( hit.sta < 3 ) { tgcWireMidPoints.push_back(TgcFit::Point(iHit + 1, hit.sta, hit.z, hit.r, w)); }
462 else if ( hit.sta ==3 ) { tgcWireInnPoints.push_back(TgcFit::Point(iHit + 1, hit.sta, hit.z, hit.r, w)); }
463 }
464 }
465
466 ATH_MSG_DEBUG(", tgcStripMidPoints.size()=" << tgcStripMidPoints.size() <<
467 ", tgcStripInnPoints.size()=" << tgcStripInnPoints.size() <<
468 ", tgcWireMidPoints.size()=" << tgcWireMidPoints.size() <<
469 ", tgcWireInnPoints.size()=" << tgcWireInnPoints.size());
470
471 return true;
472}
M_PI
#define M_PI
Definition ActiveFraction.h:14
eta
Scalar eta() const
pseudorapidity method
Definition AmgMatrixBasePlugin.h:83
deltaPhi
Scalar deltaPhi(const MatrixBase< Derived > &vec) const
Definition AmgMatrixBasePlugin.h:112
phi
Scalar phi() const
phi method
Definition AmgMatrixBasePlugin.h:67
theta
Scalar theta() const
theta method
Definition AmgMatrixBasePlugin.h:75
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x,...)
Definition AthMsgStreamMacros.h:43
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x,...)
Definition AthMsgStreamMacros.h:47
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x,...)
Definition AthMsgStreamMacros.h:46
charge
double charge(const T &p)
Definition AtlasPID.h:1003
hit
bool hit(const Container &ids, int pdgId)
Definition JetIRCSafeLabelTool.cxx:64
sc
static Double_t sc
Definition LArPhysWaveHECTool.cxx:37
ZERO_LIMIT
static const double ZERO_LIMIT
Definition MuonMatchingTool.cxx:26
TrigRoiDescriptor
Athena::TPCnvVers::Current TrigRoiDescriptor
Definition TrigSteeringEventTPCnv.cxx:68
AthAlgTool::AthAlgTool
AthAlgTool(const std::string &type, const std::string &name, const IInterface *parent)
Constructor with parameters:
Definition AthAlgTool.cxx:16
IRoiDescriptor
Describes the API of the Region of Ineterest geometry.
Definition IRoiDescriptor.h:23
IdContext
This class saves the "context" of an expanded identifier (ExpandedIdentifier) for compact or hash ver...
Definition IdContext.h:26
IdentifierHash
This is a "hash" representation of an Identifier.
Definition IdentifierHash.h:25
RoiDescriptor::phi
virtual double phi() const override final
Methods to retrieve data members.
Definition RoiDescriptor.h:101
RoiDescriptor::eta
virtual double eta() const override final
Definition RoiDescriptor.h:102
TrigL2MuonSA::MuonRoad::stationList
std::vector< Identifier > stationList
Definition MuonRoad.h:102
TrigL2MuonSA::MuonRoad::aw
double aw[N_STATION][N_SECTOR]
Definition MuonRoad.h:83
TrigL2MuonSA::MuonRoad::bw_ftf
double bw_ftf[N_STATION][N_SECTOR]
Definition MuonRoad.h:95
TrigL2MuonSA::MuonRoad::aw_ftf
double aw_ftf[N_STATION][N_SECTOR]
Definition MuonRoad.h:94
TrigL2MuonSA::MuonRoad::bw
double bw[N_STATION][N_SECTOR]
Definition MuonRoad.h:84
TrigL2MuonSA::MuonRoad::rWidth
double rWidth[N_STATION][N_LAYER]
Definition MuonRoad.h:86
TrigL2MuonSA::TgcFit::PointArray
std::vector< Point > PointArray
Definition TgcFit.h:86
TrigL2MuonSA::TgcRoadDefiner::m_backExtrapolatorTool
const ToolHandle< ITrigMuonBackExtrapolator > * m_backExtrapolatorTool
Definition TgcRoadDefiner.h:55
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:426
TrigL2MuonSA::TgcRoadDefiner::m_tgcFit
ToolHandle< TgcFit > m_tgcFit
Definition TgcRoadDefiner.h:59
TrigL2MuonSA::TgcRoadDefiner::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition TgcRoadDefiner.h:64
TrigL2MuonSA::TgcRoadDefiner::TgcRoadDefiner
TgcRoadDefiner(const std::string &type, const std::string &name, const IInterface *parent)
Definition TgcRoadDefiner.cxx:17
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
TrigL2MuonSA::TgcRoadDefiner::m_regionSelector
ToolHandle< IRegSelTool > m_regionSelector
Definition TgcRoadDefiner.h:63
TrigL2MuonSA::TgcRoadDefiner::initialize
virtual StatusCode initialize() override
Definition TgcRoadDefiner.cxx:27
TrigRoiDescriptor
nope - should be used for standalone also, perhaps need to protect the class def bits ifndef XAOD_ANA...
Definition TrigRoiDescriptor.h:48
xAOD::L2StandAloneMuon_v2::setEtaMS
void setEtaMS(float value)
Set the eta at muon spectrometer.
xAOD::L2StandAloneMuon_v2::setRMS
void setRMS(float value)
Set the R at muon spectrometer.
xAOD::L2StandAloneMuon_v2::setSAddress
void setSAddress(int value)
Set the station address of the muon.
xAOD::L2StandAloneMuon_v2::setPhiMS
void setPhiMS(float value)
Set the phi at muon spectrometer.
xAOD::L2StandAloneMuon_v2::setPt
void setPt(float pt)
Set the transverse momentum ( ) of the muon.
xAOD::L2StandAloneMuon_v2::setZMS
void setZMS(float value)
Set the Z at muon spectrometer.
TrigL2MuonSA::N_STATION
constexpr int N_STATION
Definition MuonRoad.h:15
TrigL2MuonSA::TgcHits
std::vector< TgcHitData > TgcHits
Definition TgcData.h:43
TrigL2MuonSA::N_LAYER
constexpr int N_LAYER
Definition MuonRoad.h:17
TrigL2MuonSA::N_SECTOR
constexpr int N_SECTOR
Definition MuonRoad.h:16
xAOD::L2MuonParameters::BarrelInner
@ BarrelInner
Inner station in the barrel spectrometer.
Definition TrigMuonDefs.h:16
xAOD::L2MuonParameters::EndcapOuter
@ EndcapOuter
Outer station in the endcap spectrometer.
Definition TrigMuonDefs.h:21
xAOD::L2MuonParameters::CSC
@ CSC
CSC measurement point.
Definition TrigMuonDefs.h:23
xAOD::L2MuonParameters::EndcapMiddle
@ EndcapMiddle
Middle station in the endcap spectrometer.
Definition TrigMuonDefs.h:20
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
xAOD::L2MuonParameters::EndcapInner
@ EndcapInner
Inner station in the endcap spectrometer.
Definition TrigMuonDefs.h:19
xAOD::L2StandAloneMuon
L2StandAloneMuon_v2 L2StandAloneMuon
Define the latest version of the muon SA class.
Definition L2StandAloneMuon.h:17
type
Generated on for ATLAS Offline Software by doxygen 1.17.0