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 ( )
inline

Definition at line 13 of file CSCUpgradeMotherboardLUTGenerator.h.

13 {}
CSCUpgradeMotherboardLUTGenerator::~CSCUpgradeMotherboardLUTGenerator ( )
inline

Definition at line 14 of file CSCUpgradeMotherboardLUTGenerator.h.

14 {}

Member Function Documentation

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

Definition at line 192 of file CSCUpgradeMotherboardLUTGenerator.cc.

References funct::abs(), maxEta, ticl::constants::minEta, AlCaHLTBitMon_ParallelJobs::p, and mps_fire::result.

Referenced by cscWgToRollLUT(), and setGEMGeometry().

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 }
AlCaHLTBitMon_ParallelJobs.p
p
Definition: AlCaHLTBitMon_ParallelJobs.py:153
mps_fire.result
result
Definition: mps_fire.py:294
ticl::constants::minEta
constexpr float minEta
Definition: Common.h:9
maxEta
double maxEta
Definition: PFJetBenchmarkAnalyzer.cc:76
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
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.

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

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

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 }
mps_fire.i
i
Definition: mps_fire.py:341
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
GeomDet::toLocal
LocalPoint toLocal(const GlobalPoint &gp) const
Conversion to the R.F. of the GeomDet.
Definition: GeomDet.h:58
hgcaltilesconstants::ceil
constexpr int32_t ceil(float num)
Definition: HGCalTilesConstants.h:12
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::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
void CSCUpgradeMotherboardLUTGenerator::cscWgToEtaLimitsLUT ( const CSCLayer *  keyLayer,
std::vector< std::pair< double, double > > &  lut 
) const
private

Definition at line 232 of file CSCUpgradeMotherboardLUTGenerator.cc.

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

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

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 }
mps_fire.i
i
Definition: mps_fire.py:341
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
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
min
T min(T a, T b)
Definition: MathUtil.h:58
CSCLayer::geometry
const CSCLayerGeometry * geometry() const
Definition: CSCLayer.h:44
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.

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

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

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 }
AlCaHLTBitMon_ParallelJobs.p
p
Definition: AlCaHLTBitMon_ParallelJobs.py:153
ALCARECOTkAlBeamHalo_cff.etaMin
etaMin
GeV.
Definition: ALCARECOTkAlBeamHalo_cff.py:32
CSCUpgradeMotherboardLUTGenerator::assignRoll
int assignRoll(const std::vector< std::pair< double, double > > &, double eta) const
Definition: CSCUpgradeMotherboardLUTGenerator.cc:192
ALCARECOTkAlBeamHalo_cff.etaMax
etaMax
Definition: ALCARECOTkAlBeamHalo_cff.py:33
void CSCUpgradeMotherboardLUTGenerator::gemPadToCscHsLUT ( const CSCLayer *  keyLayer,
const GEMEtaPartition *  randRoll,
std::vector< int > &  lut 
) const
private

Definition at line 263 of file CSCUpgradeMotherboardLUTGenerator.cc.

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

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

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 }
mps_fire.i
i
Definition: mps_fire.py:341
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
GeomDet::toLocal
LocalPoint toLocal(const GlobalPoint &gp) const
Conversion to the R.F. of the GeomDet.
Definition: GeomDet.h:58
GEMEtaPartition::npads
int npads() const
number of GEM-CSC trigger readout pads in partition
Definition: GEMEtaPartition.cc:43
digitizers_cfi.strip
strip
Definition: digitizers_cfi.py:19
GEMEtaPartition::centreOfPad
LocalPoint centreOfPad(int pad) const
Definition: GEMEtaPartition.cc:45
CSCLayer::geometry
const CSCLayerGeometry * geometry() const
Definition: CSCLayer.h:44
void CSCUpgradeMotherboardLUTGenerator::gemRollToCscWgLUT ( const CSCLayer *  keyLayer,
const GEMChamber *  gemChamber,
std::vector< int > &  lut 
) const
private

Definition at line 277 of file CSCUpgradeMotherboardLUTGenerator.cc.

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

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

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 }
GeomDet::toLocal
LocalPoint toLocal(const GlobalPoint &gp) const
Conversion to the R.F. of the GeomDet.
Definition: GeomDet.h:58
GEMChamber::etaPartitions
const std::vector< const GEMEtaPartition * > & etaPartitions() const
Return the eta partitions.
Definition: GEMChamber.cc:29
CSCLayer::geometry
const CSCLayerGeometry * geometry() const
Definition: CSCLayer.h:44
void CSCUpgradeMotherboardLUTGenerator::gemRollToEtaLimitsLUT ( const GEMChamber *  c,
std::vector< std::pair< double, double > > &  lut 
) const
private

Definition at line 208 of file CSCUpgradeMotherboardLUTGenerator.cc.

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

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

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 }
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
min
T min(T a, T b)
Definition: MathUtil.h:58
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.

References generateLUTsME11(), and generateLUTsME21().

Referenced by setGEMGeometry().

8  {
9  if (theStation == 1)
10  generateLUTsME11(theEndcap, theSector, theSubsector, theTrigChamber);
11  if (theStation == 2)
12  generateLUTsME21(theEndcap, theSector, theSubsector, theTrigChamber);
13 }
CSCUpgradeMotherboardLUTGenerator::generateLUTsME21
void generateLUTsME21(unsigned e, unsigned se, unsigned sb, unsigned c) const
Definition: CSCUpgradeMotherboardLUTGenerator.cc:111
CSCUpgradeMotherboardLUTGenerator::generateLUTsME11
void generateLUTsME11(unsigned e, unsigned se, unsigned sb, unsigned c) const
Definition: CSCUpgradeMotherboardLUTGenerator.cc:15
void CSCUpgradeMotherboardLUTGenerator::generateLUTsME11 ( unsigned  e,
unsigned  se,
unsigned  sb,
unsigned  c 
) const

Definition at line 15 of file CSCUpgradeMotherboardLUTGenerator.cc.

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(), and setGEMGeometry().

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 }
CSCUpgradeMotherboardLUTGenerator::gemRollToCscWgLUT
void gemRollToCscWgLUT(const CSCLayer *, const GEMChamber *, std::vector< int > &) const
Definition: CSCUpgradeMotherboardLUTGenerator.cc:277
HLT_2018_cff.region
region
Definition: HLT_2018_cff.py:81376
CSCUpgradeMotherboardLUTGenerator::cscHsToGemPadLUT
void cscHsToGemPadLUT(const CSCLayer *, const GEMEtaPartition *, int minH, int maxH, std::vector< std::pair< int, int > > &) const
Definition: CSCUpgradeMotherboardLUTGenerator.cc:247
CSCUpgradeMotherboardLUTGenerator::gemRollToEtaLimitsLUT
void gemRollToEtaLimitsLUT(const GEMChamber *c, std::vector< std::pair< double, double > > &) const
Definition: CSCUpgradeMotherboardLUTGenerator.cc:208
CSCUpgradeMotherboardLUTGenerator::cscWgToEtaLimitsLUT
void cscWgToEtaLimitsLUT(const CSCLayer *, std::vector< std::pair< double, double > > &) const
Definition: CSCUpgradeMotherboardLUTGenerator.cc:232
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:671
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
GEMGeometry::chamber
const GEMChamber * chamber(GEMDetId id) const
Definition: GEMGeometry.cc:73
CSCGeometry::chamber
const CSCChamber * chamber(CSCDetId id) const
Return the chamber corresponding to given DetId.
Definition: CSCGeometry.cc:100
CSCUpgradeMotherboardLUTGenerator::gemPadToCscHsLUT
void gemPadToCscHsLUT(const CSCLayer *, const GEMEtaPartition *, std::vector< int > &) const
Definition: CSCUpgradeMotherboardLUTGenerator.cc:263
CSCTriggerNumbering::chamberFromTriggerLabels
static int chamberFromTriggerLabels(int TriggerSector, int TriggerSubSector, int station, int TriggerCSCID)
Definition: CSCTriggerNumbering.cc:30
void CSCUpgradeMotherboardLUTGenerator::generateLUTsME21 ( unsigned  e,
unsigned  se,
unsigned  sb,
unsigned  c 
) const

Definition at line 111 of file CSCUpgradeMotherboardLUTGenerator.cc.

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(), and setGEMGeometry().

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 }
CSCUpgradeMotherboardLUTGenerator::gemRollToCscWgLUT
void gemRollToCscWgLUT(const CSCLayer *, const GEMChamber *, std::vector< int > &) const
Definition: CSCUpgradeMotherboardLUTGenerator.cc:277
HLT_2018_cff.region
region
Definition: HLT_2018_cff.py:81376
CSCUpgradeMotherboardLUTGenerator::cscHsToGemPadLUT
void cscHsToGemPadLUT(const CSCLayer *, const GEMEtaPartition *, int minH, int maxH, std::vector< std::pair< int, int > > &) const
Definition: CSCUpgradeMotherboardLUTGenerator.cc:247
CSCUpgradeMotherboardLUTGenerator::gemRollToEtaLimitsLUT
void gemRollToEtaLimitsLUT(const GEMChamber *c, std::vector< std::pair< double, double > > &) const
Definition: CSCUpgradeMotherboardLUTGenerator.cc:208
CSCUpgradeMotherboardLUTGenerator::cscWgToEtaLimitsLUT
void cscWgToEtaLimitsLUT(const CSCLayer *, std::vector< std::pair< double, double > > &) const
Definition: CSCUpgradeMotherboardLUTGenerator.cc:232
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:671
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
GEMGeometry::chamber
const GEMChamber * chamber(GEMDetId id) const
Definition: GEMGeometry.cc:73
CSCGeometry::chamber
const CSCChamber * chamber(CSCDetId id) const
Return the chamber corresponding to given DetId.
Definition: CSCGeometry.cc:100
CSCUpgradeMotherboardLUTGenerator::gemPadToCscHsLUT
void gemPadToCscHsLUT(const CSCLayer *, const GEMEtaPartition *, std::vector< int > &) const
Definition: CSCUpgradeMotherboardLUTGenerator.cc:263
CSCTriggerNumbering::chamberFromTriggerLabels
static int chamberFromTriggerLabels(int TriggerSector, int TriggerSubSector, int station, int TriggerCSCID)
Definition: CSCTriggerNumbering.cc:30
void CSCUpgradeMotherboardLUTGenerator::setCSCGeometry ( const CSCGeometry *  g)
inline

set CSC and GEM geometries for the matching needs

Definition at line 17 of file CSCUpgradeMotherboardLUTGenerator.h.

References csc_g, and g.

17 { csc_g = g; }
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
void CSCUpgradeMotherboardLUTGenerator::setGEMGeometry ( const GEMGeometry *  g)
inline

Definition at line 18 of file CSCUpgradeMotherboardLUTGenerator.h.

References assignRoll(), HltBtagPostValidation_cff::c, cscHsToGemPadLUT(), cscWgToEtaLimitsLUT(), cscWgToRollLUT(), MillePedeFileConverter_cfg::e, PVValHelper::eta, g, gem_g, gemPadToCscHsLUT(), gemRollToCscWgLUT(), gemRollToEtaLimitsLUT(), generateLUTs(), generateLUTsME11(), generateLUTsME21(), and alignCSCRings::s.

18 { gem_g = g; }
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

Member Data Documentation

const CSCGeometry* CSCUpgradeMotherboardLUTGenerator::csc_g
private

Definition at line 48 of file CSCUpgradeMotherboardLUTGenerator.h.

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

const GEMGeometry* CSCUpgradeMotherboardLUTGenerator::gem_g
private

Definition at line 49 of file CSCUpgradeMotherboardLUTGenerator.h.

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

Generated for CMSSW Reference Manual by doxygen 1.8.11