CMS 3D CMS Logo
RPCtoDTTranslator.cc
Go to the documentation of this file.
1 //-------------------------------------------------
2 //
3 // Class: RPCtoDTTranslator
4 //
5 // RPCtoDTTranslator
6 //
7 //
8 // Author :
9 // G. Flouris U Ioannina Mar. 2015
10 // modifications: G Karathanasis U Athens
11 //--------------------------------------------------
12 
13 #include <iostream>
14 #include <iomanip>
15 #include <iterator>
16 #include <cmath>
17 #include <map>
18 
19 #include "L1Trigger/L1TTwinMux/interface/RPCHitCleaner.h"
20 #include "L1Trigger/L1TTwinMux/interface/RPCtoDTTranslator.h"
21 #include "Geometry/RPCGeometry/interface/RPCRoll.h"
22 #include "Geometry/RPCGeometry/interface/RPCGeometry.h"
23 #include "CondFormats/DataRecord/interface/RPCEMapRcd.h"
24 #include "Geometry/Records/interface/MuonGeometryRecord.h"
25 
26 using namespace std;
27 
28 RPCtoDTTranslator::RPCtoDTTranslator(RPCDigiCollection const& inrpcDigis) : m_rpcDigis{inrpcDigis} {}
29 
30 namespace {
31  constexpr int max_rpc_bx = 2;
32  constexpr int min_rpc_bx = -2;
33 
34  struct rpc_hit {
35  int bx;
36  int station;
37  int sector;
38  int wheel;
39  RPCDetId detid;
40  int strip;
41  int roll;
42  int layer;
43  rpc_hit(int pbx, int pstation, int psector, int pwheel, RPCDetId pdet, int pstrip, int proll, int player)
44  : bx(pbx),
45  station(pstation),
46  sector(psector),
47  wheel(pwheel),
48  detid(pdet),
49  strip(pstrip),
50  roll(proll),
51  layer(player) {}
52  };
53 
54  //Need to shift the index so that index 0
55  // corresponds to min_rpc_bx
56  class BxToHit {
57  public:
58  BxToHit() : m_hits{} {} //zero initializes
59 
60  static bool outOfRange(int iBX) { return (iBX > max_rpc_bx or iBX < min_rpc_bx); }
61 
62  int& operator[](int iBX) { return m_hits[iBX - min_rpc_bx]; }
63 
64  size_t size() const { return m_hits.size(); }
65 
66  private:
67  std::array<int, max_rpc_bx - min_rpc_bx + 1> m_hits;
68  };
69 } // namespace
70 
71 void RPCtoDTTranslator::run(const edm::EventSetup& c) {
72  std::vector<L1MuDTChambPhDigi> l1ttma_out;
73  std::vector<L1MuDTChambPhDigi> l1ttma_hits_out;
74 
75  std::vector<rpc_hit> vrpc_hit_layer1, vrpc_hit_layer2, vrpc_hit_st3, vrpc_hit_st4;
76 
78  for (auto chamber = m_rpcDigis.begin(); chamber != m_rpcDigis.end(); ++chamber) {
79  RPCDetId detid = (*chamber).first;
80  for (auto digi = (*chamber).second.first; digi != (*chamber).second.second; ++digi) {
81  if (detid.region() != 0)
82  continue; //Region = 0 Barrel
83  if (BxToHit::outOfRange(digi->bx()))
84  continue;
85  if (detid.layer() == 1)
86  vrpc_hit_layer1.emplace_back(digi->bx(),
87  detid.station(),
88  detid.sector(),
89  detid.ring(),
90  detid,
91  digi->strip(),
92  detid.roll(),
93  detid.layer());
94  if (detid.station() == 3)
95  vrpc_hit_st3.emplace_back(digi->bx(),
96  detid.station(),
97  detid.sector(),
98  detid.ring(),
99  detid,
100  digi->strip(),
101  detid.roll(),
102  detid.layer());
103  if (detid.layer() == 2)
104  vrpc_hit_layer2.emplace_back(digi->bx(),
105  detid.station(),
106  detid.sector(),
107  detid.ring(),
108  detid,
109  digi->strip(),
110  detid.roll(),
111  detid.layer());
112  if (detid.station() == 4)
113  vrpc_hit_st4.emplace_back(digi->bx(),
114  detid.station(),
115  detid.sector(),
116  detid.ring(),
117  detid,
118  digi->strip(),
119  detid.roll(),
120  detid.layer());
121  }
122  }
123 
124  vector<int> vcluster_size;
125  int cluster_id = -1;
126  int itr = 0;
127  // int hits[5][4][12][2][5][3][100]= {{{{{{{0}}}}}}};
128  std::map<RPCHitCleaner::detId_Ext, int> hits;
129  int cluster_size = 0;
130  for (auto chamber = m_rpcDigis.begin(); chamber != m_rpcDigis.end(); ++chamber) {
131  RPCDetId detid = (*chamber).first;
132  int strip_n1 = -10000;
133  int bx_n1 = -10000;
134  if (detid.region() != 0)
135  continue; //Region = 0 Barrel
136  for (auto digi = (*chamber).second.first; digi != (*chamber).second.second; ++digi) {
137  if (fabs(digi->bx()) > 3)
138  continue;
139  //Create cluster ids and store their size
140  //if((digi->strip()+1!=strip_n1)|| digi->bx()!=bx_n1){
141  if (abs(digi->strip() - strip_n1) != 1 || digi->bx() != bx_n1) {
142  if (itr != 0)
143  vcluster_size.push_back(cluster_size);
144  cluster_size = 0;
145  cluster_id++;
146  }
147  itr++;
148  cluster_size++;
150  //hits[(detid.ring()+2)][(detid.station()-1)][(detid.sector()-1)][(detid.layer()-1)][(digi->bx()+2)][detid.roll()-1][digi->strip()]= cluster_id ;
151  RPCHitCleaner::detId_Ext tmp{detid, digi->bx(), digi->strip()};
152  hits[tmp] = cluster_id;
154  strip_n1 = digi->strip();
155  bx_n1 = digi->bx();
156  }
157  }
158  vcluster_size.push_back(cluster_size);
159 
160  for (int wh = -2; wh <= 2; wh++) {
161  for (int sec = 1; sec <= 12; sec++) {
162  for (int st = 1; st <= 4; st++) {
163  int rpcbx = 0;
164  std::vector<int> delta_phib;
165  bool found_hits = false;
166  std::vector<int> rpc2dt_phi, rpc2dt_phib;
168  int itr1 = 0;
169  for (unsigned int l1 = 0; l1 < vrpc_hit_layer1.size(); l1++) {
170  RPCHitCleaner::detId_Ext tmp{vrpc_hit_layer1[l1].detid, vrpc_hit_layer1[l1].bx, vrpc_hit_layer1[l1].strip};
171  int id = hits[tmp];
172  int phi1 = radialAngle(vrpc_hit_layer1[l1].detid, c, vrpc_hit_layer1[l1].strip);
173  if (vcluster_size[id] == 2 && itr1 == 0) {
174  itr1++;
175  continue;
176  }
177  if (vcluster_size[id] == 2 && itr1 == 1) {
178  itr1 = 0;
179  phi1 = phi1 + (radialAngle(vrpc_hit_layer1[l1 - 1].detid, c, vrpc_hit_layer1[l1 - 1].strip));
180  phi1 /= 2;
181  }
182  int itr2 = 0;
183  for (unsigned int l2 = 0; l2 < vrpc_hit_layer2.size(); l2++) {
184  if (vrpc_hit_layer1[l1].station != st || vrpc_hit_layer2[l2].station != st)
185  continue;
186  if (vrpc_hit_layer1[l1].sector != sec || vrpc_hit_layer2[l2].sector != sec)
187  continue;
188  if (vrpc_hit_layer1[l1].wheel != wh || vrpc_hit_layer2[l2].wheel != wh)
189  continue;
190  if (vrpc_hit_layer1[l1].bx != vrpc_hit_layer2[l2].bx)
191  continue;
192  RPCHitCleaner::detId_Ext tmp{vrpc_hit_layer2[l2].detid, vrpc_hit_layer2[l2].bx, vrpc_hit_layer2[l2].strip};
193  int id = hits[tmp];
194 
195  if (vcluster_size[id] == 2 && itr2 == 0) {
196  itr2++;
197  continue;
198  }
199 
200  //int phi1 = radialAngle(vrpc_hit_layer1[l1].detid, c, vrpc_hit_layer1[l1].strip) ;
201  int phi2 = radialAngle(vrpc_hit_layer2[l2].detid, c, vrpc_hit_layer2[l2].strip);
202  if (vcluster_size[id] == 2 && itr2 == 1) {
203  itr2 = 0;
204  phi2 = phi2 + (radialAngle(vrpc_hit_layer2[l2 - 1].detid, c, vrpc_hit_layer2[l2 - 1].strip));
205  phi2 /= 2;
206  }
207  int average = ((phi1 + phi2) / 2) << 2; //10-bit->12-bit
208  rpc2dt_phi.push_back(average); //Convert and store to 12-bit
209  //int xin = localX(vrpc_hit_layer1[l1].detid, c, vrpc_hit_layer1[l1].strip);
210  //int xout = localX(vrpc_hit_layer2[l2].detid, c, vrpc_hit_layer2[l2].strip);
211  //cout<<(phi1<<2)<<" "<<l1<<" "<<vrpc_hit_layer1[l1].station<<endl;
212  //cout<<(phi2<<2)<<" "<<l1<<" "<<vrpc_hit_layer1[l1].station<<endl;
213  int xin = localXX((phi1 << 2), 1, vrpc_hit_layer1[l1].station);
214  int xout = localXX((phi2 << 2), 2, vrpc_hit_layer2[l2].station);
215  if (vcluster_size[id] == 2 && itr2 == 1) {
216  int phi1_n1 = radialAngle(vrpc_hit_layer1[l1 - 1].detid, c, vrpc_hit_layer1[l1 - 1].strip);
217  int phi2_n1 = radialAngle(vrpc_hit_layer2[l2 - 1].detid, c, vrpc_hit_layer2[l2 - 1].strip);
218  xin += localXX((phi1_n1 << 2), 1, vrpc_hit_layer1[l1].station);
219  xout += localXX((phi2_n1 << 2), 2, vrpc_hit_layer2[l2].station);
220  xin /= 2;
221  xout /= 2;
222  }
223  //cout<<">>"<<xin<<" "<<xout<<endl;
224  int phi_b = bendingAngle(xin, xout, average);
225  //cout<<"phib "<<phi_b<<endl;
226  rpc2dt_phib.push_back(phi_b);
227  //delta_phib to find the highest pt primitve
228  delta_phib.push_back(abs(phi_b));
229  found_hits = true;
230  rpcbx = vrpc_hit_layer1[l1].bx;
231  }
232  }
233  if (found_hits) {
234  //cout<<"found_hits"<<endl;
235  int min_index = std::distance(delta_phib.begin(), std::min_element(delta_phib.begin(), delta_phib.end())) + 0;
236  //cout<<min_index<<endl;
237  l1ttma_out.emplace_back(rpcbx, wh, sec - 1, st, rpc2dt_phi[min_index], rpc2dt_phib[min_index], 3, 0, 0, 2);
238  }
240  BxToHit hit;
241  itr1 = 0;
242  for (unsigned int l1 = 0; l1 < vrpc_hit_layer1.size(); l1++) {
243  if (vrpc_hit_layer1[l1].station != st || st > 2 || vrpc_hit_layer1[l1].sector != sec ||
244  vrpc_hit_layer1[l1].wheel != wh)
245  continue;
246  //int id = hits[vrpc_hit_layer1[l1].wheel+2][(vrpc_hit_layer1[l1].station-1)][(vrpc_hit_layer1[l1].sector-1)][(vrpc_hit_layer1[l1].layer-1)][(vrpc_hit_layer1[l1].bx+2)][vrpc_hit_layer1[l1].roll-1][vrpc_hit_layer1[l1].strip];
247  RPCHitCleaner::detId_Ext tmp{vrpc_hit_layer1[l1].detid, vrpc_hit_layer1[l1].bx, vrpc_hit_layer1[l1].strip};
248  int id = hits[tmp];
249  if (vcluster_size[id] == 2 && itr1 == 0) {
250  itr1++;
251  continue;
252  }
253  int phi2 = radialAngle(vrpc_hit_layer1[l1].detid, c, vrpc_hit_layer1[l1].strip);
254  phi2 = phi2 << 2;
255  if (vcluster_size[id] == 2 && itr1 == 1) {
256  itr1 = 0;
257  phi2 = phi2 + (radialAngle(vrpc_hit_layer1[l1 - 1].detid, c, vrpc_hit_layer1[l1 - 1].strip) << 2);
258  phi2 /= 2;
259  }
260 
261  l1ttma_hits_out.emplace_back(
262  vrpc_hit_layer1[l1].bx, wh, sec - 1, st, phi2, 0, 3, hit[vrpc_hit_layer1[l1].bx], 0, 2);
263  hit[vrpc_hit_layer1[l1].bx]++;
264  }
265  itr1 = 0;
266  for (unsigned int l2 = 0; l2 < vrpc_hit_layer2.size(); l2++) {
267  if (vrpc_hit_layer2[l2].station != st || st > 2 || vrpc_hit_layer2[l2].sector != sec ||
268  vrpc_hit_layer2[l2].wheel != wh)
269  continue;
270  RPCHitCleaner::detId_Ext tmp{vrpc_hit_layer2[l2].detid, vrpc_hit_layer2[l2].bx, vrpc_hit_layer2[l2].strip};
271  int id = hits[tmp];
272  // int id = hits[vrpc_hit_layer2[l2].wheel+2][(vrpc_hit_layer2[l2].station-1)][(vrpc_hit_layer2[l2].sector-1)][(vrpc_hit_layer2[l2].layer-1)][(vrpc_hit_layer2[l2].bx+2)][vrpc_hit_layer2[l2].roll-1][vrpc_hit_layer2[l2].strip];
273  if (vcluster_size[id] == 2 && itr1 == 0) {
274  itr1++;
275  continue;
276  }
277  int phi2 = radialAngle(vrpc_hit_layer2[l2].detid, c, vrpc_hit_layer2[l2].strip);
278  phi2 = phi2 << 2;
279  if (vcluster_size[id] == 2 && itr1 == 1) {
280  itr1 = 0;
281  phi2 = phi2 + (radialAngle(vrpc_hit_layer2[l2 - 1].detid, c, vrpc_hit_layer2[l2 - 1].strip) << 2);
282  phi2 /= 2;
283  }
284  l1ttma_hits_out.emplace_back(
285  vrpc_hit_layer2[l2].bx, wh, sec - 1, st, phi2, 0, 3, hit[vrpc_hit_layer2[l2].bx], 0, 2);
286  hit[vrpc_hit_layer2[l2].bx]++;
287  }
288  itr1 = 0;
289 
290  for (unsigned int l1 = 0; l1 < vrpc_hit_st3.size(); l1++) {
291  if (st != 3 || vrpc_hit_st3[l1].station != 3 || vrpc_hit_st3[l1].wheel != wh ||
292  vrpc_hit_st3[l1].sector != sec)
293  continue;
294  RPCHitCleaner::detId_Ext tmp{vrpc_hit_st3[l1].detid, vrpc_hit_st3[l1].bx, vrpc_hit_st3[l1].strip};
295  int id = hits[tmp];
296  //int id = hits[vrpc_hit_st3[l1].wheel+2][(vrpc_hit_st3[l1].station-1)][(vrpc_hit_st3[l1].sector-1)][(vrpc_hit_st3[l1].layer-1)][(vrpc_hit_st3[l1].bx+2)][vrpc_hit_st3[l1].roll-1][vrpc_hit_st3[l1].strip];
297  if (vcluster_size[id] == 2 && itr1 == 0) {
298  itr1++;
299  continue;
300  }
301  int phi2 = radialAngle(vrpc_hit_st3[l1].detid, c, vrpc_hit_st3[l1].strip);
302  phi2 = phi2 << 2;
303  if (vcluster_size[id] == 2 && itr1 == 1) {
304  itr1 = 0;
305  phi2 = phi2 + (radialAngle(vrpc_hit_st3[l1 - 1].detid, c, vrpc_hit_st3[l1 - 1].strip) << 2);
306  phi2 /= 2;
307  }
308  l1ttma_hits_out.emplace_back(
309  vrpc_hit_st3[l1].bx, wh, sec - 1, st, phi2, 0, 3, hit[vrpc_hit_st3[l1].bx], 0, 2);
310  hit[vrpc_hit_st3[l1].bx]++;
311  }
312  itr1 = 0;
313 
314  for (unsigned int l1 = 0; l1 < vrpc_hit_st4.size(); l1++) {
315  if (st != 4 || vrpc_hit_st4[l1].station != 4 || vrpc_hit_st4[l1].wheel != wh ||
316  vrpc_hit_st4[l1].sector != sec)
317  continue;
318  //int id = hits[vrpc_hit_st4[l1].wheel+2][(vrpc_hit_st4[l1].station-1)][(vrpc_hit_st4[l1].sector-1)][(vrpc_hit_st4[l1].layer-1)][(vrpc_hit_st4[l1].bx+2)][vrpc_hit_st4[l1].roll-1][vrpc_hit_st4[l1].strip];
319  RPCHitCleaner::detId_Ext tmp{vrpc_hit_st4[l1].detid, vrpc_hit_st4[l1].bx, vrpc_hit_st4[l1].strip};
320  int id = hits[tmp];
321  if (vcluster_size[id] == 2 && itr1 == 0) {
322  itr1++;
323  continue;
324  }
325  int phi2 = radialAngle(vrpc_hit_st4[l1].detid, c, vrpc_hit_st4[l1].strip);
326  phi2 = phi2 << 2;
327  if (vcluster_size[id] == 2 && itr1 == 1) {
328  itr1 = 0;
329  phi2 = phi2 + (radialAngle(vrpc_hit_st4[l1 - 1].detid, c, vrpc_hit_st4[l1 - 1].strip) << 2);
330  phi2 /= 2;
331  }
332  l1ttma_hits_out.emplace_back(
333  vrpc_hit_st4[l1].bx, wh, sec - 1, st, phi2, 0, 3, hit[vrpc_hit_st4[l1].bx], 0, 2);
334  hit[vrpc_hit_st4[l1].bx]++;
335  //l1ttma_out.push_back(rpc2dt_out);
336 
337  //break;
338  }
339  }
340  }
341  }
343  m_rpcdt_translated.setContainer(l1ttma_out);
345  m_rpchitsdt_translated.setContainer(l1ttma_hits_out);
346 }
347 
349 int RPCtoDTTranslator::radialAngle(RPCDetId detid, const edm::EventSetup& c, int strip) {
350  int radialAngle;
351  // from phiGlobal to radialAngle of the primitive in sector sec in [1..12] <- RPC scheme
352  edm::ESHandle<RPCGeometry> rpcGeometry;
353  c.get<MuonGeometryRecord>().get(rpcGeometry);
354 
355  const RPCRoll* roll = rpcGeometry->roll(detid);
356  GlobalPoint stripPosition = roll->toGlobal(roll->centreOfStrip(strip));
357 
358  double globalphi = stripPosition.phi();
359  int sector = (roll->id()).sector();
360  if (sector == 1)
361  radialAngle = int(globalphi * 1024);
362  else {
363  if (globalphi >= 0)
364  radialAngle = int((globalphi - (sector - 1) * Geom::pi() / 6.) * 1024);
365  else
366  radialAngle = int((globalphi + (13 - sector) * Geom::pi() / 6.) * 1024);
367  }
368  return radialAngle;
369 }
370 
372 int RPCtoDTTranslator::localX(RPCDetId detid, const edm::EventSetup& c, int strip) {
373  edm::ESHandle<RPCGeometry> rpcGeometry;
374  c.get<MuonGeometryRecord>().get(rpcGeometry);
375 
376  const RPCRoll* roll = rpcGeometry->roll(detid);
377 
379  GlobalPoint p1cmPRG = roll->toGlobal(LocalPoint(1, 0, 0));
380  GlobalPoint m1cmPRG = roll->toGlobal(LocalPoint(-1, 0, 0));
381  float phip1cm = p1cmPRG.phi();
382  float phim1cm = m1cmPRG.phi();
383  int direction = (phip1cm - phim1cm) / abs(phip1cm - phim1cm);
385 
386  return direction * roll->centreOfStrip(strip).x();
387 }
388 
389 int RPCtoDTTranslator::bendingAngle(int xin, int xout, int phi) {
390  // use chamber size and max angle in hw units 512
391  int atanv = (int)(atan((xout - xin) / 34.6) * 512);
392  if (atanv > 512)
393  return 512;
394  int rvalue = atanv - phi / 8;
395  return rvalue;
396 }
397 
398 int RPCtoDTTranslator::localXX(int phi, int layer, int station) {
399  //R[stat][layer] - radius of rpc station/layer from center of CMS
400  double R[2][2] = {{410.0, 444.8}, {492.7, 527.3}};
401  double rvalue = R[station - 1][layer - 1] * tan(phi / 4096.);
402  return rvalue;
403 }
RPCtoDTTranslator::localXX
static int localXX(int, int, int)
Definition: RPCtoDTTranslator.cc:398
RPCRoll
Definition: RPCRoll.h:12
RPCtoDTTranslator.h
RPCtoDTTranslator::localX
static int localX(RPCDetId, const edm::EventSetup &, int)
function - will be replaced by LUTs(?)
Definition: RPCtoDTTranslator.cc:372
RPCDetId::station
int station() const
Definition: RPCDetId.h:78
RPCDetId::region
int region() const
Region id: 0 for Barrel, +/-1 For +/- Endcap.
Definition: RPCDetId.h:53
hfClusterShapes_cfi.hits
hits
Definition: hfClusterShapes_cfi.py:5
PV3DBase::x
T x() const
Definition: PV3DBase.h:59
relativeConstraints.station
station
Definition: relativeConstraints.py:67
digitizers_cfi.strip
strip
Definition: digitizers_cfi.py:19
RPCDetId
Definition: RPCDetId.h:16
l1GtPatternGenerator_cfi.bx
bx
Definition: l1GtPatternGenerator_cfi.py:18
RPCGeometry::roll
const RPCRoll * roll(RPCDetId id) const
Return a roll given its id.
Definition: RPCGeometry.cc:50
RPCRoll.h
mps_check.array
array
Definition: mps_check.py:216
RPCtoDTTranslator::m_rpcDigis
const RPCDigiCollection & m_rpcDigis
Definition: RPCtoDTTranslator.h:52
align::LocalPoint
Point3DBase< Scalar, LocalTag > LocalPoint
Definition: Definitions.h:30
createJobs.tmp
tmp
align.sh
Definition: createJobs.py:716
RPCEMapRcd.h
RPCHitCleaner.h
RPCtoDTTranslator::RPCtoDTTranslator
RPCtoDTTranslator(const RPCDigiCollection &inrpcDigis)
Definition: RPCtoDTTranslator.cc:28
RPCtoDTTranslator::bendingAngle
static int bendingAngle(int, int, int)
Definition: RPCtoDTTranslator.cc:389
RPCDigiCollection
RPCRoll::id
RPCDetId id() const
Definition: RPCRoll.cc:16
RPCtoDTTranslator::m_rpcdt_translated
L1MuDTChambPhContainer m_rpcdt_translated
Output PhContainer.
Definition: RPCtoDTTranslator.h:49
RPCHitCleaner::detId_Ext
Definition: RPCHitCleaner.h:38
L1MuDTChambPhContainer::setContainer
void setContainer(Phi_Container inputSegments)
Definition: L1MuDTChambPhContainer.cc:39
edm::ESHandle< RPCGeometry >
Geom::pi
constexpr double pi()
Definition: Pi.h:31
Point3DBase< float, GlobalTag >
RPCRoll::centreOfStrip
LocalPoint centreOfStrip(int strip) const
Definition: RPCRoll.cc:26
RPCDetId::roll
int roll() const
Definition: RPCDetId.h:92
RPCtoDTTranslator::m_rpchitsdt_translated
L1MuDTChambPhContainer m_rpchitsdt_translated
Definition: RPCtoDTTranslator.h:50
GeomDet::toGlobal
GlobalPoint toGlobal(const Local2DPoint &lp) const
Conversion to the global R.F. from the R.F. of the GeomDet.
Definition: GeomDet.h:49
PVValHelper::phi
Definition: PVValidationHelpers.h:68
RPCtoDTTranslator::run
void run(const edm::EventSetup &c)
Definition: RPCtoDTTranslator.cc:71
funct::tan
Tan< T >::type tan(const T &t)
Definition: Tan.h:22
makeMuonMisalignmentScenario.wheel
wheel
Definition: makeMuonMisalignmentScenario.py:319
createfilelist.int
int
Definition: createfilelist.py:10
average
Definition: average.py:1
edm::EventSetup
Definition: EventSetup.h:57
HltBtagPostValidation_cff.c
c
Definition: HltBtagPostValidation_cff.py:31
itr
std::vector< std::pair< float, float > >::iterator itr
Definition: HGCDigitizer.cc:29
get
#define get
RPCtoDTTranslator::radialAngle
static int radialAngle(RPCDetId, const edm::EventSetup &, int)
function - will be replaced by LUTs(?)
Definition: RPCtoDTTranslator.cc:349
fileinputsource_cfi.sec
sec
Definition: fileinputsource_cfi.py:87
RPCDetId::ring
int ring() const
Definition: RPCDetId.h:59
DDAxes::phi
std
Definition: JetResolutionObject.h:76
RPCDetId::sector
int sector() const
Sector id: the group of chambers at same phi (and increasing r)
Definition: RPCDetId.h:81
relativeConstraints.chamber
chamber
Definition: relativeConstraints.py:53
or
The Signals That Services Can Subscribe To This is based on ActivityRegistry and is current per Services can connect to the signals distributed by the ActivityRegistry in order to monitor the activity of the application Each possible callback has some defined which we here list in angle e< void, edm::EventID const &, edm::Timestamp const & > We also list in braces which AR_WATCH_USING_METHOD_ is used for those or
Definition: Activities.doc:12
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
operator[]
T operator[](int i) const
Definition: extBasic3DVector.h:222
MuonGeometryRecord.h
RPCDetId::layer
int layer() const
Definition: RPCDetId.h:85
HLT_FULL_cff.distance
distance
Definition: HLT_FULL_cff.py:7799
dttmaxenums::R
Definition: DTTMax.h:29
MuonGeometryRecord
Definition: MuonGeometryRecord.h:34
RPCGeometry.h
PV3DBase::phi
Geom::Phi< T > phi() const
Definition: PV3DBase.h:66
hit
Definition: SiStripHitEffFromCalibTree.cc:88
findQualityFiles.size
size
Write out results.
Definition: findQualityFiles.py:443
Generated for CMSSW Reference Manual by doxygen 1.8.16