CMS 3D CMS Logo

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
CSCGEMMotherboard.cc
Go to the documentation of this file.
2 
4  unsigned station,
5  unsigned sector,
6  unsigned subsector,
7  unsigned chamber,
8  const edm::ParameterSet& conf)
9  : CSCUpgradeMotherboard(endcap, station, sector, subsector, chamber, conf),
10  maxDeltaBXPad_(tmbParams_.getParameter<int>("maxDeltaBXPad")),
11  maxDeltaBXCoPad_(tmbParams_.getParameter<int>("maxDeltaBXCoPad")),
12  useOldLCTDataFormat_(tmbParams_.getParameter<bool>("useOldLCTDataFormat")),
13  promoteALCTGEMpattern_(tmbParams_.getParameter<bool>("promoteALCTGEMpattern")),
14  promoteALCTGEMquality_(tmbParams_.getParameter<bool>("promoteALCTGEMquality")),
15  doLCTGhostBustingWithGEMs_(tmbParams_.getParameter<bool>("doLCTGhostBustingWithGEMs")) {
16  // super chamber has layer=0!
18 
19  const edm::ParameterSet coPadParams(station == 1 ? conf.getParameter<edm::ParameterSet>("copadParamGE11")
20  : conf.getParameter<edm::ParameterSet>("copadParamGE21"));
22 
23  maxDeltaPadL1_ = (theParity ? tmbParams_.getParameter<int>("maxDeltaPadL1Even")
24  : tmbParams_.getParameter<int>("maxDeltaPadL1Odd"));
25  maxDeltaPadL2_ = (theParity ? tmbParams_.getParameter<int>("maxDeltaPadL2Even")
26  : tmbParams_.getParameter<int>("maxDeltaPadL2Odd"));
27 }
28 
30 
32 
35  pads_.clear();
36  coPads_.clear();
37 }
38 
40  const CSCComparatorDigiCollection* compdc,
41  const GEMPadDigiClusterCollection* gemClusters) {
42  std::unique_ptr<GEMPadDigiCollection> gemPads(new GEMPadDigiCollection());
43  coPadProcessor->declusterize(gemClusters, *gemPads);
44  run(wiredc, compdc, gemPads.get());
45 }
46 
47 void CSCGEMMotherboard::retrieveGEMPads(const GEMPadDigiCollection* gemPads, unsigned id) {
48  pads_.clear();
49  auto superChamber(gem_g->superChamber(id));
50  for (const auto& ch : superChamber->chambers()) {
51  for (const auto& roll : ch->etaPartitions()) {
52  GEMDetId roll_id(roll->id());
53  auto pads_in_det = gemPads->get(roll_id);
54  for (auto pad = pads_in_det.first; pad != pads_in_det.second; ++pad) {
55  const int bx_shifted(CSCConstants::LCT_CENTRAL_BX + pad->bx());
56  // consider matches with BX difference +1/0/-1
57  for (int bx = bx_shifted - maxDeltaBXPad_; bx <= bx_shifted + maxDeltaBXPad_; ++bx) {
58  pads_[bx].emplace_back(roll_id.rawId(), *pad);
59  }
60  }
61  }
62  }
63 }
64 
66  coPads_.clear();
67  for (const auto& copad : gemCoPadV) {
68  GEMDetId detId(theRegion, 1, theStation, 0, theChamber, 0);
69  // only consider matches with same BX
70  coPads_[CSCConstants::LCT_CENTRAL_BX + copad.bx(1)].emplace_back(detId.rawId(), copad);
71  }
72 }
73 
75  const GEMCoPadDigi& gem,
76  int trknmb) const {
77  return constructLCTsGEM(alct, CSCCLCTDigi(), GEMPadDigi(), gem, trknmb);
78 }
79 
81  const GEMCoPadDigi& gem,
82  int trknmb) const {
83  return constructLCTsGEM(CSCALCTDigi(), clct, GEMPadDigi(), gem, trknmb);
84 }
85 
87  const CSCCLCTDigi& clct,
88  const GEMCoPadDigi& gem,
89  int trknmb) const {
90  return constructLCTsGEM(alct, clct, GEMPadDigi(), gem, trknmb);
91 }
92 
94  const CSCCLCTDigi& clct,
95  const GEMPadDigi& gem,
96  int trknmb) const {
97  return constructLCTsGEM(alct, clct, gem, GEMCoPadDigi(), trknmb);
98 }
99 
101  const CSCCLCTDigi& clct,
102  const GEMPadDigi& gem1,
103  const GEMCoPadDigi& gem2,
104  int trknmb) const {
105  int pattern = 0, quality = 0, bx = 0, keyStrip = 0, keyWG = 0, bend = 0, valid = 0;
106 
107  // make a new LCT
108  CSCCorrelatedLCTDigi thisLCT;
109  if (not alct.isValid() and not clct.isValid()) {
110  LogTrace("CSCGEMCMotherboard") << "Warning!!! either ALCT or CLCT not valid, return invalid LCT \n";
111  return thisLCT;
112  }
113 
114  // Determine the case and assign properties depending on the LCT dataformat (old/new)
115  if (alct.isValid() and clct.isValid() and gem1.isValid() and not gem2.isValid()) {
116  pattern = encodePattern(clct.getPattern());
117  quality = findQualityGEM(alct, clct, 1);
118  bx = alct.getBX();
119  keyStrip = clct.getKeyStrip();
120  keyWG = alct.getKeyWG();
121  bend = clct.getBend();
122  thisLCT.setALCT(getBXShiftedALCT(alct));
123  thisLCT.setCLCT(getBXShiftedCLCT(clct));
124  thisLCT.setGEM1(gem1);
126  valid = doesWiregroupCrossStrip(keyWG, keyStrip) ? 1 : 0;
127  } else if (alct.isValid() and clct.isValid() and not gem1.isValid() and gem2.isValid()) {
128  pattern = encodePattern(clct.getPattern());
129  quality = findQualityGEM(alct, clct, 2);
130  bx = alct.getBX();
131  keyStrip = clct.getKeyStrip();
132  keyWG = alct.getKeyWG();
133  bend = clct.getBend();
134  thisLCT.setALCT(getBXShiftedALCT(alct));
135  thisLCT.setCLCT(getBXShiftedCLCT(clct));
136  thisLCT.setGEM1(gem2.first());
137  thisLCT.setGEM2(gem2.second());
139  valid = doesWiregroupCrossStrip(keyWG, keyStrip) ? 1 : 0;
140  } else if (alct.isValid() and gem2.isValid() and not clct.isValid()) {
141  //in ME11
142  //ME1b: keyWG >15,
143  //ME1a and ME1b overlap: 10<=keyWG<=15
144  //ME1a: keyWG < 10
145  //in overlap region, firstly try a match in ME1b
146 
147  auto p(getCSCPart(-1)); //use -1 as fake halfstrip, it returns ME11 if station==1 && (ring==1 or ring==4)
148  if (p == CSCPart::ME11) {
149  if (alct.getKeyWG() >= 10)
150  p = CSCPart::ME1B;
151  else
152  p = CSCPart::ME1A;
153  }
154 
155  const auto& mymap1 = getLUT()->get_gem_pad_to_csc_hs(theParity, p);
156  // GEM pad number is counting from 1
157  // keyStrip from mymap: for ME1b 0-127 and for ME1a 0-95
158  // keyStrip for CLCT: for ME1b 0-127 and for ME1a 128-223
159  keyStrip = mymap1[gem2.pad(2) - 1];
160  if (p == CSCPart::ME1A and keyStrip <= CSCConstants::MAX_HALF_STRIP_ME1B)
161  keyStrip += CSCConstants::MAX_HALF_STRIP_ME1B + 1;
162  keyWG = alct.getKeyWG();
163 
164  if ((not doesWiregroupCrossStrip(keyWG, keyStrip)) and p == CSCPart::ME1B and keyWG <= 15) {
165  //try ME1A as strip and WG do not cross
166  p = CSCPart::ME1A;
167  const auto& mymap2 = getLUT()->get_gem_pad_to_csc_hs(theParity, p);
168  keyStrip = mymap2[gem2.pad(2) - 1] + CSCConstants::MAX_HALF_STRIP_ME1B + 1;
169  }
170 
171  pattern = promoteALCTGEMpattern_ ? 10 : 0;
172  quality = promoteALCTGEMquality_ ? 15 : 11;
173  bx = alct.getBX();
174  thisLCT.setALCT(getBXShiftedALCT(alct));
175  thisLCT.setGEM1(gem2.first());
176  thisLCT.setGEM2(gem2.second());
178  valid = true;
179  } else if (clct.isValid() and gem2.isValid() and not alct.isValid()) {
180  const auto& mymap2 = getLUT()->get_gem_roll_to_csc_wg(theParity);
181  pattern = encodePattern(clct.getPattern());
182  quality = promoteCLCTGEMquality_ ? 15 : 11;
183  bx = gem2.bx(1) + CSCConstants::LCT_CENTRAL_BX;
184  keyStrip = clct.getKeyStrip();
185  // choose the corresponding wire-group in the middle of the partition
186  keyWG = mymap2[gem2.roll()];
187  bend = clct.getBend();
188  thisLCT.setCLCT(clct);
189  thisLCT.setGEM1(gem2.first());
190  thisLCT.setGEM2(gem2.second());
192  valid = true;
193  }
194 
195  if (valid == 0)
196  LogTrace("CSCGEMCMotherboard") << "Warning!!! wiregroup and strip pair are not crossing each other"
197  << " detid " << cscId_ << " with wiregroup " << keyWG << "keyStrip " << keyStrip
198  << " \n";
199 
200  // fill the rest of the properties
201  thisLCT.setTrknmb(trknmb);
202  thisLCT.setValid(valid);
203  thisLCT.setQuality(quality);
204  thisLCT.setWireGroup(keyWG);
205  thisLCT.setStrip(keyStrip);
206  thisLCT.setPattern(pattern);
207  thisLCT.setBend(bend);
208  thisLCT.setBX(bx);
209  thisLCT.setMPCLink(0);
210  thisLCT.setBX0(0);
211  thisLCT.setSyncErr(0);
212  thisLCT.setCSCID(theTrigChamber);
213 
214  // future work: add a section that produces LCTs according
215  // to the new LCT dataformat (not yet defined)
216 
217  // return new LCT
218  return thisLCT;
219 }
220 
221 bool CSCGEMMotherboard::isPadInOverlap(int roll) const {
222  // this only works for ME1A!
223  const auto& mymap = (getLUT()->get_csc_wg_to_gem_roll(theParity));
224  for (unsigned i = 0; i < mymap.size(); i++) {
225  // overlap region are WGs 10-15
226  if ((i < 10) or (i > 15))
227  continue;
228  if ((mymap[i].first <= roll) and (roll <= mymap[i].second))
229  return true;
230  }
231  return false;
232 }
233 
234 bool CSCGEMMotherboard::isGEMDetId(unsigned int p) const {
235  return (DetId(p).subdetId() == MuonSubdetId::GEM and DetId(p).det() == DetId::Muon);
236 }
237 
238 int CSCGEMMotherboard::getBX(const GEMPadDigi& p) const { return p.bx(); }
239 
240 int CSCGEMMotherboard::getBX(const GEMCoPadDigi& p) const { return p.bx(1); }
241 
242 int CSCGEMMotherboard::getRoll(const GEMPadDigiId& p) const { return GEMDetId(p.first).roll(); }
243 
244 int CSCGEMMotherboard::getRoll(const GEMCoPadDigiId& p) const { return p.second.roll(); }
245 
246 std::pair<int, int> CSCGEMMotherboard::getRolls(const CSCALCTDigi& alct) const {
247  return std::make_pair((getLUT()->get_csc_wg_to_gem_roll(theParity))[alct.getKeyWG()].first,
248  (getLUT()->get_csc_wg_to_gem_roll(theParity))[alct.getKeyWG()].second);
249 }
250 
251 float CSCGEMMotherboard::getPad(const GEMPadDigi& p) const { return p.pad(); }
252 
254  // average pad number for a GEMCoPad
255  return 0.5 * (p.pad(1) + p.pad(2));
256 }
257 
258 float CSCGEMMotherboard::getPad(const CSCCLCTDigi& clct, enum CSCPart part) const {
259  const auto& mymap = (getLUT()->get_csc_hs_to_gem_pad(theParity, part));
260  int keyStrip = clct.getKeyStrip();
261  //ME1A part, convert halfstrip from 128-223 to 0-95
262  if (part == CSCPart::ME1A and keyStrip > CSCConstants::MAX_HALF_STRIP_ME1B)
263  keyStrip = keyStrip - CSCConstants::MAX_HALF_STRIP_ME1B - 1;
264  return 0.5 * (mymap[keyStrip].first + mymap[keyStrip].second);
265 }
266 
269  generator_->setGEMGeometry(gem_g);
270 }
271 
272 void CSCGEMMotherboard::printGEMTriggerPads(int bx_start, int bx_stop, enum CSCPart part) {
273  LogTrace("CSCGEMMotherboard") << "------------------------------------------------------------------------"
274  << std::endl;
275  LogTrace("CSCGEMMotherboard") << "* GEM trigger pads: " << std::endl;
276 
277  for (int bx = bx_start; bx <= bx_stop; bx++) {
278  const auto& in_pads = pads_[bx];
279  LogTrace("CSCGEMMotherboard") << "N(pads) BX " << bx << " : " << in_pads.size() << std::endl;
280 
281  for (const auto& pad : in_pads) {
282  LogTrace("CSCGEMMotherboard") << "\tdetId " << GEMDetId(pad.first) << ", pad = " << pad.second;
283  const auto& roll_id(GEMDetId(pad.first));
284 
285  if (part == CSCPart::ME11 and isPadInOverlap(GEMDetId(roll_id).roll()))
286  LogTrace("CSCGEMMotherboard") << " (in overlap)" << std::endl;
287  else
288  LogTrace("CSCGEMMotherboard") << std::endl;
289  }
290  }
291 }
292 
293 void CSCGEMMotherboard::printGEMTriggerCoPads(int bx_start, int bx_stop, enum CSCPart part) {
294  LogTrace("CSCGEMMotherboard") << "------------------------------------------------------------------------"
295  << std::endl;
296  LogTrace("CSCGEMMotherboard") << "* GEM trigger coincidence pads: " << std::endl;
297 
298  for (int bx = bx_start; bx <= bx_stop; bx++) {
299  const auto& in_pads = coPads_[bx];
300  LogTrace("CSCGEMMotherboard") << "N(copads) BX " << bx << " : " << in_pads.size() << std::endl;
301 
302  for (const auto& pad : in_pads) {
303  LogTrace("CSCGEMMotherboard") << "\tdetId " << GEMDetId(pad.first) << ", pad = " << pad.second;
304  const auto& roll_id(GEMDetId(pad.first));
305 
306  if (part == CSCPart::ME11 and isPadInOverlap(GEMDetId(roll_id).roll()))
307  LogTrace("CSCGEMMotherboard") << " (in overlap)" << std::endl;
308  else
309  LogTrace("CSCGEMMotherboard") << std::endl;
310  }
311  }
312 }
313 
314 unsigned int CSCGEMMotherboard::findQualityGEM(const CSCALCTDigi& aLCT, const CSCCLCTDigi& cLCT, int gemlayers) const {
315  // Either ALCT or CLCT is invalid
316  if (!(aLCT.isValid()) || !(cLCT.isValid())) {
317  // No CLCT
318  if (aLCT.isValid() && !(cLCT.isValid()))
319  return LCT_Quality::NO_CLCT;
320 
321  // No ALCT
322  else if (!(aLCT.isValid()) && cLCT.isValid())
323  return LCT_Quality::NO_ALCT;
324 
325  // No ALCT and no CLCT
326  else
327  return LCT_Quality::INVALID;
328  }
329  // Both ALCT and CLCT are valid
330  else {
331  const int pattern(cLCT.getPattern());
332 
333  // Layer-trigger in CLCT
334  if (pattern == 1)
335  return LCT_Quality::CLCT_LAYER_TRIGGER;
336 
337  // Multi-layer pattern in CLCT
338  else {
339  // ALCT quality is the number of layers hit minus 3.
340  bool a4 = false;
341 
342  // Case of ME11 with GEMs: require 4 layers for ALCT
343  if (theStation == 1)
344  a4 = aLCT.getQuality() >= 1;
345 
346  // Case of ME21 with GEMs: require 4 layers for ALCT+GEM
347  if (theStation == 2)
348  a4 = aLCT.getQuality() + gemlayers >= 1;
349 
350  // CLCT quality is the number of layers hit.
351  const bool c4((cLCT.getQuality() >= 4) or (cLCT.getQuality() >= 3 and gemlayers >= 1));
352 
353  // quality = 4; "reserved for low-quality muons in future"
354 
355  // marginal anode and cathode
356  if (!a4 && !c4)
357  return LCT_Quality::MARGINAL_ANODE_CATHODE;
358 
359  // HQ anode, but marginal cathode
360  else if (a4 && !c4)
361  return LCT_Quality::HQ_ANODE_MARGINAL_CATHODE;
362 
363  // HQ cathode, but marginal anode
364  else if (!a4 && c4)
365  return LCT_Quality::HQ_CATHODE_MARGINAL_ANODE;
366 
367  // HQ muon, but accelerator ALCT
368  else if (a4 && c4) {
369  if (aLCT.getAccelerator())
370  return LCT_Quality::HQ_ACCEL_ALCT;
371 
372  else {
373  // quality = 9; "reserved for HQ muons with future patterns
374  // quality = 10; "reserved for HQ muons with future patterns
375 
376  // High quality muons are determined by their CLCT pattern
377  if (pattern == 2 || pattern == 3)
378  return LCT_Quality::HQ_PATTERN_2_3;
379 
380  else if (pattern == 4 || pattern == 5)
381  return LCT_Quality::HQ_PATTERN_4_5;
382 
383  else if (pattern == 6 || pattern == 7)
384  return LCT_Quality::HQ_PATTERN_6_7;
385 
386  else if (pattern == 8 || pattern == 9)
387  return LCT_Quality::HQ_PATTERN_8_9;
388 
389  else if (pattern == 10)
390  return LCT_Quality::HQ_PATTERN_10;
391 
392  else {
393  if (infoV >= 0)
394  edm::LogWarning("L1CSCTPEmulatorWrongValues")
395  << "+++ findQuality: Unexpected CLCT pattern id = " << pattern << "+++\n";
396  return LCT_Quality::INVALID;
397  }
398  }
399  }
400  }
401  }
402  return LCT_Quality::INVALID;
403 }
404 
405 template <>
406 const matchesBX<GEMPadDigi>& CSCGEMMotherboard::getPads<GEMPadDigi>() const {
407  return pads_;
408 }
409 
410 template <>
411 const matchesBX<GEMCoPadDigi>& CSCGEMMotherboard::getPads<GEMCoPadDigi>() const {
412  return coPads_;
413 }
414 
415 template <>
416 int CSCGEMMotherboard::getMaxDeltaBX<GEMPadDigi>() const {
417  return maxDeltaBXPad_;
418 }
419 
420 template <>
421 int CSCGEMMotherboard::getMaxDeltaBX<GEMCoPadDigi>() const {
422  return maxDeltaBXCoPad_;
423 }
424 
425 template <>
426 int CSCGEMMotherboard::getLctTrigEnable<CSCALCTDigi>() const {
427  return alct_trig_enable;
428 }
429 
430 template <>
431 int CSCGEMMotherboard::getLctTrigEnable<CSCCLCTDigi>() const {
432  return clct_trig_enable;
433 }
int getQuality() const
return quality of a pattern (number of layers hit!)
Definition: CSCCLCTDigi.h:41
bool isValid() const
Definition: GEMPadDigi.cc:22
void retrieveGEMPads(const GEMPadDigiCollection *pads, unsigned id)
T getParameter(std::string const &) const
match< GEMCoPadDigi > GEMCoPadDigiId
void setALCT(const CSCALCTDigi &alct)
void setGEM2(const GEMPadDigi &gem)
static constexpr int GEM
Definition: MuonSubdetId.h:14
unsigned int clct_trig_enable
void setWireGroup(unsigned int wiregroup)
set wiregroup number
void setBend(unsigned int b)
set bend
std::unique_ptr< CSCUpgradeMotherboardLUTGenerator > generator_
CSCALCTDigi getBXShiftedALCT(const CSCALCTDigi &) const
CSCCLCTDigi getBXShiftedCLCT(const CSCCLCTDigi &) const
bool isValid() const
check ALCT validity (1 - valid ALCT)
Definition: CSCALCTDigi.h:32
GEMCoPadDigiIdsBX coPads_
void setBX0(unsigned int b)
set bx0
int roll() const
Definition: GEMDetId.h:188
constexpr uint32_t rawId() const
get the raw id
Definition: DetId.h:57
void setQuality(unsigned int q)
set quality code
int getBX(const GEMPadDigi &p) const
static constexpr TimeType INVALID
Definition: Time.h:33
int pad(int l) const
Definition: GEMCoPadDigi.cc:20
virtual bool doesWiregroupCrossStrip(int key_wg, int key_strip) const
CSCDetId cscId_
Definition: CSCBaseboard.h:50
Definition: AMC13Event.h:6
std::vector< GEMCoPadDigi > gemCoPadV
int getBend() const
return bend
Definition: CSCCLCTDigi.h:59
void setMPCLink(const uint16_t &link)
Set mpc link number after MPC sorting.
U second(std::pair< T, U > const &p)
bool isValid() const
Definition: GEMCoPadDigi.cc:18
const unsigned theTrigChamber
Definition: CSCBaseboard.h:41
match< GEMPadDigi > GEMPadDigiId
void setPattern(unsigned int p)
set pattern
void setValid(unsigned int v)
set valid
std::unique_ptr< GEMCoPadProcessor > coPadProcessor
virtual void run(const CSCWireDigiCollection *wiredc, const CSCComparatorDigiCollection *compdc, const GEMPadDigiCollection *gemPads)=0
void setSyncErr(unsigned int s)
set syncErr
int bx(int l) const
Definition: GEMCoPadDigi.cc:29
void setStrip(unsigned int s)
set strip
unsigned int findQualityGEM(const CSCALCTDigi &, const CSCCLCTDigi &, int gemlayer) const
std::vector< int > get_gem_roll_to_csc_wg(Parity par) const
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
int pad() const
Definition: GEMPadDigi.h:26
void printGEMTriggerCoPads(int bx_start, int bx_stop, enum CSCPart)
unsigned int encodePattern(const int clctPattern) const
GEMPadDigi first() const
Definition: GEMCoPadDigi.h:29
bool isValid() const
check CLCT validity (1 - valid CLCT)
Definition: CSCCLCTDigi.h:35
int getRoll(const GEMPadDigiId &p) const
void setCSCID(unsigned int c)
set cscID
unsigned theChamber
Definition: CSCBaseboard.h:44
std::pair< int, int > getRolls(const CSCALCTDigi &) const
bool isGEMDetId(unsigned int) const
int roll() const
Definition: GEMCoPadDigi.h:25
#define LogTrace(id)
const GEMSuperChamber * superChamber(GEMDetId id) const
Definition: GEMGeometry.cc:69
int getBX() const
return BX - five low bits of BXN counter tagged by the ALCT
Definition: CSCALCTDigi.h:65
bool isPadInOverlap(int roll) const
float getPad(const GEMPadDigi &) const
virtual std::vector< int > get_gem_pad_to_csc_hs(Parity par, enum CSCPart) const =0
CSCCorrelatedLCTDigi constructLCTsGEM(const CSCALCTDigi &alct, const GEMCoPadDigi &gem, int i) const
Definition: DetId.h:17
edm::ParameterSet tmbParams_
Definition: CSCBaseboard.h:65
int getQuality() const
return quality of a pattern
Definition: CSCALCTDigi.h:38
int getAccelerator() const
Definition: CSCALCTDigi.h:45
unsigned theRegion
Definition: CSCBaseboard.h:42
void setBX(unsigned int b)
set bx
int bx() const
Definition: GEMPadDigi.h:27
int getPattern() const
return pattern
Definition: CSCCLCTDigi.h:47
part
Definition: HCALResponse.h:20
MuonDigiCollection< GEMDetId, GEMPadDigi > GEMPadDigiCollection
const unsigned theStation
Definition: CSCBaseboard.h:38
GEMPadDigi second() const
Definition: GEMCoPadDigi.h:30
unsigned int alct_trig_enable
virtual const CSCGEMMotherboardLUT * getLUT() const =0
GEMPadDigiIdsBX pads_
virtual std::vector< std::pair< int, int > > get_csc_hs_to_gem_pad(Parity par, enum CSCPart) const =0
~CSCGEMMotherboard() override
int getKeyStrip() const
Definition: CSCCLCTDigi.h:94
const GEMGeometry * gem_g
void setTrknmb(const uint16_t number)
Set track number (1,2) after sorting LCTs.
void setCLCT(const CSCCLCTDigi &clct)
int getKeyWG() const
return key wire group
Definition: CSCALCTDigi.h:59
void setGEM1(const GEMPadDigi &gem)
void printGEMTriggerPads(int bx_start, int bx_stop, enum CSCPart)
std::vector< std::pair< int, int > > get_csc_wg_to_gem_roll(Parity par, int layer=1) const
enum CSCPart getCSCPart(int keystrip) const