ATLAS Offline Software
RpcRoadDefiner.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 <cmath>
6 
7 #include "RpcRoadDefiner.h"
8 #include "TrigSteeringEvent/TrigRoiDescriptor.h"
9 #include "AthenaBaseComps/AthMsgStreamMacros.h"
10 
11 // --------------------------------------------------------------------------------
12 // --------------------------------------------------------------------------------
13 
14 TrigL2MuonSA::RpcRoadDefiner::RpcRoadDefiner(const std::string& type,
15  const std::string& name,
16  const IInterface* parent):
17  AthAlgTool(type, name, parent)
18 {
19 }
20 
21 // --------------------------------------------------------------------------------
22 // --------------------------------------------------------------------------------
23 
24 StatusCode TrigL2MuonSA::RpcRoadDefiner::initialize()
25 {
26  ATH_CHECK(m_idHelperSvc.retrieve());
27 
28  ATH_CHECK(m_regionSelector.retrieve());
29  ATH_MSG_DEBUG("Retrieved the RegionSelector tool ");
30 
31  return StatusCode::SUCCESS;
32 }
33 
34 // --------------------------------------------------------------------------------
35 // --------------------------------------------------------------------------------
36 
37 StatusCode TrigL2MuonSA::RpcRoadDefiner::defineRoad(const LVL1::RecMuonRoI* p_roi,
38  const bool insideOut,
39  TrigL2MuonSA::MuonRoad& muonRoad,
40  TrigL2MuonSA::RpcHits& /*rpcHits*/,
41  const TrigL2MuonSA::RpcLayerHits& rpcLayerHits,
42  const ToolHandle<RpcPatFinder>* rpcPatFinder,
43  TrigL2MuonSA::RpcFitResult& rpcFitResult,
44  double roiEtaMinLow,
45  double roiEtaMaxLow,
46  double roiEtaMinHigh,
47  double roiEtaMaxHigh) const
48 {
49 
50  const double ZERO_LIMIT = 1e-5;
51 
52  const int N_LAYER = 5; // 0: inner, 1: middle, 2: outer 4: BME 5: BMG
53  const int N_SECTOR = 2; // 0: normal, 1:overlap
54 
55  if (m_use_rpc && !insideOut) {
56  double aw[3]={0.,0.,0.};
57  double bw[3]={0.,0.,0.};
58  unsigned int rpc_pattern;
59  if ( (*rpcPatFinder)->findPatternEta(aw, bw, rpc_pattern, rpcLayerHits) ) {
60  rpcFitResult.isSuccess = true;
61  rpcFitResult.offset_inner = bw[0];
62  rpcFitResult.offset_middle = bw[1];
63  rpcFitResult.offset_outer = bw[2];
64  rpcFitResult.slope_inner = 1.0/aw[0];
65  rpcFitResult.slope_middle = 1.0/aw[1];
66  rpcFitResult.slope_outer = 1.0/aw[2];
67 
68  for(int i=0;i<3;i++){
69  if(std::abs(1.0/aw[i]) <= ZERO_LIMIT) rpcFitResult.isSuccess = false;
70  }
71  } else {
72  rpcFitResult.isSuccess = false;
73  }
74 
75  double phi_middle;
76  double phi_outer;
77  unsigned int phi_pattern;
78  if ( (*rpcPatFinder)->findPatternPhi(phi_middle, phi_outer, phi_pattern, rpcLayerHits)) {
79  rpcFitResult.phi = phi_middle;
80  rpcFitResult.phi_middle = phi_middle;
81  rpcFitResult.phi_outer = phi_outer;
82  } else {
83  rpcFitResult.phi = p_roi->phi();
84  }
85  } else {
86  ATH_MSG_DEBUG("Skip rpcPatFinder");
87  }
88 
89  // RPC data is not available -> use RoI
90 
91  muonRoad.isEndcap = false;
92  if(!insideOut) {
93  muonRoad.phiMiddle = rpcFitResult.phi;
94  } else {
95  muonRoad.phiMiddle = muonRoad.extFtfMiddlePhi;
96  rpcFitResult.phi = muonRoad.extFtfMiddlePhi;
97  rpcFitResult.phi_middle = muonRoad.extFtfMiddlePhi;
98  rpcFitResult.phi_outer = muonRoad.extFtfMiddlePhi;
99  }
100  muonRoad.phiRoI = p_roi->phi();
101  muonRoad.side = (p_roi->phi()<0.)? 0 : 1;
102  muonRoad.LargeSmall = ((p_roi->sectorID() + 1)/2 )%2;
103 
104  const int PhysicsSector = ((p_roi->sectorID() + 1)/4 )%8 + 1;
105 
106  int special = 0;
107  if (muonRoad.LargeSmall == 0 && (PhysicsSector == 6 || PhysicsSector == 8 ))
108  special = 1;
109  if (muonRoad.LargeSmall == 1 && (PhysicsSector == 6 || PhysicsSector == 7 ))
110  special = 1;
111  muonRoad.Special = special;
112 
113  for (int i_station=0; i_station<6; i_station++) {
114  for (int i_layer=0; i_layer<8; i_layer++) {
115  if(!rpcFitResult.isSuccess) {
116  if (!insideOut){
117  if (i_station==0) muonRoad.rWidth[i_station][i_layer] = 500;//for inner
118  else if (i_station==1) muonRoad.rWidth[i_station][i_layer] = 650;//for middle
119  else if (i_station==2) muonRoad.rWidth[i_station][i_layer] = 800;//for outer
120  else if (i_station==3) muonRoad.rWidth[i_station][i_layer] = 500;//EndcapInner
121  else if (i_station==4) muonRoad.rWidth[9][i_layer] = 650;//BME
122  else if (i_station==5) muonRoad.rWidth[10][i_layer] = 650;//BMG
123  else muonRoad.rWidth[i_station][i_layer] = m_rWidth_RPC_Failed;
124  } else {
125  if (i_station==0) muonRoad.rWidth[i_station][i_layer] = 250;//for inner
126  else if (i_station==1) muonRoad.rWidth[i_station][i_layer] = 400;//for middle
127  else if (i_station==2) muonRoad.rWidth[i_station][i_layer] = 600;//for outer
128  else if (i_station==3) muonRoad.rWidth[i_station][i_layer] = 300;//EndcapInner
129  else if (i_station==4) muonRoad.rWidth[9][i_layer] = 400;//BME
130  else if (i_station==5) muonRoad.rWidth[10][i_layer] = 400;//BMG
131  else muonRoad.rWidth[i_station][i_layer] = 400;
132  }
133  }
134  else {
135  if (i_station==0) muonRoad.rWidth[i_station][i_layer] = 400;//for inner
136  else if (i_station==1) muonRoad.rWidth[i_station][i_layer] = 200;//for middle
137  else if (i_station==2) muonRoad.rWidth[i_station][i_layer] = 400;//for outer
138  else if (i_station==3) muonRoad.rWidth[i_station][i_layer] = 400;//EndcapInner
139  else if (i_station==4) muonRoad.rWidth[9][i_layer] = m_rWidth_RPC_Failed;//BME
140  else if (i_station==5) muonRoad.rWidth[10][i_layer] = m_rWidth_RPC_Failed;//BMG
141  else muonRoad.rWidth[i_station][i_layer] = m_rWidth_RPC_Failed;
142  }
143  }
144  }
145 
146  int sector_trigger = 99;
147  int sector_overlap = 99;
148  std::vector<Identifier> stationList;
149  std::vector<IdentifierHash> mdtHashList;
150 
151  // get sector_trigger and sector_overlap by using the region selector
152  IdContext context = m_idHelperSvc->mdtIdHelper().module_context();
153 
154  double etaMin = p_roi->eta()-.02;
155  double etaMax = p_roi->eta()+.02;
156  double phiMin = muonRoad.phiMiddle-.01;
157  double phiMax = muonRoad.phiMiddle+.01;
158  if(phiMax > M_PI) phiMax -= M_PI*2.;
159  if(phiMin < M_PI*-1) phiMin += M_PI*2.;
160 
161  TrigRoiDescriptor* roi = new TrigRoiDescriptor( p_roi->eta(), etaMin, etaMax, p_roi->phi(), phiMin, phiMax );
162 
163  const IRoiDescriptor* iroi = (IRoiDescriptor*) roi;
164 
165  if (iroi) m_regionSelector->HashIDList(*iroi, mdtHashList);
166  else {
167  TrigRoiDescriptor fullscan_roi( true );
168  m_regionSelector->HashIDList(fullscan_roi, mdtHashList);
169  }
170 
171  if(roi) delete roi;
172 
173  for( const IdentifierHash& hash : mdtHashList){
174 
175  Identifier id;
176  const int convert = m_idHelperSvc->mdtIdHelper().get_id(hash, id, &context);
177 
178  if(convert!=0) ATH_MSG_ERROR("problem converting hash list to id");
179 
180  muonRoad.stationList.push_back(id);
181  const int stationPhi = m_idHelperSvc->mdtIdHelper().stationPhi(id);
182  std::string name = m_idHelperSvc->mdtIdHelper().stationNameString(m_idHelperSvc->mdtIdHelper().stationName(id));
183 
184  if ( name[1]=='M' && name[2]=='E' ) continue;//exclude BME
185  if ( name[1]=='M' && name[2]=='G' ) continue;//exclude BMG
186 
187  int LargeSmall = 0;
188  if(name[2]=='S' || name[2]=='F' || name[2]=='G' ) LargeSmall = 1;
189  const int sector = (stationPhi-1)*2 + LargeSmall;
190  if(sector_trigger == 99)
191  sector_trigger = sector;
192  else if(sector_trigger != sector)
193  sector_overlap = sector;
194  }
195 
196  const int MDT_tr = (PhysicsSector - 1)*2 + muonRoad.LargeSmall;
197  if (MDT_tr == sector_overlap) {
198  sector_overlap = sector_trigger;
199  sector_trigger = MDT_tr;
200  }
201 
202  muonRoad.MDT_sector_trigger = sector_trigger;
203  muonRoad.MDT_sector_overlap = sector_overlap;
204 
205  if (rpcFitResult.isSuccess) {
206  for (int i_sector=0; i_sector<N_SECTOR; i_sector++) {
207  muonRoad.aw[0][i_sector] = rpcFitResult.slope_inner;
208  muonRoad.bw[0][i_sector] = rpcFitResult.offset_inner;
209  muonRoad.aw[1][i_sector] = rpcFitResult.slope_middle;
210  muonRoad.bw[1][i_sector] = rpcFitResult.offset_middle;
211  muonRoad.aw[2][i_sector] = rpcFitResult.slope_outer;
212  muonRoad.bw[2][i_sector] = rpcFitResult.offset_outer;
213  muonRoad.aw[3][i_sector] = rpcFitResult.slope_inner; // Endcap Inner
214  muonRoad.bw[3][i_sector] = rpcFitResult.offset_inner;
215  muonRoad.aw[9][i_sector] = rpcFitResult.slope_middle;//BME
216  muonRoad.bw[9][i_sector] = rpcFitResult.offset_middle;
217  muonRoad.aw[10][i_sector] = rpcFitResult.slope_middle;//BMG
218  muonRoad.bw[10][i_sector] = rpcFitResult.offset_middle;
219  }
220 
221  } else {
222  const double roiEtaLow = (roiEtaMinLow + roiEtaMaxLow) * 0.5;
223  const double roiEtaHigh = (roiEtaMinHigh + roiEtaMaxHigh) * 0.5;
224  const double thetaLow = std::atan(std::exp(-std::abs(roiEtaLow)))*2.;
225  const double thetaHigh = std::atan(std::exp(-std::abs(roiEtaHigh)))*2.;
226  const double awLow = (std::abs(roiEtaLow) > ZERO_LIMIT)? std::tan(thetaLow)*(std::abs(roiEtaLow)/roiEtaLow): 0.;
227  const double awHigh = (std::abs(roiEtaHigh) > ZERO_LIMIT)? std::tan(thetaHigh)*(std::abs(roiEtaHigh)/roiEtaHigh): 0.;
228 
229  for (int i_station=0; i_station<N_LAYER; i_station++) {
230  for (int i_sector=0; i_sector<N_SECTOR; i_sector++) {
231  muonRoad.aw[i_station][i_sector] = awLow;
232  muonRoad.bw[i_station][i_sector] = 0;
233  if (i_station==2) muonRoad.aw[i_station][i_sector] = awHigh;
234  if (i_station==3) muonRoad.aw[i_station][i_sector] = awLow; //EI
235  if (i_station==4) muonRoad.aw[9][i_sector] = awLow; //BME
236  if (i_station==5) muonRoad.aw[10][i_sector] = awLow; //BMG
237  }
238  }
239  }
240 
241  if (insideOut) {
242  for (int i_sector=0; i_sector<N_SECTOR; i_sector++) {
243  ATH_MSG_DEBUG("Use aw_ftf and bw_ftf as aw and bw");
244  muonRoad.aw[0][i_sector] = muonRoad.aw_ftf[0][0];
245  muonRoad.bw[0][i_sector] = muonRoad.bw_ftf[0][0];
246  muonRoad.aw[1][i_sector] = muonRoad.aw_ftf[1][0];
247  muonRoad.bw[1][i_sector] = muonRoad.bw_ftf[1][0];
248  muonRoad.aw[2][i_sector] = muonRoad.aw_ftf[2][0];
249  muonRoad.bw[2][i_sector] = muonRoad.bw_ftf[2][0];
250  muonRoad.aw[3][i_sector] = muonRoad.aw_ftf[3][0]; // Endcap Inner
251  muonRoad.bw[3][i_sector] = muonRoad.bw_ftf[3][0];
252  muonRoad.aw[9][i_sector] = muonRoad.aw_ftf[9][0];//BME
253  muonRoad.bw[9][i_sector] = muonRoad.bw_ftf[9][0];
254  muonRoad.aw[10][i_sector] = muonRoad.aw_ftf[10][0];//BMG
255  muonRoad.bw[10][i_sector] = muonRoad.bw_ftf[10][0];
256  }
257  }
258  ATH_MSG_DEBUG("muonRoad.phiMiddle: " << muonRoad.phiMiddle);
259 
260  return StatusCode::SUCCESS;
261 }
262 
263 // --------------------------------------------------------------------------------
264 // --------------------------------------------------------------------------------
265 
266 StatusCode TrigL2MuonSA::RpcRoadDefiner::defineRoad(const xAOD::MuonRoI* p_roi,
267  const bool insideOut,
268  TrigL2MuonSA::MuonRoad& muonRoad,
269  TrigL2MuonSA::RpcHits& /*rpcHits*/,
270  const TrigL2MuonSA::RpcLayerHits& rpcLayerHits,
271  const ToolHandle<RpcPatFinder>* rpcPatFinder,
272  TrigL2MuonSA::RpcFitResult& rpcFitResult,
273  double roiEtaMinLow,
274  double roiEtaMaxLow,
275  double roiEtaMinHigh,
276  double roiEtaMaxHigh) const
277 {
278 
279  const double ZERO_LIMIT = 1e-5;
280 
281  const int N_LAYER = 5; // 0: inner, 1: middle, 2: outer 4: BME 5: BMG
282  const int N_SECTOR = 2; // 0: normal, 1:overlap
283 
284  if (m_use_rpc && !insideOut) {
285  double aw[3]={0.,0.,0.};
286  double bw[3]={0.,0.,0.};
287  unsigned int rpc_pattern;
288  if ( (*rpcPatFinder)->findPatternEta(aw, bw, rpc_pattern, rpcLayerHits) ) {
289  rpcFitResult.isSuccess = true;
290  rpcFitResult.offset_inner = bw[0];
291  rpcFitResult.offset_middle = bw[1];
292  rpcFitResult.offset_outer = bw[2];
293  rpcFitResult.slope_inner = 1.0/aw[0];
294  rpcFitResult.slope_middle = 1.0/aw[1];
295  rpcFitResult.slope_outer = 1.0/aw[2];
296 
297  for(int i=0;i<3;i++){
298  if(std::abs(1.0/aw[i]) <= ZERO_LIMIT) rpcFitResult.isSuccess = false;
299  }
300  } else {
301  rpcFitResult.isSuccess = false;
302  }
303 
304  double phi_middle;
305  double phi_outer;
306  unsigned int phi_pattern;
307  if ( (*rpcPatFinder)->findPatternPhi(phi_middle, phi_outer, phi_pattern, rpcLayerHits)) {
308  rpcFitResult.phi = phi_middle;
309  rpcFitResult.phi_middle = phi_middle;
310  rpcFitResult.phi_outer = phi_outer;
311  } else {
312  rpcFitResult.phi = p_roi->phi();
313  }
314  } else {
315  ATH_MSG_DEBUG("Skip rpcPatFinder");
316  }
317 
318  // RPC data is not available -> use RoI
319 
320  muonRoad.isEndcap = false;
321  if(!insideOut) {
322  muonRoad.phiMiddle = rpcFitResult.phi;
323  } else {
324  muonRoad.phiMiddle = muonRoad.extFtfMiddlePhi;
325  rpcFitResult.phi = muonRoad.extFtfMiddlePhi;
326  rpcFitResult.phi_middle = muonRoad.extFtfMiddlePhi;
327  rpcFitResult.phi_outer = muonRoad.extFtfMiddlePhi;
328  }
329  muonRoad.phiRoI = p_roi->phi();
330  muonRoad.side = (p_roi->phi()<0.)? 0 : 1;
331  muonRoad.LargeSmall = ((p_roi->getSectorID() + 1)/2 )%2;
332 
333  const int PhysicsSector = ((p_roi->getSectorID() + 1)/4 )%8 + 1;
334 
335  int special = 0;
336  if (muonRoad.LargeSmall == 0 && (PhysicsSector == 6 || PhysicsSector == 8 ))
337  special = 1;
338  if (muonRoad.LargeSmall == 1 && (PhysicsSector == 6 || PhysicsSector == 7 ))
339  special = 1;
340  muonRoad.Special = special;
341 
342  for (int i_station=0; i_station<6; i_station++) {
343  for (int i_layer=0; i_layer<8; i_layer++) {
344  if(!rpcFitResult.isSuccess) {
345  if (!insideOut){
346  if (i_station==0) muonRoad.rWidth[i_station][i_layer] = 500;//for inner
347  else if (i_station==1) muonRoad.rWidth[i_station][i_layer] = 650;//for middle
348  else if (i_station==2) muonRoad.rWidth[i_station][i_layer] = 800;//for outer
349  else if (i_station==3) muonRoad.rWidth[i_station][i_layer] = 500;//EndcapInner
350  else if (i_station==4) muonRoad.rWidth[9][i_layer] = 650;//BME
351  else if (i_station==5) muonRoad.rWidth[10][i_layer] = 650;//BMG
352  else muonRoad.rWidth[i_station][i_layer] = m_rWidth_RPC_Failed;
353  } else {
354  if (i_station==0) muonRoad.rWidth[i_station][i_layer] = 250;//for inner
355  else if (i_station==1) muonRoad.rWidth[i_station][i_layer] = 400;//for middle
356  else if (i_station==2) muonRoad.rWidth[i_station][i_layer] = 600;//for outer
357  else if (i_station==3) muonRoad.rWidth[i_station][i_layer] = 300;//EndcapInner
358  else if (i_station==4) muonRoad.rWidth[9][i_layer] = 400;//BME
359  else if (i_station==5) muonRoad.rWidth[10][i_layer] = 400;//BMG
360  else muonRoad.rWidth[i_station][i_layer] = 400;
361  }
362  }
363  else {
364  if (i_station==0) muonRoad.rWidth[i_station][i_layer] = 400;//for inner
365  else if (i_station==1) muonRoad.rWidth[i_station][i_layer] = 200;//for middle
366  else if (i_station==2) muonRoad.rWidth[i_station][i_layer] = 400;//for outer
367  else if (i_station==3) muonRoad.rWidth[i_station][i_layer] = 400;//EndcapInner
368  else if (i_station==4) muonRoad.rWidth[9][i_layer] = m_rWidth_RPC_Failed;//BME
369  else if (i_station==5) muonRoad.rWidth[10][i_layer] = m_rWidth_RPC_Failed;//BMG
370  else muonRoad.rWidth[i_station][i_layer] = m_rWidth_RPC_Failed;
371  }
372  }
373  }
374 
375  int sector_trigger = 99;
376  int sector_overlap = 99;
377  std::vector<Identifier> stationList;
378  std::vector<IdentifierHash> mdtHashList;
379 
380  // get sector_trigger and sector_overlap by using the region selector
381  IdContext context = m_idHelperSvc->mdtIdHelper().module_context();
382 
383  double etaMin = p_roi->eta()-.02;
384  double etaMax = p_roi->eta()+.02;
385  double phiMin = muonRoad.phiMiddle-.01;
386  double phiMax = muonRoad.phiMiddle+.01;
387  if(phiMax > M_PI) phiMax -= M_PI*2.;
388  if(phiMin < M_PI*-1) phiMin += M_PI*2.;
389 
390  TrigRoiDescriptor* roi = new TrigRoiDescriptor( p_roi->eta(), etaMin, etaMax, p_roi->phi(), phiMin, phiMax );
391 
392  const IRoiDescriptor* iroi = (IRoiDescriptor*) roi;
393 
394  if (iroi) m_regionSelector->HashIDList(*iroi, mdtHashList);
395  else {
396  TrigRoiDescriptor fullscan_roi( true );
397  m_regionSelector->HashIDList(fullscan_roi, mdtHashList);
398  }
399 
400  if(roi) delete roi;
401 
402  for( const IdentifierHash& hash : mdtHashList){
403 
404  Identifier id;
405  const int convert = m_idHelperSvc->mdtIdHelper().get_id(hash, id, &context);
406 
407  if(convert!=0) ATH_MSG_ERROR("problem converting hash list to id");
408 
409  muonRoad.stationList.push_back(id);
410  const int stationPhi = m_idHelperSvc->mdtIdHelper().stationPhi(id);
411  std::string name = m_idHelperSvc->mdtIdHelper().stationNameString(m_idHelperSvc->mdtIdHelper().stationName(id));
412 
413  if ( name[1]=='M' && name[2]=='E' ) continue;//exclude BME
414  if ( name[1]=='M' && name[2]=='G' ) continue;//exclude BMG
415 
416  int LargeSmall = 0;
417  if(name[2]=='S' || name[2]=='F' || name[2]=='G' ) LargeSmall = 1;
418  const int sector = (stationPhi-1)*2 + LargeSmall;
419  if(sector_trigger == 99)
420  sector_trigger = sector;
421  else if(sector_trigger != sector)
422  sector_overlap = sector;
423  }
424 
425  const int MDT_tr = (PhysicsSector - 1)*2 + muonRoad.LargeSmall;
426  if (MDT_tr == sector_overlap) {
427  sector_overlap = sector_trigger;
428  sector_trigger = MDT_tr;
429  }
430 
431  muonRoad.MDT_sector_trigger = sector_trigger;
432  muonRoad.MDT_sector_overlap = sector_overlap;
433 
434  if (rpcFitResult.isSuccess) {
435  for (int i_sector=0; i_sector<N_SECTOR; i_sector++) {
436  muonRoad.aw[0][i_sector] = rpcFitResult.slope_inner;
437  muonRoad.bw[0][i_sector] = rpcFitResult.offset_inner;
438  muonRoad.aw[1][i_sector] = rpcFitResult.slope_middle;
439  muonRoad.bw[1][i_sector] = rpcFitResult.offset_middle;
440  muonRoad.aw[2][i_sector] = rpcFitResult.slope_outer;
441  muonRoad.bw[2][i_sector] = rpcFitResult.offset_outer;
442  muonRoad.aw[3][i_sector] = rpcFitResult.slope_inner; // Endcap Inner
443  muonRoad.bw[3][i_sector] = rpcFitResult.offset_inner;
444  muonRoad.aw[9][i_sector] = rpcFitResult.slope_middle;//BME
445  muonRoad.bw[9][i_sector] = rpcFitResult.offset_middle;
446  muonRoad.aw[10][i_sector] = rpcFitResult.slope_middle;//BMG
447  muonRoad.bw[10][i_sector] = rpcFitResult.offset_middle;
448  }
449 
450  } else {
451  const double roiEtaLow = (roiEtaMinLow + roiEtaMaxLow) * 0.5;
452  const double roiEtaHigh = (roiEtaMinHigh + roiEtaMaxHigh) * 0.5;
453  const double thetaLow = std::atan(std::exp(-std::abs(roiEtaLow)))*2.;
454  const double thetaHigh = std::atan(std::exp(-std::abs(roiEtaHigh)))*2.;
455  const double awLow = (std::abs(roiEtaLow) > ZERO_LIMIT)? std::tan(thetaLow)*(std::abs(roiEtaLow)/roiEtaLow): 0.;
456  const double awHigh = (std::abs(roiEtaHigh) > ZERO_LIMIT)? std::tan(thetaHigh)*(std::abs(roiEtaHigh)/roiEtaHigh): 0.;
457 
458  for (int i_station=0; i_station<N_LAYER; i_station++) {
459  for (int i_sector=0; i_sector<N_SECTOR; i_sector++) {
460  muonRoad.aw[i_station][i_sector] = awLow;
461  muonRoad.bw[i_station][i_sector] = 0;
462  if (i_station==2) muonRoad.aw[i_station][i_sector] = awHigh;
463  if (i_station==3) muonRoad.aw[i_station][i_sector] = awLow; //EI
464  if (i_station==4) muonRoad.aw[9][i_sector] = awLow; //BME
465  if (i_station==5) muonRoad.aw[10][i_sector] = awLow; //BMG
466  }
467  }
468  }
469 
470  if (insideOut) {
471  for (int i_sector=0; i_sector<N_SECTOR; i_sector++) {
472  ATH_MSG_DEBUG("Use aw_ftf and bw_ftf as aw and bw");
473  muonRoad.aw[0][i_sector] = muonRoad.aw_ftf[0][0];
474  muonRoad.bw[0][i_sector] = muonRoad.bw_ftf[0][0];
475  muonRoad.aw[1][i_sector] = muonRoad.aw_ftf[1][0];
476  muonRoad.bw[1][i_sector] = muonRoad.bw_ftf[1][0];
477  muonRoad.aw[2][i_sector] = muonRoad.aw_ftf[2][0];
478  muonRoad.bw[2][i_sector] = muonRoad.bw_ftf[2][0];
479  muonRoad.aw[3][i_sector] = muonRoad.aw_ftf[3][0]; // Endcap Inner
480  muonRoad.bw[3][i_sector] = muonRoad.bw_ftf[3][0];
481  muonRoad.aw[9][i_sector] = muonRoad.aw_ftf[9][0];//BME
482  muonRoad.bw[9][i_sector] = muonRoad.bw_ftf[9][0];
483  muonRoad.aw[10][i_sector] = muonRoad.aw_ftf[10][0];//BMG
484  muonRoad.bw[10][i_sector] = muonRoad.bw_ftf[10][0];
485  }
486  }
487  ATH_MSG_DEBUG("muonRoad.phiMiddle: " << muonRoad.phiMiddle);
488 
489  return StatusCode::SUCCESS;
490 }
491 
492 // --------------------------------------------------------------------------------
493 // --------------------------------------------------------------------------------
TrigL2MuonSA::MuonRoad::MDT_sector_overlap
int MDT_sector_overlap
Definition: MuonRoad.h:87
TrigL2MuonSA::N_SECTOR
constexpr int N_SECTOR
Definition: MuonRoad.h:16
TrigL2MuonSA::RpcRoadDefiner::defineRoad
StatusCode defineRoad(const LVL1::RecMuonRoI *p_roi, const bool insideOut, TrigL2MuonSA::MuonRoad &muonRoad, TrigL2MuonSA::RpcHits &rpcHits, const TrigL2MuonSA::RpcLayerHits &rpcLayerHits, const ToolHandle< RpcPatFinder > *rpcPatFinder, TrigL2MuonSA::RpcFitResult &rpcFitResult, double roiEtaMinLow, double roiEtaMaxLow, double roiEtaMinHigh, double roiEtaMaxHigh) const
Definition: RpcRoadDefiner.cxx:37
AthMsgStreamMacros.h
TrigL2MuonSA::RpcFitResult::phi
double phi
Definition: RpcFitResult.h:44
TrigL2MuonSA::RpcHits
std::vector< RpcHitData > RpcHits
Definition: RpcData.h:57
TrigL2MuonSA::MuonRoad::phiMiddle
double phiMiddle
Definition: MuonRoad.h:79
TrigL2MuonSA::N_LAYER
constexpr int N_LAYER
Definition: MuonRoad.h:17
TrigL2MuonSA::RpcFitResult
Definition: RpcFitResult.h:14
TrigL2MuonSA::RpcFitResult::offset_middle
double offset_middle
Definition: RpcFitResult.h:53
TrigL2MuonSA::MuonRoad::bw
double bw[N_STATION][N_SECTOR]
Definition: MuonRoad.h:82
M_PI
#define M_PI
Definition: ActiveFraction.h:11
TrigL2MuonSA::MuonRoad::isEndcap
bool isEndcap
Definition: MuonRoad.h:72
xAOD::MuonRoI_v1::eta
float eta() const
The pseudorapidity ( ) of the muon candidate.
xAOD::etaMax
etaMax
Definition: HIEventShape_v2.cxx:46
TrigL2MuonSA::RpcFitResult::offset_inner
double offset_inner
Definition: RpcFitResult.h:49
TrigRoiDescriptor
nope - should be used for standalone also, perhaps need to protect the class def bits #ifndef XAOD_AN...
Definition: TrigRoiDescriptor.h:56
TrigL2MuonSA::RpcFitResult::offset_outer
double offset_outer
Definition: RpcFitResult.h:57
LVL1::RecMuonRoI::eta
virtual double eta() const
returns eta coord of ROI
Definition: RecMuonRoI.h:117
drawFromPickle.exp
exp
Definition: drawFromPickle.py:36
TrigL2MuonSA::RpcRoadDefiner::initialize
virtual StatusCode initialize() override
Definition: RpcRoadDefiner.cxx:24
TrigL2MuonSA::MuonRoad::aw
double aw[N_STATION][N_SECTOR]
Definition: MuonRoad.h:81
drawFromPickle.atan
atan
Definition: drawFromPickle.py:36
TrigL2MuonSA::MuonRoad::side
int side
Definition: MuonRoad.h:76
TrigL2MuonSA::MuonRoad::phiRoI
double phiRoI
Definition: MuonRoad.h:80
TrigL2MuonSA::MuonRoad::stationList
std::vector< Identifier > stationList
Definition: MuonRoad.h:100
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
LVL1::RecMuonRoI
This class defines the reconstructed Muon ROI.
Definition: RecMuonRoI.h:60
TrigL2MuonSA::RpcRoadDefiner::RpcRoadDefiner
RpcRoadDefiner(const std::string &type, const std::string &name, const IInterface *parent)
Definition: RpcRoadDefiner.cxx:14
TrigL2MuonSA::RpcFitResult::slope_inner
double slope_inner
Definition: RpcFitResult.h:48
lumiFormat.i
int i
Definition: lumiFormat.py:92
TrigL2MuonSA::MuonRoad
Definition: MuonRoad.h:20
Identifier
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:32
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::MuonRoad::MDT_sector_trigger
int MDT_sector_trigger
Definition: MuonRoad.h:86
TrigL2MuonSA::RpcFitResult::slope_middle
double slope_middle
Definition: RpcFitResult.h:52
xAOD::MuonRoI_v1
Class describing a LVL1 muon region of interest.
Definition: MuonRoI_v1.h:33
test_pyathena.parent
parent
Definition: test_pyathena.py:15
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
LVL1::RecMuonRoI::sectorID
unsigned int sectorID() const
returns sector ID ROI
Definition: RecMuonRoI.h:111
TrigL2MuonSA::RpcFitResult::phi_middle
double phi_middle
Definition: RpcFitResult.h:51
drawFromPickle.tan
tan
Definition: drawFromPickle.py:36
ZERO_LIMIT
const float ZERO_LIMIT
Definition: VP1TriggerHandleL2.cxx:37
TrigL2MuonSA::RpcFitResult::phi_outer
double phi_outer
Definition: RpcFitResult.h:55
LVL1::RecMuonRoI::phi
virtual double phi() const
returns phi coord of ROI
Definition: RecMuonRoI.h:114
id
SG::auxid_t id
Definition: Control/AthContainers/Root/debug.cxx:191
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:192
TrigL2MuonSA::RpcLayerHits
Definition: RpcPatFinder.h:20
TMVAToMVAUtils::convert
std::unique_ptr< MVAUtils::BDT > convert(TMVA::MethodBDT *bdt, bool isRegression=true, bool useYesNoLeaf=false)
Definition: TMVAToMVAUtils.h:114
TrigL2MuonSA::MuonRoad::LargeSmall
int LargeSmall
Definition: MuonRoad.h:77
TrigL2MuonSA::RpcFitResult::isSuccess
bool isSuccess
Definition: RpcFitResult.h:38
DiTauMassTools::MaxHistStrategyV2::e
e
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
LArCellBinning.etaMin
etaMin
Definition: LArCellBinning.py:84
TrigL2MuonSA::MuonRoad::rWidth
double rWidth[N_STATION][N_LAYER]
Definition: MuonRoad.h:84
CaloCondBlobAlgs_fillNoiseFromASCII.hash
dictionary hash
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:109
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
RpcRoadDefiner.h
if
if(febId1==febId2)
Definition: LArRodBlockPhysicsV0.cxx:569
TrigL2MuonSA::MuonRoad::extFtfMiddlePhi
double extFtfMiddlePhi
Definition: MuonRoad.h:91
TrigL2MuonSA::RpcFitResult::slope_outer
double slope_outer
Definition: RpcFitResult.h:56
TrigL2MuonSA::MuonRoad::aw_ftf
double aw_ftf[N_STATION][N_SECTOR]
Definition: MuonRoad.h:92
TrigRoiDescriptor
Athena::TPCnvVers::Current TrigRoiDescriptor
Definition: TrigSteeringEventTPCnv.cxx:68
TrigRoiDescriptor.h
TrigL2MuonSA::MuonRoad::Special
int Special
Definition: MuonRoad.h:78
xAOD::MuonRoI_v1::getSectorID
int getSectorID() const
Get the sector ID number.
AthAlgTool
Definition: AthAlgTool.h:26
IdentifierHash
Definition: IdentifierHash.h:38
IdContext
class IdContext
Definition: IdContext.h:34
xAOD::MuonRoI_v1::phi
float phi() const
The azimuthal angle ( ) of the muon candidate.
Generated on Sun Jun 30 2024 21:25:47 for ATLAS Offline Software by   doxygen 1.8.18