CMS 3D CMS Logo
SiStripFecKey.cc
Go to the documentation of this file.
1 
2 #include "DataFormats/SiStripCommon/interface/SiStripFecKey.h"
3 #include "DataFormats/SiStripCommon/interface/SiStripNullKey.h"
4 #include "DataFormats/SiStripCommon/interface/Constants.h"
5 #include "DataFormats/SiStripCommon/interface/ConstantsForHardwareSystems.h"
6 #include "DataFormats/SiStripCommon/interface/ConstantsForDqm.h"
7 #include "DataFormats/SiStripCommon/interface/ConstantsForView.h"
8 #include "DataFormats/SiStripCommon/interface/SiStripEnumsAndStrings.h"
9 #include <iomanip>
10 
11 // -----------------------------------------------------------------------------
12 //
13 SiStripFecKey::SiStripFecKey(const uint16_t& fec_crate,
14  const uint16_t& fec_slot,
15  const uint16_t& fec_ring,
16  const uint16_t& ccu_addr,
17  const uint16_t& ccu_chan,
18  const uint16_t& lld_chan,
19  const uint16_t& i2c_addr)
20  : SiStripKey(),
21  fecCrate_(fec_crate),
22  fecSlot_(fec_slot),
23  fecRing_(fec_ring),
24  ccuAddr_(ccu_addr),
25  ccuChan_(ccu_chan),
26  lldChan_(lld_chan),
27  i2cAddr_(i2c_addr) {
28  // order is important!
29  initFromValue();
30  initFromKey();
31  initFromPath();
32  initGranularity();
33 }
34 
35 // -----------------------------------------------------------------------------
36 //
37 SiStripFecKey::SiStripFecKey(const uint32_t& fec_key)
38  : SiStripKey(fec_key),
39  fecCrate_(sistrip::invalid_),
40  fecSlot_(sistrip::invalid_),
41  fecRing_(sistrip::invalid_),
42  ccuAddr_(sistrip::invalid_),
43  ccuChan_(sistrip::invalid_),
44  lldChan_(sistrip::invalid_),
45  i2cAddr_(sistrip::invalid_) {
46  // order is important!
47  initFromKey();
48  initFromValue();
49  initFromPath();
50  initGranularity();
51 }
52 
53 // -----------------------------------------------------------------------------
54 //
55 SiStripFecKey::SiStripFecKey(const std::string& path)
56  : SiStripKey(path),
57  fecCrate_(sistrip::invalid_),
58  fecSlot_(sistrip::invalid_),
59  fecRing_(sistrip::invalid_),
60  ccuAddr_(sistrip::invalid_),
61  ccuChan_(sistrip::invalid_),
62  lldChan_(sistrip::invalid_),
63  i2cAddr_(sistrip::invalid_) {
64  // order is important!
65  initFromPath();
66  initFromValue();
67  initFromKey();
68  initGranularity();
69 }
70 
71 // -----------------------------------------------------------------------------
72 //
73 SiStripFecKey::SiStripFecKey(const SiStripFecKey& input)
74  : SiStripKey(),
75  fecCrate_(input.fecCrate()),
76  fecSlot_(input.fecSlot()),
77  fecRing_(input.fecRing()),
78  ccuAddr_(input.ccuAddr()),
79  ccuChan_(input.ccuChan()),
80  lldChan_(input.lldChan()),
81  i2cAddr_(input.i2cAddr()) {
82  key(input.key());
83  path(input.path());
84  granularity(input.granularity());
85 }
86 
87 // -----------------------------------------------------------------------------
88 //
89 SiStripFecKey::SiStripFecKey(const SiStripKey& input)
90  : SiStripKey(),
91  fecCrate_(sistrip::invalid_),
92  fecSlot_(sistrip::invalid_),
93  fecRing_(sistrip::invalid_),
94  ccuAddr_(sistrip::invalid_),
95  ccuChan_(sistrip::invalid_),
96  lldChan_(sistrip::invalid_),
97  i2cAddr_(sistrip::invalid_) {
98  const SiStripFecKey& fec_key = dynamic_cast<const SiStripFecKey&>(input);
99  key(fec_key.key());
100  path(fec_key.path());
101  granularity(fec_key.granularity());
102  fecCrate_ = fec_key.fecCrate();
103  fecSlot_ = fec_key.fecSlot();
104  fecRing_ = fec_key.fecRing();
105  ccuAddr_ = fec_key.ccuAddr();
106  ccuChan_ = fec_key.ccuChan();
107  lldChan_ = fec_key.lldChan();
108  i2cAddr_ = fec_key.i2cAddr();
109 }
110 
111 // -----------------------------------------------------------------------------
112 //
113 SiStripFecKey::SiStripFecKey(const SiStripKey& input, const sistrip::Granularity& gran)
114  : SiStripKey(), fecCrate_(0), fecSlot_(0), fecRing_(0), ccuAddr_(0), ccuChan_(0), lldChan_(0), i2cAddr_(0) {
115  const SiStripFecKey& fec_key = dynamic_cast<const SiStripFecKey&>(input);
116  if (gran == sistrip::FEC_CRATE || gran == sistrip::FEC_SLOT || gran == sistrip::FEC_RING ||
117  gran == sistrip::CCU_ADDR || gran == sistrip::CCU_CHAN || gran == sistrip::LLD_CHAN || gran == sistrip::APV) {
118  fecCrate_ = fec_key.fecCrate();
119  }
120 
121  if (gran == sistrip::FEC_SLOT || gran == sistrip::FEC_RING || gran == sistrip::CCU_ADDR ||
122  gran == sistrip::CCU_CHAN || gran == sistrip::LLD_CHAN || gran == sistrip::APV) {
123  fecSlot_ = fec_key.fecSlot();
124  }
125 
126  if (gran == sistrip::FEC_RING || gran == sistrip::CCU_ADDR || gran == sistrip::CCU_CHAN ||
127  gran == sistrip::LLD_CHAN || gran == sistrip::APV) {
128  fecRing_ = fec_key.fecRing();
129  }
130 
131  if (gran == sistrip::CCU_ADDR || gran == sistrip::CCU_CHAN || gran == sistrip::LLD_CHAN || gran == sistrip::APV) {
132  ccuAddr_ = fec_key.ccuAddr();
133  }
134 
135  if (gran == sistrip::CCU_CHAN || gran == sistrip::LLD_CHAN || gran == sistrip::APV) {
136  ccuChan_ = fec_key.ccuChan();
137  }
138 
139  if (gran == sistrip::LLD_CHAN || gran == sistrip::APV) {
140  lldChan_ = fec_key.lldChan();
141  }
142 
143  if (gran == sistrip::APV) {
144  i2cAddr_ = fec_key.i2cAddr();
145  }
146 
147  initFromValue();
148  initFromKey();
149  initFromPath();
150  initGranularity();
151 }
152 
153 // -----------------------------------------------------------------------------
154 //
155 SiStripFecKey::SiStripFecKey()
156  : SiStripKey(),
157  fecCrate_(sistrip::invalid_),
158  fecSlot_(sistrip::invalid_),
159  fecRing_(sistrip::invalid_),
160  ccuAddr_(sistrip::invalid_),
161  ccuChan_(sistrip::invalid_),
162  lldChan_(sistrip::invalid_),
163  i2cAddr_(sistrip::invalid_) {
164  ;
165 }
166 
167 // -----------------------------------------------------------------------------
168 //
169 uint16_t SiStripFecKey::hybridPos(const uint16_t& i2c_addr) {
170  if (i2c_addr < sistrip::APV_I2C_MIN || i2c_addr > sistrip::APV_I2C_MAX) {
171  return sistrip::invalid_;
172  }
173  return (i2c_addr - sistrip::APV_I2C_MIN + 1);
174 }
175 
176 // -----------------------------------------------------------------------------
177 //
178 uint16_t SiStripFecKey::i2cAddr(const uint16_t& hybrid_pos) {
179  if (!hybrid_pos || hybrid_pos > (sistrip::APV_I2C_MAX - sistrip::APV_I2C_MIN + 1)) {
180  return sistrip::invalid_;
181  }
182  return (hybrid_pos + sistrip::APV_I2C_MIN - 1);
183 }
184 
185 // -----------------------------------------------------------------------------
186 //
187 uint16_t SiStripFecKey::i2cAddr(const uint16_t& lld_chan, const bool& first_apv) {
188  if (lld_chan < sistrip::LLD_CHAN_MIN || lld_chan > sistrip::LLD_CHAN_MAX) {
189  return sistrip::invalid_;
190  }
191  return (sistrip::APV_I2C_MIN + lld_chan * sistrip::APVS_PER_CHAN - (first_apv ? 2 : 1));
192 }
193 
194 // -----------------------------------------------------------------------------
195 //
196 uint16_t SiStripFecKey::lldChan(const uint16_t& i2c_addr) {
197  if (i2c_addr == 0) {
198  return 0;
199  } else if (i2c_addr < sistrip::APV_I2C_MIN || i2c_addr > sistrip::APV_I2C_MAX) {
200  return sistrip::invalid_;
201  }
202  return ((i2c_addr - sistrip::APV_I2C_MIN) / 2 + 1);
203 }
204 
205 // -----------------------------------------------------------------------------
206 //
207 bool SiStripFecKey::firstApvOfPair(const uint16_t& i2c_addr) {
208  if (i2c_addr < sistrip::APV_I2C_MIN || i2c_addr > sistrip::APV_I2C_MAX) {
209  return sistrip::invalid_;
210  }
211  return (((i2c_addr - sistrip::APV_I2C_MIN) % 2) == 0);
212 }
213 
214 // -----------------------------------------------------------------------------
215 //
216 bool SiStripFecKey::isEqual(const SiStripKey& key) const {
217  const SiStripFecKey& input = dynamic_cast<const SiStripFecKey&>(key);
218  if (fecCrate_ == input.fecCrate() && fecSlot_ == input.fecSlot() && fecRing_ == input.fecRing() &&
219  ccuAddr_ == input.ccuAddr() && ccuChan_ == input.ccuChan() && lldChan_ == input.lldChan() &&
220  i2cAddr_ == input.i2cAddr()) {
221  return true;
222  } else {
223  return false;
224  }
225 }
226 
227 // -----------------------------------------------------------------------------
228 //
229 bool SiStripFecKey::isConsistent(const SiStripKey& key) const {
230  const SiStripFecKey& input = dynamic_cast<const SiStripFecKey&>(key);
231  if (isEqual(input)) {
232  return true;
233  } else if ((fecCrate_ == 0 || input.fecCrate() == 0) && (fecSlot_ == 0 || input.fecSlot() == 0) &&
234  (fecRing_ == 0 || input.fecRing() == 0) && (ccuAddr_ == 0 || input.ccuAddr() == 0) &&
235  (lldChan_ == 0 || input.lldChan() == 0) && (i2cAddr_ == 0 || input.i2cAddr() == 0)) {
236  return true;
237  } else {
238  return false;
239  }
240 }
241 
242 // -----------------------------------------------------------------------------
243 //
244 bool SiStripFecKey::isValid() const { return isValid(sistrip::APV); }
245 
246 // -----------------------------------------------------------------------------
247 //
248 bool SiStripFecKey::isValid(const sistrip::Granularity& gran) const {
249  if (gran == sistrip::FEC_SYSTEM) {
250  return true;
251  } else if (gran == sistrip::UNDEFINED_GRAN || gran == sistrip::UNKNOWN_GRAN) {
252  return false;
253  }
254 
255  if (fecCrate_ != sistrip::invalid_) {
256  if (gran == sistrip::FEC_CRATE) {
257  return true;
258  }
259  if (fecSlot_ != sistrip::invalid_) {
260  if (gran == sistrip::FEC_RING) {
261  return true;
262  }
263  if (fecRing_ != sistrip::invalid_) {
264  if (gran == sistrip::FEC_RING) {
265  return true;
266  }
267  if (ccuAddr_ != sistrip::invalid_) {
268  if (gran == sistrip::CCU_ADDR) {
269  return true;
270  }
271  if (ccuChan_ != sistrip::invalid_) {
272  if (gran == sistrip::CCU_CHAN) {
273  return true;
274  }
275  if (lldChan_ != sistrip::invalid_) {
276  if (gran == sistrip::LLD_CHAN) {
277  return true;
278  }
279  if (i2cAddr_ != sistrip::invalid_) {
280  if (gran == sistrip::APV) {
281  return true;
282  }
283  }
284  }
285  }
286  }
287  }
288  }
289  }
290  return false;
291 }
292 
293 // -----------------------------------------------------------------------------
294 //
295 bool SiStripFecKey::isInvalid() const { return isInvalid(sistrip::APV); }
296 
297 // -----------------------------------------------------------------------------
298 //
299 bool SiStripFecKey::isInvalid(const sistrip::Granularity& gran) const {
300  if (gran == sistrip::FEC_SYSTEM) {
301  return false;
302  } else if (gran == sistrip::UNDEFINED_GRAN || gran == sistrip::UNKNOWN_GRAN) {
303  return false;
304  }
305 
306  if (fecCrate_ == sistrip::invalid_) {
307  if (gran == sistrip::FEC_CRATE) {
308  return true;
309  }
310  if (fecSlot_ == sistrip::invalid_) {
311  if (gran == sistrip::FEC_RING) {
312  return true;
313  }
314  if (fecRing_ == sistrip::invalid_) {
315  if (gran == sistrip::FEC_RING) {
316  return true;
317  }
318  if (ccuAddr_ == sistrip::invalid_) {
319  if (gran == sistrip::CCU_ADDR) {
320  return true;
321  }
322  if (ccuChan_ == sistrip::invalid_) {
323  if (gran == sistrip::CCU_CHAN) {
324  return true;
325  }
326  if (lldChan_ == sistrip::invalid_) {
327  if (gran == sistrip::LLD_CHAN) {
328  return true;
329  }
330  if (i2cAddr_ == sistrip::invalid_) {
331  if (gran == sistrip::APV) {
332  return true;
333  }
334  }
335  }
336  }
337  }
338  }
339  }
340  }
341  return false;
342 }
343 
344 // -----------------------------------------------------------------------------
345 //
346 void SiStripFecKey::initFromValue() {
347  // FEC crate
348  if (not((fecCrate_ >= sistrip::FEC_CRATE_MIN && fecCrate_ <= sistrip::FEC_CRATE_MAX) || (fecCrate_ == 0))) {
349  fecCrate_ = sistrip::invalid_;
350  }
351 
352  // FEC slot
353  if (not((fecSlot_ >= sistrip::CRATE_SLOT_MIN && fecSlot_ <= sistrip::CRATE_SLOT_MAX) || (fecSlot_ == 0))) {
354  fecSlot_ = sistrip::invalid_;
355  }
356 
357  // FEC ring
358  if (not((fecRing_ >= sistrip::FEC_RING_MIN && fecRing_ <= sistrip::FEC_RING_MAX) || (fecRing_ == 0))) {
359  fecRing_ = sistrip::invalid_;
360  }
361 
362  // CCU addr
363  if (not((ccuAddr_ >= sistrip::CCU_ADDR_MIN && ccuAddr_ <= sistrip::CCU_ADDR_MAX) || (ccuAddr_ == 0))) {
364  ccuAddr_ = sistrip::invalid_;
365  }
366 
367  // CCU chan
368  if (not((ccuChan_ >= sistrip::CCU_CHAN_MIN && ccuChan_ <= sistrip::CCU_CHAN_MAX) || (ccuChan_ == 0))) {
369  ccuChan_ = sistrip::invalid_;
370  }
371 
372  // LLD channel
373  if (not((lldChan_ >= sistrip::LLD_CHAN_MIN && lldChan_ <= sistrip::LLD_CHAN_MAX) || (lldChan_ == 0))) {
374  lldChan_ = sistrip::invalid_;
375  }
376 
377  // APV I2C address
378  if (i2cAddr_ >= sistrip::APV_I2C_MIN && i2cAddr_ <= sistrip::APV_I2C_MAX) {
379  if (lldChan_ && lldChan(i2cAddr_) != lldChan_) {
380  i2cAddr_ = sistrip::invalid_;
381  key(key() | (i2cAddrMask_ << i2cAddrOffset_));
382  }
383  } else if (i2cAddr_ != 0) {
384  i2cAddr_ = sistrip::invalid_;
385  }
386 }
387 
388 // -----------------------------------------------------------------------------
389 //
390 void SiStripFecKey::initFromKey() {
391  if (key() == sistrip::invalid32_) {
392  // ---------- Set FecKey based on member data ----------
393 
394  // Initialise to null value
395  key(0);
396 
397  // Extract FEC crate
398  if (fecCrate_ >= sistrip::FEC_CRATE_MIN && fecCrate_ <= sistrip::FEC_CRATE_MAX) {
399  key(key() | (fecCrate_ << fecCrateOffset_));
400  } else if (fecCrate_ == 0) {
401  key(key() | (fecCrate_ << fecCrateOffset_));
402  } else {
403  key(key() | (fecCrateMask_ << fecCrateOffset_));
404  }
405 
406  // Extract FEC slot
407  if (fecSlot_ >= sistrip::CRATE_SLOT_MIN && fecSlot_ <= sistrip::CRATE_SLOT_MAX) {
408  key(key() | (fecSlot_ << fecSlotOffset_));
409  } else if (fecSlot_ == 0) {
410  key(key() | (fecSlot_ << fecSlotOffset_));
411  } else {
412  key(key() | (fecSlotMask_ << fecSlotOffset_));
413  }
414 
415  // Extract FEC ring
416  if (fecRing_ >= sistrip::FEC_RING_MIN && fecRing_ <= sistrip::FEC_RING_MAX) {
417  key(key() | (fecRing_ << fecRingOffset_));
418  } else if (fecRing_ == 0) {
419  key(key() | (fecRing_ << fecRingOffset_));
420  } else {
421  key(key() | (fecRingMask_ << fecRingOffset_));
422  }
423 
424  // Extract CCU addr
425  if (ccuAddr_ >= sistrip::CCU_ADDR_MIN && ccuAddr_ <= sistrip::CCU_ADDR_MAX) {
426  key(key() | (ccuAddr_ << ccuAddrOffset_));
427  } else if (ccuAddr_ == 0) {
428  key(key() | (ccuAddr_ << ccuAddrOffset_));
429  } else {
430  key(key() | (ccuAddrMask_ << ccuAddrOffset_));
431  }
432 
433  // Extract CCU chan
434  if (ccuChan_ >= sistrip::CCU_CHAN_MIN && ccuChan_ <= sistrip::CCU_CHAN_MAX) {
435  key(key() | ((ccuChan_ - (sistrip::CCU_CHAN_MIN - 1)) << ccuChanOffset_));
436  } else if (ccuChan_ == 0) {
437  key(key() | (ccuChan_ << ccuChanOffset_));
438  } else {
439  key(key() | (ccuChanMask_ << ccuChanOffset_));
440  }
441 
442  // Extract LLD channel
443  if (lldChan_ >= sistrip::LLD_CHAN_MIN && lldChan_ <= sistrip::LLD_CHAN_MAX) {
444  key(key() | (lldChan_ << lldChanOffset_));
445  } else if (lldChan_ == 0) {
446  key(key() | (lldChan_ << lldChanOffset_));
447  } else {
448  key(key() | (lldChanMask_ << lldChanOffset_));
449  }
450 
451  // Extract APV I2C address
452  if (i2cAddr_ >= sistrip::APV_I2C_MIN && i2cAddr_ <= sistrip::APV_I2C_MAX) {
453  key(key() | ((firstApvOfPair(i2cAddr_) ? 1 : 2) << i2cAddrOffset_)); // key encodes APV number (1 or 2)
454  if (lldChan_ && lldChan(i2cAddr_) != lldChan_) {
455  i2cAddr_ = sistrip::invalid_;
456  key(key() | (i2cAddrMask_ << i2cAddrOffset_));
457  }
458  } else if (i2cAddr_ == 0) {
459  key(key() | (i2cAddr_ << i2cAddrOffset_));
460  } else {
461  key(key() | (i2cAddrMask_ << i2cAddrOffset_));
462  }
463 
464  } else {
465  // ---------- Set member data based on FEC key ----------
466 
467  fecCrate_ = (key() >> fecCrateOffset_) & fecCrateMask_;
468  fecSlot_ = (key() >> fecSlotOffset_) & fecSlotMask_;
469  fecRing_ = (key() >> fecRingOffset_) & fecRingMask_;
470  ccuAddr_ = (key() >> ccuAddrOffset_) & ccuAddrMask_;
471  ccuChan_ = (key() >> ccuChanOffset_) & ccuChanMask_;
472  lldChan_ = (key() >> lldChanOffset_) & lldChanMask_;
473  i2cAddr_ = (key() >> i2cAddrOffset_) & i2cAddrMask_;
474 
475  if (fecCrate_ == fecCrateMask_) {
476  fecCrate_ = sistrip::invalid_;
477  }
478  if (fecSlot_ == fecSlotMask_) {
479  fecSlot_ = sistrip::invalid_;
480  }
481  if (fecRing_ == fecRingMask_) {
482  fecRing_ = sistrip::invalid_;
483  }
484  if (ccuAddr_ == ccuAddrMask_) {
485  ccuAddr_ = sistrip::invalid_;
486  }
487  if (ccuChan_ == ccuChanMask_) {
488  ccuChan_ = sistrip::invalid_;
489  } else if (ccuChan_) {
490  ccuChan_ += (sistrip::CCU_CHAN_MIN - 1);
491  }
492  if (lldChan_ == lldChanMask_) {
493  lldChan_ = sistrip::invalid_;
494  }
495  if (i2cAddr_ == i2cAddrMask_) {
496  i2cAddr_ = sistrip::invalid_;
497  } else if (i2cAddr_ && lldChan_ != lldChanMask_) {
498  i2cAddr_ = i2cAddr(lldChan_, 2 - i2cAddr_);
499  }
500  }
501 }
502 
503 // -----------------------------------------------------------------------------
504 //
505 void SiStripFecKey::initFromPath() {
506  if (path() == sistrip::null_) {
507  // ---------- Set directory path based on member data ----------
508 
509  std::stringstream dir;
510 
511  dir << sistrip::root_ << sistrip::dir_ << sistrip::controlView_ << sistrip::dir_;
512 
513  // Add FEC crate
514  if (fecCrate_) {
515  dir << sistrip::fecCrate_ << fecCrate_ << sistrip::dir_;
516 
517  // Add FEC slot
518  if (fecSlot_) {
519  dir << sistrip::fecSlot_ << fecSlot_ << sistrip::dir_;
520 
521  // Add FEC ring
522  if (fecRing_) {
523  dir << sistrip::fecRing_ << fecRing_ << sistrip::dir_;
524 
525  // Add CCU address
526  if (ccuAddr_) {
527  dir << sistrip::ccuAddr_ << ccuAddr_ << sistrip::dir_;
528 
529  // Add CCU channel
530  if (ccuChan_) {
531  dir << sistrip::ccuChan_ << ccuChan_ << sistrip::dir_;
532 
533  // Add LLD channel
534  if (lldChan_) {
535  dir << sistrip::lldChan_ << lldChan_ << sistrip::dir_;
536 
537  // Add APV I2C address
538  if (i2cAddr_) {
539  dir << sistrip::apv_ << i2cAddr_ << sistrip::dir_;
540  }
541  }
542  }
543  }
544  }
545  }
546  }
547 
548  std::string temp(dir.str());
549  path(temp);
550 
551  } else {
552  // ---------- Set member data based on directory path ----------
553 
554  fecCrate_ = 0;
555  fecSlot_ = 0;
556  fecRing_ = 0;
557  ccuAddr_ = 0;
558  ccuChan_ = 0;
559  lldChan_ = 0;
560  i2cAddr_ = 0;
561 
562  // Check if root is found
563  if (path().find(sistrip::root_) == std::string::npos) {
564  std::string temp = path();
565  path(std::string(sistrip::root_) + sistrip::dir_ + temp);
566  }
567 
568  size_t curr = 0; // current string position
569  size_t next = 0; // next string position
570  next = path().find(sistrip::controlView_, curr);
571 
572  // Extract view
573  curr = next;
574  if (curr != std::string::npos) {
575  next = path().find(sistrip::fecCrate_, curr);
576  std::string control_view(
577  path(), curr + (sizeof(sistrip::controlView_) - 1), next - (sizeof(sistrip::dir_) - 1) - curr);
578 
579  // Extract FEC crate
580  curr = next;
581  if (curr != std::string::npos) {
582  next = path().find(sistrip::fecSlot_, curr);
583  std::string fec_crate(
584  path(), curr + (sizeof(sistrip::fecCrate_) - 1), next - (sizeof(sistrip::dir_) - 1) - curr);
585  fecCrate_ = std::atoi(fec_crate.c_str());
586 
587  // Extract FEC slot
588  curr = next;
589  if (curr != std::string::npos) {
590  next = path().find(sistrip::fecRing_, curr);
591  std::string fec_slot(
592  path(), curr + (sizeof(sistrip::fecSlot_) - 1), next - (sizeof(sistrip::dir_) - 1) - curr);
593  fecSlot_ = std::atoi(fec_slot.c_str());
594 
595  // Extract FEC ring
596  curr = next;
597  if (curr != std::string::npos) {
598  next = path().find(sistrip::ccuAddr_, curr);
599  std::string fec_ring(
600  path(), curr + (sizeof(sistrip::fecRing_) - 1), next - (sizeof(sistrip::dir_) - 1) - curr);
601  fecRing_ = std::atoi(fec_ring.c_str());
602 
603  // Extract CCU address
604  curr = next;
605  if (curr != std::string::npos) {
606  next = path().find(sistrip::ccuChan_, curr);
607  std::string ccu_addr(
608  path(), curr + (sizeof(sistrip::ccuAddr_) - 1), next - (sizeof(sistrip::dir_) - 1) - curr);
609  ccuAddr_ = std::atoi(ccu_addr.c_str());
610 
611  // Extract CCU channel
612  curr = next;
613  if (curr != std::string::npos) {
614  next = path().find(sistrip::lldChan_, curr);
615  std::string ccu_chan(
616  path(), curr + (sizeof(sistrip::ccuChan_) - 1), next - (sizeof(sistrip::dir_) - 1) - curr);
617  ccuChan_ = std::atoi(ccu_chan.c_str());
618 
619  // Extract LLD channel
620  curr = next;
621  if (curr != std::string::npos) {
622  next = path().find(sistrip::apv_, curr);
623  std::string lld_chan(
624  path(), curr + (sizeof(sistrip::lldChan_) - 1), next - (sizeof(sistrip::dir_) - 1) - curr);
625  lldChan_ = std::atoi(lld_chan.c_str());
626 
627  // Extract I2C address
628  curr = next;
629  if (curr != std::string::npos) {
630  next = std::string::npos;
631  std::string i2c_addr(path(), curr + (sizeof(sistrip::apv_) - 1), next - curr);
632  i2cAddr_ = std::atoi(i2c_addr.c_str());
633  }
634  }
635  }
636  }
637  }
638  }
639  }
640  } else {
641  std::stringstream ss;
642  ss << sistrip::root_ << sistrip::dir_;
643  //ss << sistrip::root_ << sistrip::dir_
644  //<< sistrip::unknownView_ << sistrip::dir_;
645  std::string temp(ss.str());
646  path(temp);
647  }
648  }
649 }
650 
651 // -----------------------------------------------------------------------------
652 //
653 void SiStripFecKey::initGranularity() {
654  granularity(sistrip::FEC_SYSTEM);
655  channel(0);
656  if (fecCrate_ && fecCrate_ != sistrip::invalid_) {
657  granularity(sistrip::FEC_CRATE);
658  channel(fecCrate_);
659  if (fecSlot_ && fecSlot_ != sistrip::invalid_) {
660  granularity(sistrip::FEC_SLOT);
661  channel(fecSlot_);
662  if (fecRing_ && fecRing_ != sistrip::invalid_) {
663  granularity(sistrip::FEC_RING);
664  channel(fecRing_);
665  if (ccuAddr_ && ccuAddr_ != sistrip::invalid_) {
666  granularity(sistrip::CCU_ADDR);
667  channel(ccuAddr_);
668  if (ccuChan_ && ccuChan_ != sistrip::invalid_) {
669  granularity(sistrip::CCU_CHAN);
670  channel(ccuChan_);
671  if (lldChan_ && lldChan_ != sistrip::invalid_) {
672  granularity(sistrip::LLD_CHAN);
673  channel(lldChan_);
674  if (i2cAddr_ && i2cAddr_ != sistrip::invalid_) {
675  granularity(sistrip::APV);
676  channel(i2cAddr_);
677  } else if (i2cAddr_ == sistrip::invalid_) {
678  granularity(sistrip::UNKNOWN_GRAN);
679  channel(sistrip::invalid_);
680  }
681  } else if (lldChan_ == sistrip::invalid_) {
682  granularity(sistrip::UNKNOWN_GRAN);
683  channel(sistrip::invalid_);
684  }
685  } else if (ccuChan_ == sistrip::invalid_) {
686  granularity(sistrip::UNKNOWN_GRAN);
687  channel(sistrip::invalid_);
688  }
689  } else if (ccuAddr_ == sistrip::invalid_) {
690  granularity(sistrip::UNKNOWN_GRAN);
691  channel(sistrip::invalid_);
692  }
693  } else if (fecRing_ == sistrip::invalid_) {
694  granularity(sistrip::UNKNOWN_GRAN);
695  channel(sistrip::invalid_);
696  }
697  } else if (fecSlot_ == sistrip::invalid_) {
698  granularity(sistrip::UNKNOWN_GRAN);
699  channel(sistrip::invalid_);
700  }
701  } else if (fecCrate_ == sistrip::invalid_) {
702  granularity(sistrip::UNKNOWN_GRAN);
703  channel(sistrip::invalid_);
704  }
705 }
706 
707 // -----------------------------------------------------------------------------
708 //
709 void SiStripFecKey::terse(std::stringstream& ss) const {
710  ss << "FEC:crate/slot/ring/CCU/module/LLD/I2C= " << fecCrate() << "/" << fecSlot() << "/" << fecRing() << "/"
711  << ccuAddr() << "/" << ccuChan() << "/" << lldChan() << "/" << i2cAddr();
712  // ss << " FecKey"
713  // //<< "=0x"
714  // //<< std::hex
715  // //<< std::setfill('0') << std::setw(8) << key() << std::setfill(' ')
716  // //<< std::dec
717  // //<< ", " << ( isValid() ? "Valid" : "Invalid" )
718  // << ", Crate=" << fecCrate()
719  // << ", Slot=" << fecSlot()
720  // << ", Ring=" << fecRing()
721  // << ", CCU=" << ccuAddr()
722  // << ", module=" << ccuChan()
723  // << ", LLD=" << lldChan()
724  // << ", I2C=" << i2cAddr();
725 }
726 
727 // -----------------------------------------------------------------------------
728 //
729 void SiStripFecKey::print(std::stringstream& ss) const {
730  ss << " [SiStripFecKey::print]" << std::endl
731  << std::hex << " FEC key : 0x" << std::setfill('0') << std::setw(8) << key() << std::endl
732  << std::setfill(' ') << std::dec << " FEC VME crate : " << fecCrate() << std::endl
733  << " FEC VME slot : " << fecSlot() << std::endl
734  << " FEC control ring : " << fecRing() << std::endl
735  << " CCU I2C address : " << ccuAddr() << std::endl
736  << " CCU chan (FE module) : " << ccuChan() << std::endl
737  << " LaserDriver channel : " << lldChan() << std::endl
738  << " APV I2C address : " << i2cAddr() << std::endl
739  << " Directory : " << path() << std::endl
740  << " Granularity : " << SiStripEnumsAndStrings::granularity(granularity()) << std::endl
741  << " Channel : " << channel() << std::endl
742  << " isValid : " << isValid();
743 }
744 
745 // -----------------------------------------------------------------------------
746 //
747 std::ostream& operator<<(std::ostream& os, const SiStripFecKey& input) {
748  std::stringstream ss;
749  input.print(ss);
750  os << ss.str();
751  return os;
752 }
753 
754 // -----------------------------------------------------------------------------
755 //
756 ConsistentWithKey::ConsistentWithKey(const SiStripFecKey& key)
757  : mask_(key.fecCrate() ? sistrip::invalid_ : 0,
758  key.fecSlot() ? sistrip::invalid_ : 0,
759  key.fecRing() ? sistrip::invalid_ : 0,
760  key.ccuAddr() ? sistrip::invalid_ : 0,
761  key.ccuChan() ? sistrip::invalid_ : 0,
762  key.lldChan() ? sistrip::invalid_ : 0,
763  key.i2cAddr() ? sistrip::invalid_ : 0) {
764  ;
765 }
766 
767 // -----------------------------------------------------------------------------
768 //
769 ConsistentWithKey::ConsistentWithKey() : mask_(SiStripNullKey()) { ; }
770 
771 // -----------------------------------------------------------------------------
772 //
773 bool ConsistentWithKey::operator()(const uint32_t& a, const uint32_t& b) const {
774  return ((a & mask_.key()) < (b & mask_.key()));
775 }
sistrip::Granularity
Granularity
Definition: ConstantsForGranularity.h:60
Constants.h
Generic constants.
sistrip::null_
static const char null_[]
Definition: Constants.h:22
sistrip::CCU_CHAN
Definition: ConstantsForGranularity.h:93
SiStripFecKey::i2cAddr_
uint16_t i2cAddr_
Definition: SiStripFecKey.h:175
ConsistentWithKey::ConsistentWithKey
ConsistentWithKey()
Definition: SiStripFecKey.cc:769
SiStripFecKey::initGranularity
void initGranularity() override
Definition: SiStripFecKey.cc:653
SiStripFecKey::fecSlotMask_
static const uint16_t fecSlotMask_
Definition: SiStripFecKey.h:188
SiStripFecKey::lldChanOffset_
static const uint16_t lldChanOffset_
Definition: SiStripFecKey.h:183
input
static const std::string input
Definition: EdmProvDump.cc:48
SiStripFecKey::ccuAddrOffset_
static const uint16_t ccuAddrOffset_
Definition: SiStripFecKey.h:181
sistrip::FEC_RING
Definition: ConstantsForGranularity.h:91
sistrip::FEC_SYSTEM
Definition: ConstantsForGranularity.h:88
SiStripFecKey::print
void print(std::stringstream &ss) const override
Definition: SiStripFecKey.cc:729
sistrip::invalid32_
static const uint32_t invalid32_
Definition: Constants.h:15
SiStripFecKey::initFromValue
void initFromValue() override
Definition: SiStripFecKey.cc:346
sistrip::LLD_CHAN_MIN
static const uint16_t LLD_CHAN_MIN
Definition: ConstantsForHardwareSystems.h:70
sistrip::CCU_ADDR
Definition: ConstantsForGranularity.h:92
sistrip::FEC_CRATE_MIN
static const uint16_t FEC_CRATE_MIN
Definition: ConstantsForHardwareSystems.h:89
SiStripKey::key
const uint32_t & key() const
Definition: SiStripKey.h:120
SiStripFecKey::lldChan
const uint16_t & lldChan() const
Definition: SiStripFecKey.h:203
sistrip::dir_
static const char dir_[]
Definition: ConstantsForDqm.h:17
sistrip::CCU_ADDR_MAX
static const uint16_t CCU_ADDR_MAX
Definition: ConstantsForHardwareSystems.h:65
sistrip::FEC_RING_MAX
static const uint16_t FEC_RING_MAX
Definition: ConstantsForHardwareSystems.h:62
sistrip::APV_I2C_MIN
static const uint16_t APV_I2C_MIN
Definition: ConstantsForHardwareSystems.h:73
sistrip::FEC_CRATE_MAX
static const uint16_t FEC_CRATE_MAX
Definition: ConstantsForHardwareSystems.h:90
sistrip::CCU_CHAN_MIN
static const uint16_t CCU_CHAN_MIN
Definition: ConstantsForHardwareSystems.h:67
ConsistentWithKey::operator()
bool operator()(const uint32_t &, const uint32_t &) const
Definition: SiStripFecKey.cc:773
SiStripFecKey::fecCrate
const uint16_t & fecCrate() const
Definition: SiStripFecKey.h:198
ConstantsForHardwareSystems.h
Constants and enumerated types for FED/FEC systems.
sistrip::UNKNOWN_GRAN
Definition: ConstantsForGranularity.h:62
spr::find
void find(edm::Handle< EcalRecHitCollection > &hits, DetId thisDet, std::vector< EcalRecHitCollection::const_iterator > &hit, bool debug=false)
Definition: FindCaloHit.cc:19
groupFilesInBlocks.temp
list temp
Definition: groupFilesInBlocks.py:142
SiStripFecKey::ccuAddrMask_
static const uint16_t ccuAddrMask_
Definition: SiStripFecKey.h:190
sistrip::ccuAddr_
static const char ccuAddr_[]
Definition: ConstantsForGranularity.h:55
SiStripKey::granularity
const sistrip::Granularity & granularity() const
Definition: SiStripKey.h:122
sistrip::CRATE_SLOT_MAX
static const uint16_t CRATE_SLOT_MAX
Definition: ConstantsForHardwareSystems.h:81
sistrip::CCU_ADDR_MIN
static const uint16_t CCU_ADDR_MIN
Definition: ConstantsForHardwareSystems.h:64
sistrip::LLD_CHAN_MAX
static const uint16_t LLD_CHAN_MAX
Definition: ConstantsForHardwareSystems.h:71
contentValuesCheck.ss
ss
Definition: contentValuesCheck.py:33
SiStripKey::channel
const uint16_t & channel() const
Definition: SiStripKey.h:123
SiStripFecKey::ccuChanOffset_
static const uint16_t ccuChanOffset_
Definition: SiStripFecKey.h:182
SiStripFecKey::fecRingMask_
static const uint16_t fecRingMask_
Definition: SiStripFecKey.h:189
SiStripFecKey::terse
void terse(std::stringstream &ss) const override
Definition: SiStripFecKey.cc:709
SiStripFecKey::fecCrateOffset_
static const uint16_t fecCrateOffset_
Definition: SiStripFecKey.h:178
SiStripFecKey::fecRing
const uint16_t & fecRing() const
Definition: SiStripFecKey.h:200
sistrip::fecCrate_
static const char fecCrate_[]
Definition: ConstantsForGranularity.h:52
sistrip::FEC_RING_MIN
static const uint16_t FEC_RING_MIN
Definition: ConstantsForHardwareSystems.h:61
SiStripEnumsAndStrings::granularity
static std::string granularity(const sistrip::Granularity &)
Definition: SiStripEnumsAndStrings.cc:265
SiStripFecKey::fecSlot_
uint16_t fecSlot_
Definition: SiStripFecKey.h:160
sistrip::fecSlot_
static const char fecSlot_[]
Definition: ConstantsForGranularity.h:53
b
double b
Definition: hdecay.h:118
SiStripNullKey.h
SiStripFecKey
Utility class that identifies a position within the strip tracker control structure,...
Definition: SiStripFecKey.h:45
SiStripFecKey.h
SiStripFecKey::ccuChan
const uint16_t & ccuChan() const
Definition: SiStripFecKey.h:202
sistrip::CRATE_SLOT_MIN
static const uint16_t CRATE_SLOT_MIN
Definition: ConstantsForHardwareSystems.h:80
sistrip::ccuChan_
static const char ccuChan_[]
Definition: ConstantsForGranularity.h:56
sistrip::lldChan_
static const char lldChan_[]
Definition: ConstantsForGranularity.h:39
ConsistentWithKey::mask_
SiStripFecKey mask_
Definition: SiStripFecKey.h:239
a
double a
Definition: hdecay.h:119
SiStripFecKey::fecRing_
uint16_t fecRing_
Definition: SiStripFecKey.h:163
SiStripKey::path
const std::string & path() const
Definition: SiStripKey.h:121
SiStripFecKey::SiStripFecKey
SiStripFecKey()
Definition: SiStripFecKey.cc:155
sistrip::controlView_
static const char controlView_[]
Definition: ConstantsForView.h:21
SiStripFecKey::isEqual
bool isEqual(const SiStripKey &) const override
Definition: SiStripFecKey.cc:216
sistrip::APV
Definition: ConstantsForGranularity.h:79
SiStripFecKey::fecCrateMask_
static const uint16_t fecCrateMask_
Definition: SiStripFecKey.h:187
SiStripFecKey::ccuChan_
uint16_t ccuChan_
Definition: SiStripFecKey.h:169
sistrip::root_
static const char root_[]
Definition: ConstantsForDqm.h:30
SiStripNullKey
Concrete implementation of abstract base, signifying null values or an "unknown" position or view.
Definition: SiStripNullKey.h:20
sistrip::invalid_
static const uint16_t invalid_
Definition: Constants.h:16
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
ConstantsForView.h
Constants and enumerated types for sistrip::View.
SiStripFecKey::ccuAddr_
uint16_t ccuAddr_
Definition: SiStripFecKey.h:166
SiStripFecKey::isConsistent
bool isConsistent(const SiStripKey &) const override
Definition: SiStripFecKey.cc:229
SiStripFecKey::i2cAddrMask_
static const uint16_t i2cAddrMask_
Definition: SiStripFecKey.h:193
SiStripFecKey::hybridPos
static uint16_t hybridPos(const uint16_t &i2c_addr)
Definition: SiStripFecKey.cc:169
SiStripFecKey::i2cAddr
const uint16_t & i2cAddr() const
Definition: SiStripFecKey.h:204
sistrip::apv_
static const char apv_[]
Definition: ConstantsForGranularity.h:40
ConstantsForDqm.h
Various generic constants used by DQM.
SiStripFecKey::ccuChanMask_
static const uint16_t ccuChanMask_
Definition: SiStripFecKey.h:191
sistrip::APV_I2C_MAX
static const uint16_t APV_I2C_MAX
Definition: ConstantsForHardwareSystems.h:74
SiStripEnumsAndStrings.h
SiStripFecKey::ccuAddr
const uint16_t & ccuAddr() const
Definition: SiStripFecKey.h:201
SiStripFecKey::fecSlotOffset_
static const uint16_t fecSlotOffset_
Definition: SiStripFecKey.h:179
SiStripFecKey::lldChan_
uint16_t lldChan_
Definition: SiStripFecKey.h:172
SiStripFecKey::fecRingOffset_
static const uint16_t fecRingOffset_
Definition: SiStripFecKey.h:180
sistrip::fecRing_
static const char fecRing_[]
Definition: ConstantsForGranularity.h:54
SiStripFecKey::fecCrate_
uint16_t fecCrate_
Definition: SiStripFecKey.h:157
SiStripFecKey::firstApvOfPair
static bool firstApvOfPair(const uint16_t &i2c_addr)
Definition: SiStripFecKey.cc:207
castor_dqm_sourceclient_file_cfg.path
path
Definition: castor_dqm_sourceclient_file_cfg.py:37
SiStripFecKey::initFromPath
void initFromPath() override
Definition: SiStripFecKey.cc:505
sistrip
sistrip classes
Definition: EnsembleCalibrationLA.cc:10
SiStripFecKey::fecSlot
const uint16_t & fecSlot() const
Definition: SiStripFecKey.h:199
sistrip::FEC_CRATE
Definition: ConstantsForGranularity.h:89
sistrip::UNDEFINED_GRAN
Definition: ConstantsForGranularity.h:61
crabWrapper.key
key
Definition: crabWrapper.py:19
sistrip::APVS_PER_CHAN
static const uint16_t APVS_PER_CHAN
Definition: ConstantsForHardwareSystems.h:38
SiStripKey
Base utility class that identifies a position within a logical structure of the strip tracker.
Definition: SiStripKey.h:23
SiStripFecKey::i2cAddrOffset_
static const uint16_t i2cAddrOffset_
Definition: SiStripFecKey.h:184
TauDecayModes.dec
dec
Definition: TauDecayModes.py:142
SiStripFecKey::lldChanMask_
static const uint16_t lldChanMask_
Definition: SiStripFecKey.h:192
sistrip::LLD_CHAN
Definition: ConstantsForGranularity.h:78
SiStripFecKey::initFromKey
void initFromKey() override
Definition: SiStripFecKey.cc:390
SiStripFecKey::isInvalid
bool isInvalid() const override
Definition: SiStripFecKey.cc:295
SiStripFecKey::isValid
bool isValid() const override
Definition: SiStripFecKey.cc:244
GetRecoTauVFromDQM_MC_cff.next
next
Definition: GetRecoTauVFromDQM_MC_cff.py:31
DeadROC_duringRun.dir
dir
Definition: DeadROC_duringRun.py:23
sistrip::CCU_CHAN_MAX
static const uint16_t CCU_CHAN_MAX
Definition: ConstantsForHardwareSystems.h:68
sistrip::FEC_SLOT
Definition: ConstantsForGranularity.h:90
operator<<
std::ostream & operator<<(std::ostream &os, const SiStripFecKey &input)
Definition: SiStripFecKey.cc:747
Generated for CMSSW Reference Manual by doxygen 1.8.16