CMS 3D CMS Logo
List of all members | Public Member Functions | Private Member Functions | Private Attributes
CSCUpgradeMotherboardLUTGenerator Class Reference

#include <CSCUpgradeMotherboardLUTGenerator.h>

Public Member Functions

int assignRoll (const std::vector< std::pair< double, double > > &, double eta) const
 
 CSCUpgradeMotherboardLUTGenerator ()
 
void generateLUTs (unsigned e, unsigned s, unsigned se, unsigned sb, unsigned c) const
 generate and print LUT More...
 
void generateLUTsME11 (unsigned e, unsigned se, unsigned sb, unsigned c) const
 
void generateLUTsME21 (unsigned e, unsigned se, unsigned sb, unsigned c) const
 
void setCSCGeometry (const CSCGeometry *g)
 set CSC and GEM geometries for the matching needs More...
 
void setGEMGeometry (const GEMGeometry *g)
 
 ~CSCUpgradeMotherboardLUTGenerator ()
 

Private Member Functions

void cscHsToGemPadLUT (const CSCLayer *, const GEMEtaPartition *, int minH, int maxH, std::vector< std::pair< int, int > > &) const
 
void cscWgToEtaLimitsLUT (const CSCLayer *, std::vector< std::pair< double, double > > &) const
 
void cscWgToRollLUT (const std::vector< std::pair< double, double > > &, const std::vector< std::pair< double, double > > &, std::vector< std::pair< int, int > > &) const
 
void gemPadToCscHsLUT (const CSCLayer *, const GEMEtaPartition *, std::vector< int > &) const
 
void gemRollToCscWgLUT (const CSCLayer *, const GEMChamber *, std::vector< int > &) const
 
void gemRollToEtaLimitsLUT (const GEMChamber *c, std::vector< std::pair< double, double > > &) const
 

Private Attributes

const CSCGeometry * csc_g
 
const GEMGeometry * gem_g
 

Detailed Description

Definition at line 11 of file CSCUpgradeMotherboardLUTGenerator.h.

Constructor & Destructor Documentation

◆ CSCUpgradeMotherboardLUTGenerator()

CSCUpgradeMotherboardLUTGenerator::CSCUpgradeMotherboardLUTGenerator ( )
inline

Definition at line 13 of file CSCUpgradeMotherboardLUTGenerator.h.

13 {}

◆ ~CSCUpgradeMotherboardLUTGenerator()

CSCUpgradeMotherboardLUTGenerator::~CSCUpgradeMotherboardLUTGenerator ( )
inline

Definition at line 14 of file CSCUpgradeMotherboardLUTGenerator.h.

14 {}

Member Function Documentation

◆ assignRoll()

int CSCUpgradeMotherboardLUTGenerator::assignRoll ( const std::vector< std::pair< double, double > > &  lut,
double  eta 
) const

Definition at line 192 of file CSCUpgradeMotherboardLUTGenerator.cc.

193  {
194  int result = -99;
195  int iRoll = 0;
196  for (const auto& p : lut) {
197  iRoll++;
198  const float minEta(p.first);
199  const float maxEta(p.second);
200  if (minEta <= std::abs(eta) and std::abs(eta) < maxEta) {
201  result = iRoll;
202  break;
203  }
204  }
205  return result;
206 }

References funct::abs(), PVValHelper::eta, maxEta, EgHLTOffEleSelection_cfi::minEta, AlCaHLTBitMon_ParallelJobs::p, and mps_fire::result.

Referenced by cscWgToRollLUT().

◆ cscHsToGemPadLUT()

void CSCUpgradeMotherboardLUTGenerator::cscHsToGemPadLUT ( const CSCLayer *  keyLayer,
const GEMEtaPartition *  randRoll,
int  minH,
int  maxH,
std::vector< std::pair< int, int > > &  lut 
) const
private

Definition at line 247 of file CSCUpgradeMotherboardLUTGenerator.cc.

251  {
252  const CSCLayerGeometry* keyLayerGeometry(keyLayer->geometry());
253  auto nStrips(keyLayerGeometry->numberOfStrips());
254  for (float i = 0; i < nStrips; i = i + 0.5) {
255  const LocalPoint lpCSC(keyLayerGeometry->topology()->localPosition(i));
256  const GlobalPoint gp(keyLayer->toGlobal(lpCSC));
257  const LocalPoint lpGEM(randRoll->toLocal(gp));
258  const float pad(randRoll->pad(lpGEM));
259  lut.emplace_back(std::floor(pad), std::ceil(pad));
260  }
261 }

References reco::ceil(), CSCLayer::geometry(), runTauDisplay::gp, mps_fire::i, me0TriggerPseudoDigis_cff::nStrips, GEMEtaPartition::pad(), GeomDet::toGlobal(), and GeomDet::toLocal().

Referenced by generateLUTsME11(), and generateLUTsME21().

◆ cscWgToEtaLimitsLUT()

void CSCUpgradeMotherboardLUTGenerator::cscWgToEtaLimitsLUT ( const CSCLayer *  keyLayer,
std::vector< std::pair< double, double > > &  lut 
) const
private

Definition at line 232 of file CSCUpgradeMotherboardLUTGenerator.cc.

233  {
234  const CSCLayerGeometry* keyLayerGeometry(keyLayer->geometry());
235  const int numberOfWG(keyLayerGeometry->numberOfWireGroups());
236  for (int i = 0; i < numberOfWG; ++i) {
237  const float middle_wire(keyLayerGeometry->middleWireOfGroup(i));
238  const std::pair<LocalPoint, LocalPoint> wire_ends(keyLayerGeometry->wireTopology()->wireEnds(middle_wire));
239  const GlobalPoint gp_top(keyLayer->toGlobal(wire_ends.first));
240  const GlobalPoint gp_bottom(keyLayer->toGlobal(wire_ends.second));
241  const double bottom_eta(std::abs(gp_bottom.eta()));
242  const double top_eta(std::abs(gp_top.eta()));
243  lut.emplace_back(std::min(bottom_eta, top_eta), std::max(bottom_eta, top_eta));
244  }
245 }

References funct::abs(), CSCLayer::geometry(), mps_fire::i, SiStripPI::max, min(), and GeomDet::toGlobal().

Referenced by generateLUTsME11(), and generateLUTsME21().

◆ cscWgToRollLUT()

void CSCUpgradeMotherboardLUTGenerator::cscWgToRollLUT ( const std::vector< std::pair< double, double > > &  inLUT1,
const std::vector< std::pair< double, double > > &  inLUT2,
std::vector< std::pair< int, int > > &  outLUT 
) const
private

Definition at line 222 of file CSCUpgradeMotherboardLUTGenerator.cc.

224  {
225  for (const auto& p : inLUT1) {
226  double etaMin(p.first);
227  double etaMax(p.second);
228  outLUT.emplace_back(assignRoll(inLUT2, etaMin), assignRoll(inLUT2, etaMax));
229  }
230 }

References assignRoll(), ALCARECOTkAlBeamHalo_cff::etaMax, ALCARECOTkAlBeamHalo_cff::etaMin, and AlCaHLTBitMon_ParallelJobs::p.

Referenced by generateLUTsME11(), and generateLUTsME21().

◆ gemPadToCscHsLUT()

void CSCUpgradeMotherboardLUTGenerator::gemPadToCscHsLUT ( const CSCLayer *  keyLayer,
const GEMEtaPartition *  randRoll,
std::vector< int > &  lut 
) const
private

Definition at line 263 of file CSCUpgradeMotherboardLUTGenerator.cc.

265  {
266  const int nGEMPads(randRoll->npads());
267  const CSCLayerGeometry* keyLayerGeometry(keyLayer->geometry());
268  for (int i = 0; i < nGEMPads; ++i) {
269  const LocalPoint lpGEM(randRoll->centreOfPad(i));
270  const GlobalPoint gp(randRoll->toGlobal(lpGEM));
271  const LocalPoint lpCSC(keyLayer->toLocal(gp));
272  const float strip(keyLayerGeometry->strip(lpCSC));
273  lut.push_back(int(strip * 2));
274  }
275 }

References GEMEtaPartition::centreOfPad(), CSCLayer::geometry(), runTauDisplay::gp, mps_fire::i, GEMEtaPartition::npads(), digitizers_cfi::strip, GeomDet::toGlobal(), and GeomDet::toLocal().

Referenced by generateLUTsME11(), and generateLUTsME21().

◆ gemRollToCscWgLUT()

void CSCUpgradeMotherboardLUTGenerator::gemRollToCscWgLUT ( const CSCLayer *  keyLayer,
const GEMChamber *  gemChamber,
std::vector< int > &  lut 
) const
private

Definition at line 277 of file CSCUpgradeMotherboardLUTGenerator.cc.

279  {
280  const CSCLayerGeometry* keyLayerGeometry(keyLayer->geometry());
281  for (const auto& roll : gemChamber->etaPartitions()) {
282  const float half_striplength(roll->specs()->specificTopology().stripLength() / 2.);
283  const LocalPoint lp_top(0., half_striplength, 0.);
284  const LocalPoint lp_bottom(0., -half_striplength, 0.);
285  const GlobalPoint gp_top(roll->toGlobal(lp_top));
286  const GlobalPoint gp_bottom(roll->toGlobal(lp_bottom));
287  float x, y, z;
288  x = (gp_top.x() + gp_bottom.x()) / 2.;
289  y = (gp_top.y() + gp_bottom.y()) / 2.;
290  z = (gp_top.z() + gp_bottom.z()) / 2.;
291  const GlobalPoint gp_ave(x, y, z);
292  const LocalPoint lp_ave(keyLayer->toLocal(gp_ave));
293  const int wire(keyLayerGeometry->nearestWire(lp_ave));
294  const int wg(keyLayerGeometry->wireGroup(wire));
295  lut.emplace_back(wg);
296  }
297 }

References GEMChamber::etaPartitions(), CSCLayer::geometry(), GeomDet::toLocal(), x, y, and z.

Referenced by generateLUTsME11(), and generateLUTsME21().

◆ gemRollToEtaLimitsLUT()

void CSCUpgradeMotherboardLUTGenerator::gemRollToEtaLimitsLUT ( const GEMChamber *  c,
std::vector< std::pair< double, double > > &  lut 
) const
private

Definition at line 208 of file CSCUpgradeMotherboardLUTGenerator.cc.

209  {
210  for (const auto& roll : gemChamber->etaPartitions()) {
211  const float half_striplength(roll->specs()->specificTopology().stripLength() / 2.);
212  const LocalPoint lp_top(0., half_striplength, 0.);
213  const LocalPoint lp_bottom(0., -half_striplength, 0.);
214  const GlobalPoint gp_top(roll->toGlobal(lp_top));
215  const GlobalPoint gp_bottom(roll->toGlobal(lp_bottom));
216  const double bottom_eta(std::abs(gp_bottom.eta()));
217  const double top_eta(std::abs(gp_top.eta()));
218  lut.emplace_back(std::min(bottom_eta, top_eta), std::max(bottom_eta, top_eta));
219  }
220 }

References funct::abs(), GEMChamber::etaPartitions(), SiStripPI::max, and min().

Referenced by generateLUTsME11(), and generateLUTsME21().

◆ generateLUTs()

void CSCUpgradeMotherboardLUTGenerator::generateLUTs ( unsigned  e,
unsigned  s,
unsigned  se,
unsigned  sb,
unsigned  c 
) const

generate and print LUT

Definition at line 7 of file CSCUpgradeMotherboardLUTGenerator.cc.

8  {
9  if (theStation == 1)
10  generateLUTsME11(theEndcap, theSector, theSubsector, theTrigChamber);
11  if (theStation == 2)
12  generateLUTsME21(theEndcap, theSector, theSubsector, theTrigChamber);
13 }

References generateLUTsME11(), and generateLUTsME21().

◆ generateLUTsME11()

void CSCUpgradeMotherboardLUTGenerator::generateLUTsME11 ( unsigned  e,
unsigned  se,
unsigned  sb,
unsigned  c 
) const

Definition at line 15 of file CSCUpgradeMotherboardLUTGenerator.cc.

18  {
19  bool gemGeometryAvailable(false);
20  if (gem_g != nullptr) {
21  LogTrace("CSCUpgradeMotherboardLUTGenerator") << "+++ generateLUTsME11() called for ME11 chamber! +++ \n";
22  gemGeometryAvailable = true;
23  }
24 
25  // check for GEM geometry
26  if (not gemGeometryAvailable) {
27  LogTrace("CSCUpgradeMotherboardLUTGenerator")
28  << "+++ generateLUTsME11() called for ME11 chamber without valid GEM geometry! +++ \n";
29  return;
30  }
31 
32  // CSC trigger geometry
33  const int chid = CSCTriggerNumbering::chamberFromTriggerLabels(theSector, theSubsector, 1, theTrigChamber);
34  const CSCDetId me1bId(theEndcap, 1, 1, chid, 0);
35  const CSCDetId me1aId(theEndcap, 1, 4, chid, 0);
36  const CSCChamber* cscChamberME1b(csc_g->chamber(me1bId));
37  const CSCChamber* cscChamberME1a(csc_g->chamber(me1aId));
38  const CSCLayer* keyLayerME1b(cscChamberME1b->layer(3));
39  const CSCLayer* keyLayerME1a(cscChamberME1a->layer(3));
40 
41  // GEM trigger geometry
42  const int region((theEndcap == 1) ? 1 : -1);
43  const GEMDetId gem_id_l1(region, 1, 1, 1, me1bId.chamber(), 0);
44  const GEMDetId gem_id_l2(region, 1, 1, 2, me1bId.chamber(), 0);
45  const GEMChamber* gemChamber_l1(gem_g->chamber(gem_id_l1));
46  const GEMChamber* gemChamber_l2(gem_g->chamber(gem_id_l2));
47  const GEMEtaPartition* randRoll(gemChamber_l1->etaPartition(4));
48 
49  // LUTs
50  std::vector<std::pair<double, double> > gemRollEtaLimits_l1;
51  std::vector<std::pair<double, double> > gemRollEtaLimits_l2;
52  std::vector<std::pair<double, double> > cscWGToEtaLimits;
53  std::vector<std::pair<int, int> > cscWgToGemRoll_l1;
54  std::vector<std::pair<int, int> > cscWgToGemRoll_l2;
55  std::vector<std::pair<int, int> > cscHsToGemPadME1a;
56  std::vector<std::pair<int, int> > cscHsToGemPadME1b;
57  std::vector<int> gemPadToCscHsME1a;
58  std::vector<int> gemPadToCscHsME1b;
59  std::vector<int> gemRollToCscWg1b;
60 
61  gemRollToEtaLimitsLUT(gemChamber_l1, gemRollEtaLimits_l1);
62  gemRollToEtaLimitsLUT(gemChamber_l2, gemRollEtaLimits_l2);
63  cscWgToEtaLimitsLUT(keyLayerME1b, cscWGToEtaLimits);
64  cscWgToRollLUT(cscWGToEtaLimits, gemRollEtaLimits_l1, cscWgToGemRoll_l1);
65  cscWgToRollLUT(cscWGToEtaLimits, gemRollEtaLimits_l2, cscWgToGemRoll_l2);
66  cscHsToGemPadLUT(keyLayerME1a, randRoll, 2, 94, cscHsToGemPadME1a);
67  cscHsToGemPadLUT(keyLayerME1b, randRoll, 4, 124, cscHsToGemPadME1b);
68  gemPadToCscHsLUT(keyLayerME1a, randRoll, gemPadToCscHsME1a);
69  gemPadToCscHsLUT(keyLayerME1b, randRoll, gemPadToCscHsME1b);
70  gemRollToCscWgLUT(keyLayerME1b, gemChamber_l1, gemRollToCscWg1b);
71 
72  // print LUTs
73  std::stringstream os;
74  os << "ME11 " << me1bId << std::endl;
75 
76  os << "GEM L1 roll to eta limits" << std::endl;
77  os << gemRollEtaLimits_l1;
78 
79  os << "GEM L2 roll to eta limits" << std::endl;
80  os << gemRollEtaLimits_l2;
81 
82  os << "ME1b " << me1bId << std::endl;
83  os << "WG roll to eta limits" << std::endl;
84  os << cscWGToEtaLimits;
85 
86  os << "WG to Roll L1" << std::endl;
87  os << cscWgToGemRoll_l1;
88 
89  os << "WG to Roll L2" << std::endl;
90  os << cscWgToGemRoll_l2;
91 
92  os << "CSC HS to GEM pad LUT in ME1a" << std::endl;
93  os << cscHsToGemPadME1a;
94 
95  os << "CSC HS to GEM pad LUT in ME1b" << std::endl;
96  os << cscHsToGemPadME1b;
97 
98  os << "GEM pad to CSC HS LUT in ME1a" << std::endl;
99  os << gemPadToCscHsME1a;
100 
101  os << "GEM pad to CSC HS LUT in ME1b" << std::endl;
102  os << gemPadToCscHsME1b;
103 
104  os << "GEM roll to CSC WG" << std::endl;
105  os << gemRollToCscWg1b;
106 
107  // print LUTs
108  LogTrace("CSCUpgradeMotherboardLUTGenerator") << os.str();
109 }

References CSCDetId::chamber(), CSCGeometry::chamber(), GEMGeometry::chamber(), CSCTriggerNumbering::chamberFromTriggerLabels(), csc_g, cscHsToGemPadLUT(), cscWgToEtaLimitsLUT(), cscWgToRollLUT(), gem_g, gemPadToCscHsLUT(), gemRollToCscWgLUT(), gemRollToEtaLimitsLUT(), LogTrace, and HLT_2018_cff::region.

Referenced by generateLUTs().

◆ generateLUTsME21()

void CSCUpgradeMotherboardLUTGenerator::generateLUTsME21 ( unsigned  e,
unsigned  se,
unsigned  sb,
unsigned  c 
) const

Definition at line 111 of file CSCUpgradeMotherboardLUTGenerator.cc.

114  {
115  bool gemGeometryAvailable(false);
116  if (gem_g != nullptr) {
117  LogTrace("CSCUpgradeMotherboardLUTGenerator") << "+++ generateLUTsME11() called for ME21 chamber! +++ \n";
118  gemGeometryAvailable = true;
119  }
120 
121  // check for GEM geometry
122  if (not gemGeometryAvailable) {
123  LogTrace("CSCUpgradeMotherboardLUTGenerator")
124  << "+++ generateLUTsME21() called for ME21 chamber without valid GEM geometry! +++ \n";
125  return;
126  }
127 
128  // CSC trigger geometry
129  const int chid = CSCTriggerNumbering::chamberFromTriggerLabels(theSector, theSubsector, 2, theTrigChamber);
130  const CSCDetId csc_id(theEndcap, 2, 1, chid, 0);
131  const CSCChamber* cscChamber(csc_g->chamber(csc_id));
132  const CSCLayer* keyLayer(cscChamber->layer(3));
133 
134  // GEM trigger geometry
135  const int region((theEndcap == 1) ? 1 : -1);
136  const GEMDetId gem_id_l1(region, 1, 2, 1, csc_id.chamber(), 0);
137  const GEMDetId gem_id_l2(region, 1, 2, 2, csc_id.chamber(), 0);
138  const GEMChamber* gemChamber_l1(gem_g->chamber(gem_id_l1));
139  const GEMChamber* gemChamber_l2(gem_g->chamber(gem_id_l2));
140  const GEMEtaPartition* randRoll(gemChamber_l1->etaPartition(4));
141 
142  // LUTs
143  std::vector<std::pair<double, double> > gemRollEtaLimits_l1;
144  std::vector<std::pair<double, double> > gemRollEtaLimits_l2;
145  std::vector<std::pair<double, double> > cscWGToEtaLimits;
146  std::vector<std::pair<int, int> > cscWgToGemRoll_l1;
147  std::vector<std::pair<int, int> > cscWgToGemRoll_l2;
148  std::vector<std::pair<int, int> > cscHsToGemPad;
149  std::vector<int> gemPadToCscHs;
150  std::vector<int> gemRollToCscWg;
151 
152  gemRollToEtaLimitsLUT(gemChamber_l1, gemRollEtaLimits_l1);
153  gemRollToEtaLimitsLUT(gemChamber_l2, gemRollEtaLimits_l2);
154  cscWgToEtaLimitsLUT(keyLayer, cscWGToEtaLimits);
155  cscWgToRollLUT(cscWGToEtaLimits, gemRollEtaLimits_l1, cscWgToGemRoll_l1);
156  cscWgToRollLUT(cscWGToEtaLimits, gemRollEtaLimits_l2, cscWgToGemRoll_l2);
157  cscHsToGemPadLUT(keyLayer, randRoll, 4, 155, cscHsToGemPad);
158  gemPadToCscHsLUT(keyLayer, randRoll, gemPadToCscHs);
159  gemRollToCscWgLUT(keyLayer, gemChamber_l1, gemRollToCscWg);
160 
161  std::stringstream os;
162  os << "ME21 " << csc_id << std::endl;
163 
164  os << "GEM roll to eta limits L1" << std::endl;
165  os << gemRollEtaLimits_l1;
166 
167  os << "GEM roll to eta limits L2" << std::endl;
168  os << gemRollEtaLimits_l2;
169 
170  os << "WG to eta limits" << std::endl;
171  os << cscWGToEtaLimits;
172 
173  os << "WG to Roll L1" << std::endl;
174  os << cscWgToGemRoll_l1;
175 
176  os << "WG to Roll L2" << std::endl;
177  os << cscWgToGemRoll_l2;
178 
179  os << "CSC HS to GEM pad LUT in ME21" << std::endl;
180  os << cscHsToGemPad;
181 
182  os << "GEM pad to CSC HS LUT in ME21" << std::endl;
183  os << gemPadToCscHs;
184 
185  os << "GEM roll to CSC WG" << std::endl;
186  os << gemRollToCscWg;
187 
188  // print LUTs
189  LogTrace("CSCUpgradeMotherboardLUTGenerator") << os.str();
190 }

References CSCDetId::chamber(), CSCGeometry::chamber(), GEMGeometry::chamber(), CSCTriggerNumbering::chamberFromTriggerLabels(), csc_g, cscHsToGemPadLUT(), cscWgToEtaLimitsLUT(), cscWgToRollLUT(), gem_g, gemPadToCscHsLUT(), gemRollToCscWgLUT(), gemRollToEtaLimitsLUT(), LogTrace, and HLT_2018_cff::region.

Referenced by generateLUTs().

◆ setCSCGeometry()

void CSCUpgradeMotherboardLUTGenerator::setCSCGeometry ( const CSCGeometry *  g)
inline

set CSC and GEM geometries for the matching needs

Definition at line 17 of file CSCUpgradeMotherboardLUTGenerator.h.

17 { csc_g = g; }

References csc_g, and g.

◆ setGEMGeometry()

void CSCUpgradeMotherboardLUTGenerator::setGEMGeometry ( const GEMGeometry *  g)
inline

Definition at line 18 of file CSCUpgradeMotherboardLUTGenerator.h.

18 { gem_g = g; }

References g, and gem_g.

Member Data Documentation

◆ csc_g

const CSCGeometry* CSCUpgradeMotherboardLUTGenerator::csc_g
private

Definition at line 48 of file CSCUpgradeMotherboardLUTGenerator.h.

Referenced by generateLUTsME11(), generateLUTsME21(), and setCSCGeometry().

◆ gem_g

const GEMGeometry* CSCUpgradeMotherboardLUTGenerator::gem_g
private

Definition at line 49 of file CSCUpgradeMotherboardLUTGenerator.h.

Referenced by generateLUTsME11(), generateLUTsME21(), and setGEMGeometry().

DDAxes::y
ALCARECOTkAlBeamHalo_cff.etaMin
etaMin
GeV.
Definition: ALCARECOTkAlBeamHalo_cff.py:32
mps_fire.i
i
Definition: mps_fire.py:355
CSCUpgradeMotherboardLUTGenerator::generateLUTsME21
void generateLUTsME21(unsigned e, unsigned se, unsigned sb, unsigned c) const
Definition: CSCUpgradeMotherboardLUTGenerator.cc:111
min
T min(T a, T b)
Definition: MathUtil.h:58
digitizers_cfi.strip
strip
Definition: digitizers_cfi.py:19
AlCaHLTBitMon_ParallelJobs.p
p
Definition: AlCaHLTBitMon_ParallelJobs.py:153
GEMEtaPartition
Definition: GEMEtaPartition.h:12
CSCUpgradeMotherboardLUTGenerator::gemPadToCscHsLUT
void gemPadToCscHsLUT(const CSCLayer *, const GEMEtaPartition *, std::vector< int > &) const
Definition: CSCUpgradeMotherboardLUTGenerator.cc:263
CSCLayer
Definition: CSCLayer.h:24
DDAxes::x
CSCUpgradeMotherboardLUTGenerator::csc_g
const CSCGeometry * csc_g
Definition: CSCUpgradeMotherboardLUTGenerator.h:48
CSCUpgradeMotherboardLUTGenerator::gem_g
const GEMGeometry * gem_g
Definition: CSCUpgradeMotherboardLUTGenerator.h:49
reco::ceil
constexpr int32_t ceil(float num)
Definition: constexpr_cmath.h:7
PVValHelper::eta
Definition: PVValidationHelpers.h:69
CSCLayerGeometry
Definition: CSCLayerGeometry.h:25
DDAxes::z
maxEta
double maxEta
Definition: PFJetBenchmarkAnalyzer.cc:76
CSCChamber
Definition: CSCChamber.h:22
GEMEtaPartition::pad
float pad(const LocalPoint &lp) const
returns FRACTIONAL pad number [0.,npads) for a point
Definition: GEMEtaPartition.cc:52
CSCLayer::geometry
const CSCLayerGeometry * geometry() const
Definition: CSCLayer.h:44
Point3DBase< float, LocalTag >
GeomDet::toLocal
LocalPoint toLocal(const GlobalPoint &gp) const
Conversion to the R.F. of the GeomDet.
Definition: GeomDet.h:58
runTauDisplay.gp
gp
Definition: runTauDisplay.py:431
GEMChamber::etaPartitions
const std::vector< const GEMEtaPartition * > & etaPartitions() const
Return the eta partitions.
Definition: GEMChamber.cc:29
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
CSCUpgradeMotherboardLUTGenerator::cscWgToRollLUT
void cscWgToRollLUT(const std::vector< std::pair< double, double > > &, const std::vector< std::pair< double, double > > &, std::vector< std::pair< int, int > > &) const
Definition: CSCUpgradeMotherboardLUTGenerator.cc:222
SiStripPI::max
Definition: SiStripPayloadInspectorHelper.h:169
GEMDetId
Definition: GEMDetId.h:17
CSCDetId
Definition: CSCDetId.h:26
CSCUpgradeMotherboardLUTGenerator::gemRollToCscWgLUT
void gemRollToCscWgLUT(const CSCLayer *, const GEMChamber *, std::vector< int > &) const
Definition: CSCUpgradeMotherboardLUTGenerator.cc:277
CSCUpgradeMotherboardLUTGenerator::cscHsToGemPadLUT
void cscHsToGemPadLUT(const CSCLayer *, const GEMEtaPartition *, int minH, int maxH, std::vector< std::pair< int, int > > &) const
Definition: CSCUpgradeMotherboardLUTGenerator.cc:247
CSCTriggerNumbering::chamberFromTriggerLabels
static int chamberFromTriggerLabels(int TriggerSector, int TriggerSubSector, int station, int TriggerCSCID)
Definition: CSCTriggerNumbering.cc:30
CSCUpgradeMotherboardLUTGenerator::generateLUTsME11
void generateLUTsME11(unsigned e, unsigned se, unsigned sb, unsigned c) const
Definition: CSCUpgradeMotherboardLUTGenerator.cc:15
me0TriggerPseudoDigis_cff.nStrips
nStrips
1.2 is to make the matching window safely the two nearest strips 0.35 is the size of an ME0 chamber i...
Definition: me0TriggerPseudoDigis_cff.py:26
GEMEtaPartition::centreOfPad
LocalPoint centreOfPad(int pad) const
Definition: GEMEtaPartition.cc:45
GEMChamber
Definition: GEMChamber.h:19
GEMEtaPartition::npads
int npads() const
number of GEM-CSC trigger readout pads in partition
Definition: GEMEtaPartition.cc:43
CSCUpgradeMotherboardLUTGenerator::cscWgToEtaLimitsLUT
void cscWgToEtaLimitsLUT(const CSCLayer *, std::vector< std::pair< double, double > > &) const
Definition: CSCUpgradeMotherboardLUTGenerator.cc:232
CSCUpgradeMotherboardLUTGenerator::gemRollToEtaLimitsLUT
void gemRollToEtaLimitsLUT(const GEMChamber *c, std::vector< std::pair< double, double > > &) const
Definition: CSCUpgradeMotherboardLUTGenerator.cc:208
CSCUpgradeMotherboardLUTGenerator::assignRoll
int assignRoll(const std::vector< std::pair< double, double > > &, double eta) const
Definition: CSCUpgradeMotherboardLUTGenerator.cc:192
HLT_2018_cff.region
region
Definition: HLT_2018_cff.py:81479
ALCARECOTkAlBeamHalo_cff.etaMax
etaMax
Definition: ALCARECOTkAlBeamHalo_cff.py:33
mps_fire.result
result
Definition: mps_fire.py:303
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:671
GEMGeometry::chamber
const GEMChamber * chamber(GEMDetId id) const
Definition: GEMGeometry.cc:73
EgHLTOffEleSelection_cfi.minEta
minEta
Definition: EgHLTOffEleSelection_cfi.py:11
CSCGeometry::chamber
const CSCChamber * chamber(CSCDetId id) const
Return the chamber corresponding to given DetId.
Definition: CSCGeometry.cc:100
g
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 g
Definition: Activities.doc:4
Generated for CMSSW Reference Manual by doxygen 1.8.16