CMS 3D CMS Logo
SiStripEnumsAndStrings.cc
Go to the documentation of this file.
1 #include "DataFormats/SiStripCommon/interface/SiStripEnumsAndStrings.h"
2 
3 // -----------------------------------------------------------------------------
4 //
5 std::string SiStripEnumsAndStrings::view(const sistrip::View& view) {
6  if (view == sistrip::READOUT_VIEW) {
7  return sistrip::readoutView_;
8  } else if (view == sistrip::CONTROL_VIEW) {
9  return sistrip::controlView_;
10  } else if (view == sistrip::DETECTOR_VIEW) {
11  return sistrip::detectorView_;
12  } else if (view == sistrip::UNDEFINED_VIEW) {
13  return sistrip::undefinedView_;
14  } else {
15  return sistrip::unknownView_;
16  }
17 }
18 
19 // -----------------------------------------------------------------------------
20 //
21 sistrip::View SiStripEnumsAndStrings::view(const std::string& dir) {
22  if (dir.find(sistrip::readoutView_) != std::string::npos) {
23  return sistrip::READOUT_VIEW;
24  } else if (dir.find(sistrip::controlView_) != std::string::npos) {
25  return sistrip::CONTROL_VIEW;
26  } else if (dir.find(sistrip::detectorView_) != std::string::npos) {
27  return sistrip::DETECTOR_VIEW;
28  } else if (dir.find(sistrip::undefinedView_) != std::string::npos) {
29  return sistrip::UNDEFINED_VIEW;
30  } else if (dir.empty()) {
31  return sistrip::UNDEFINED_VIEW;
32  } else {
33  return sistrip::UNKNOWN_VIEW;
34  }
35 }
36 
37 // -----------------------------------------------------------------------------
38 //
39 std::string SiStripEnumsAndStrings::runType(const sistrip::RunType& run_type) {
40  if (run_type == sistrip::FAST_CABLING) {
41  return sistrip::fastCablingRun_;
42  } else if (run_type == sistrip::FED_CABLING) {
43  return sistrip::fedCablingRun_;
44  } else if (run_type == sistrip::APV_TIMING) {
45  return sistrip::apvTimingRun_;
46  } else if (run_type == sistrip::FED_TIMING) {
47  return sistrip::fedTimingRun_;
48  } else if (run_type == sistrip::OPTO_SCAN) {
49  return sistrip::optoScanRun_;
50  } else if (run_type == sistrip::VPSP_SCAN) {
51  return sistrip::vpspScanRun_;
52  } else if (run_type == sistrip::PEDESTALS) {
53  return sistrip::pedestalsRun_;
54  } else if (run_type == sistrip::PEDS_ONLY) {
55  return sistrip::pedsOnlyRun_;
56  } else if (run_type == sistrip::NOISE) {
57  return sistrip::noiseRun_;
58  } else if (run_type == sistrip::PEDS_FULL_NOISE) {
59  return sistrip::pedsFullNoiseRun_;
60  } else if (run_type == sistrip::APV_LATENCY) {
61  return sistrip::apvLatencyRun_;
62  } else if (run_type == sistrip::FINE_DELAY) {
63  return sistrip::fineDelayRun_;
64  } else if (run_type == sistrip::CALIBRATION) {
65  return sistrip::calibPeakRun_;
66  } else if (run_type == sistrip::CALIBRATION_DECO) {
67  return sistrip::calibDeconRun_;
68  } else if (run_type == sistrip::CALIBRATION_SCAN) {
69  return sistrip::calibScanPeakRun_;
70  } else if (run_type == sistrip::CALIBRATION_SCAN_DECO) {
71  return sistrip::calibScanDeconRun_;
72  } else if (run_type == sistrip::DAQ_SCOPE_MODE) {
73  return sistrip::daqScopeModeRun_;
74  } else if (run_type == sistrip::PHYSICS) {
75  return sistrip::physicsRun_;
76  } else if (run_type == sistrip::UNDEFINED_RUN_TYPE) {
77  return sistrip::undefinedRunType_;
78  } else {
79  return sistrip::unknownRunType_;
80  }
81 }
82 
83 // -----------------------------------------------------------------------------
84 //
85 sistrip::RunType SiStripEnumsAndStrings::runType(const std::string& run_type) {
86  if (run_type.find(sistrip::fastCablingRun_) != std::string::npos) {
87  return sistrip::FAST_CABLING;
88  } else if (run_type.find(sistrip::fedCablingRun_) != std::string::npos) {
89  return sistrip::FED_CABLING;
90  } else if (run_type.find(sistrip::apvTimingRun_) != std::string::npos) {
91  return sistrip::APV_TIMING;
92  } else if (run_type.find(sistrip::fedTimingRun_) != std::string::npos) {
93  return sistrip::FED_TIMING;
94  } else if (run_type.find(sistrip::optoScanRun_) != std::string::npos) {
95  return sistrip::OPTO_SCAN;
96  } else if (run_type.find(sistrip::vpspScanRun_) != std::string::npos) {
97  return sistrip::VPSP_SCAN;
98  } else if (run_type.find(sistrip::pedestalsRun_) != std::string::npos) {
99  return sistrip::PEDESTALS;
100  } else if (run_type.find(sistrip::pedsOnlyRun_) != std::string::npos) {
101  return sistrip::PEDS_ONLY;
102  } else if (run_type.find(sistrip::pedsFullNoiseRun_) != std::string::npos) {
103  return sistrip::PEDS_FULL_NOISE;
104  } // needs to be before noise, otherwise name mismatch
105  else if (run_type.find(sistrip::noiseRun_) != std::string::npos) {
106  return sistrip::NOISE;
107  } else if (run_type.find(sistrip::fineDelayRun_) != std::string::npos) {
108  return sistrip::FINE_DELAY;
109  } else if (run_type.find(sistrip::calibPeakRun_) != std::string::npos) {
110  return sistrip::CALIBRATION;
111  } else if (run_type.find(sistrip::calibScanPeakRun_) != std::string::npos) {
112  return sistrip::CALIBRATION_SCAN;
113  } else if (run_type.find(sistrip::calibDeconRun_) != std::string::npos) {
114  return sistrip::CALIBRATION_DECO;
115  } else if (run_type.find(sistrip::calibScanDeconRun_) != std::string::npos) {
116  return sistrip::CALIBRATION_SCAN_DECO;
117  } else if (run_type.find(sistrip::apvLatencyRun_) != std::string::npos) {
118  return sistrip::APV_LATENCY;
119  } else if (run_type.find(sistrip::daqScopeModeRun_) != std::string::npos) {
120  return sistrip::DAQ_SCOPE_MODE;
121  } else if (run_type.find(sistrip::physicsRun_) != std::string::npos) {
122  return sistrip::PHYSICS;
123  } else if (run_type.find(sistrip::undefinedRunType_) != std::string::npos) {
124  return sistrip::UNDEFINED_RUN_TYPE;
125  } else if (run_type.empty()) {
126  return sistrip::UNDEFINED_RUN_TYPE;
127  } else if (run_type == "FAST_CABLING") {
128  return sistrip::FAST_CABLING;
129  } else if (run_type == "FED_CABLING") {
130  return sistrip::FED_CABLING;
131  } else if (run_type == "APV_TIMING") {
132  return sistrip::APV_TIMING;
133  } else if (run_type == "FED_TIMING") {
134  return sistrip::FED_TIMING;
135  } else if (run_type == "OPTO_SCAN") {
136  return sistrip::OPTO_SCAN;
137  } else if (run_type == "VPSP_SCAN") {
138  return sistrip::VPSP_SCAN;
139  } else if (run_type == "PEDESTALS") {
140  return sistrip::PEDESTALS;
141  } else if (run_type == "PEDS_FULL_NOISE") {
142  return sistrip::PEDS_FULL_NOISE;
143  } else if (run_type == "PEDS_ONLY") {
144  return sistrip::PEDS_ONLY;
145  } else if (run_type == "NOISE") {
146  return sistrip::NOISE;
147  } else if (run_type == "APV_LATENCY") {
148  return sistrip::APV_LATENCY;
149  } else if (run_type == "FINE_DELAY") {
150  return sistrip::FINE_DELAY;
151  } else if (run_type == "CALIBRATION") {
152  return sistrip::CALIBRATION;
153  } else if (run_type == "CALIBRATION_SCAN") {
154  return sistrip::CALIBRATION_SCAN;
155  } else if (run_type == "CALIBRATION_DECO") {
156  return sistrip::CALIBRATION_DECO;
157  } else if (run_type == "CALIBRATION_SCAN_DECO") {
158  return sistrip::CALIBRATION_SCAN_DECO;
159  } else if (run_type == "DAQ_SCOPE_MODE") {
160  return sistrip::DAQ_SCOPE_MODE;
161  } else if (run_type == "PHYSICS") {
162  return sistrip::PHYSICS;
163  } else if (run_type == "UNDEFINED") {
164  return sistrip::UNDEFINED_RUN_TYPE;
165  } else {
166  return sistrip::UNKNOWN_RUN_TYPE;
167  }
168 }
169 
170 // -----------------------------------------------------------------------------
171 //
172 sistrip::RunType SiStripEnumsAndStrings::runType(const uint16_t& run_type) {
173  if (run_type == 1) {
174  return sistrip::PHYSICS;
175  } else if (run_type == 2) {
176  return sistrip::PEDESTALS;
177  } else if (run_type == 3) {
178  return sistrip::CALIBRATION;
179  } else if (run_type == 4) {
180  return sistrip::OPTO_SCAN;
181  } else if (run_type == 5) {
182  return sistrip::APV_TIMING;
183  } else if (run_type == 6) {
184  return sistrip::APV_LATENCY;
185  } else if (run_type == 7) {
186  return sistrip::FINE_DELAY_PLL;
187  } else if (run_type == 8) {
188  return sistrip::FINE_DELAY_TTC;
189  } else if (run_type == 10) {
190  return sistrip::MULTI_MODE;
191  } else if (run_type == 11) {
192  return sistrip::FED_CABLING;
193  } else if (run_type == 12) {
194  return sistrip::FED_TIMING;
195  } else if (run_type == 13) {
196  return sistrip::FED_CABLING;
197  } else if (run_type == 14) {
198  return sistrip::VPSP_SCAN;
199  } else if (run_type == 15) {
200  return sistrip::DAQ_SCOPE_MODE;
201  } else if (run_type == 16) {
202  return sistrip::QUITE_FAST_CABLING;
203  } else if (run_type == 17) {
204  return sistrip::FINE_DELAY;
205  } //@@ layer
206  else if (run_type == 18) {
207  return sistrip::PHYSICS_ZS;
208  } else if (run_type == 19) {
209  return sistrip::CALIBRATION_SCAN;
210  } else if (run_type == 20) {
211  return sistrip::CALIBRATION_SCAN_DECO;
212  } else if (run_type == 21) {
213  return sistrip::FAST_CABLING;
214  } else if (run_type == 22) {
215  return sistrip::PEDS_ONLY;
216  } else if (run_type == 23) {
217  return sistrip::NOISE;
218  } else if (run_type == 24) {
219  return sistrip::PEDS_FULL_NOISE;
220  } else if (run_type == 33) {
221  return sistrip::CALIBRATION_DECO;
222  } else if (run_type == sistrip::invalid_) {
223  return sistrip::UNDEFINED_RUN_TYPE;
224  } else {
225  return sistrip::UNKNOWN_RUN_TYPE;
226  }
227 }
228 
229 // -----------------------------------------------------------------------------
230 //
231 std::string SiStripEnumsAndStrings::keyType(const sistrip::KeyType& key_type) {
232  if (key_type == sistrip::FED_KEY) {
233  return sistrip::fedKey_;
234  } else if (key_type == sistrip::FEC_KEY) {
235  return sistrip::fecKey_;
236  } else if (key_type == sistrip::DET_KEY) {
237  return sistrip::detKey_;
238  } else if (key_type == sistrip::UNDEFINED_KEY) {
239  return sistrip::undefinedKey_;
240  } else {
241  return sistrip::unknownKey_;
242  }
243 }
244 
245 // -----------------------------------------------------------------------------
246 //
247 sistrip::KeyType SiStripEnumsAndStrings::keyType(const std::string& key_type) {
248  if (key_type.find(sistrip::fedKey_) != std::string::npos) {
249  return sistrip::FED_KEY;
250  } else if (key_type.find(sistrip::fecKey_) != std::string::npos) {
251  return sistrip::FEC_KEY;
252  } else if (key_type.find(sistrip::detKey_) != std::string::npos) {
253  return sistrip::DET_KEY;
254  } else if (key_type.find(sistrip::undefinedKey_) != std::string::npos) {
255  return sistrip::UNDEFINED_KEY;
256  } else if (key_type.empty()) {
257  return sistrip::UNDEFINED_KEY;
258  } else {
259  return sistrip::UNKNOWN_KEY;
260  }
261 }
262 
263 // -----------------------------------------------------------------------------
264 //
265 std::string SiStripEnumsAndStrings::granularity(const sistrip::Granularity& granularity) {
266  // System
267  if (granularity == sistrip::TRACKER) {
268  return sistrip::tracker_;
269  } else if (granularity == sistrip::PARTITION) {
270  return sistrip::partition_;
271  } else if (granularity == sistrip::TIB) {
272  return sistrip::tib_;
273  } else if (granularity == sistrip::TOB) {
274  return sistrip::tob_;
275  } else if (granularity == sistrip::TEC) {
276  return sistrip::tec_;
277  }
278  // Sub-structure
279  else if (granularity == sistrip::LAYER) {
280  return sistrip::layer_;
281  } else if (granularity == sistrip::ROD) {
282  return sistrip::rod_;
283  } else if (granularity == sistrip::STRING) {
284  return sistrip::string_;
285  } else if (granularity == sistrip::DISK) {
286  return sistrip::disk_;
287  } else if (granularity == sistrip::PETAL) {
288  return sistrip::petal_;
289  } else if (granularity == sistrip::RING) {
290  return sistrip::ring_;
291  }
292  // Module and below
293  else if (granularity == sistrip::MODULE) {
294  return sistrip::module_;
295  } else if (granularity == sistrip::LLD_CHAN) {
296  return sistrip::lldChan_;
297  } else if (granularity == sistrip::APV) {
298  return sistrip::apv_;
299  }
300  // Readout
301  else if (granularity == sistrip::FED_SYSTEM) {
302  return sistrip::fedSystem_;
303  } else if (granularity == sistrip::FE_DRIVER) {
304  return sistrip::feDriver_;
305  } else if (granularity == sistrip::FE_UNIT) {
306  return sistrip::feUnit_;
307  } else if (granularity == sistrip::FE_CHAN) {
308  return sistrip::feChan_;
309  } else if (granularity == sistrip::FED_APV) {
310  return sistrip::fedApv_;
311  } else if (granularity == sistrip::FED_CHANNEL) {
312  return sistrip::fedChannel_;
313  }
314  // Control
315  else if (granularity == sistrip::FEC_SYSTEM) {
316  return sistrip::fecSystem_;
317  } else if (granularity == sistrip::FEC_CRATE) {
318  return sistrip::fecCrate_;
319  } else if (granularity == sistrip::FEC_SLOT) {
320  return sistrip::fecSlot_;
321  } else if (granularity == sistrip::FEC_RING) {
322  return sistrip::fecRing_;
323  } else if (granularity == sistrip::CCU_ADDR) {
324  return sistrip::ccuAddr_;
325  } else if (granularity == sistrip::CCU_CHAN) {
326  return sistrip::ccuChan_;
327  }
328  // Unknown
329  else if (granularity == sistrip::UNDEFINED_GRAN) {
330  return sistrip::undefinedGranularity_;
331  } else {
332  return sistrip::unknownGranularity_;
333  }
334 }
335 
336 // -----------------------------------------------------------------------------
337 //
338 sistrip::Granularity SiStripEnumsAndStrings::granularity(const std::string& granularity) {
339  // System
340  if (granularity.find(sistrip::tracker_) != std::string::npos) {
341  return sistrip::TRACKER;
342  } else if (granularity.find(sistrip::partition_) != std::string::npos) {
343  return sistrip::PARTITION;
344  } else if (granularity.find(sistrip::tib_) != std::string::npos) {
345  return sistrip::TIB;
346  } else if (granularity.find(sistrip::tob_) != std::string::npos) {
347  return sistrip::TOB;
348  } else if (granularity.find(sistrip::tec_) != std::string::npos) {
349  return sistrip::TEC;
350  }
351  // Readout
352  else if (granularity.find(sistrip::fedSystem_) != std::string::npos) {
353  return sistrip::FED_SYSTEM;
354  } else if (granularity.find(sistrip::feDriver_) != std::string::npos) {
355  return sistrip::FE_DRIVER;
356  } else if (granularity.find(sistrip::feUnit_) != std::string::npos) {
357  return sistrip::FE_UNIT;
358  } else if (granularity.find(sistrip::feChan_) != std::string::npos) {
359  return sistrip::FE_CHAN;
360  } else if (granularity.find(sistrip::fedApv_) != std::string::npos) {
361  return sistrip::FED_APV;
362  } else if (granularity.find(sistrip::fedChannel_) != std::string::npos) {
363  return sistrip::FED_CHANNEL;
364  }
365  // Control
366  else if (granularity.find(sistrip::fecSystem_) != std::string::npos) {
367  return sistrip::FEC_SYSTEM;
368  } else if (granularity.find(sistrip::fecCrate_) != std::string::npos) {
369  return sistrip::FEC_CRATE;
370  } else if (granularity.find(sistrip::fecSlot_) != std::string::npos) {
371  return sistrip::FEC_SLOT;
372  } else if (granularity.find(sistrip::fecRing_) != std::string::npos) {
373  return sistrip::FEC_RING;
374  } else if (granularity.find(sistrip::ccuAddr_) != std::string::npos) {
375  return sistrip::CCU_ADDR;
376  } else if (granularity.find(sistrip::ccuChan_) != std::string::npos) {
377  return sistrip::CCU_CHAN;
378  }
379  // Sub-structure
380  else if (granularity.find(sistrip::layer_) != std::string::npos) {
381  return sistrip::LAYER;
382  } else if (granularity.find(sistrip::rod_) != std::string::npos) {
383  return sistrip::ROD;
384  } else if (granularity.find(sistrip::string_) != std::string::npos) {
385  return sistrip::STRING;
386  } else if (granularity.find(sistrip::disk_) != std::string::npos) {
387  return sistrip::DISK;
388  } else if (granularity.find(sistrip::petal_) != std::string::npos) {
389  return sistrip::PETAL;
390  } else if (granularity.find(sistrip::ring_) != std::string::npos) {
391  return sistrip::RING;
392  }
393  // Module and below
394  else if (granularity.find(sistrip::module_) != std::string::npos) {
395  return sistrip::MODULE;
396  } else if (granularity.find(sistrip::lldChan_) != std::string::npos) {
397  return sistrip::LLD_CHAN;
398  } else if (granularity.find(sistrip::apv_) != std::string::npos) {
399  return sistrip::APV;
400  } //@@ bug if before "FedApv"!
401  // Unknown
402  else if (granularity.find(sistrip::undefinedGranularity_) != std::string::npos) {
403  return sistrip::UNDEFINED_GRAN;
404  } else if (granularity.empty()) {
405  return sistrip::UNDEFINED_GRAN;
406  } else {
407  return sistrip::UNKNOWN_GRAN;
408  }
409 }
410 
411 // -----------------------------------------------------------------------------
412 //
413 std::string SiStripEnumsAndStrings::apvReadoutMode(const sistrip::ApvReadoutMode& mode) {
414  if (mode == sistrip::APV_PEAK_MODE) {
415  return sistrip::apvPeakMode_;
416  } else if (mode == sistrip::APV_DECON_MODE) {
417  return sistrip::apvDeconMode_;
418  } else if (mode == sistrip::APV_MULTI_MODE) {
419  return sistrip::apvMultiMode_;
420  } else if (mode == sistrip::UNDEFINED_APV_READOUT_MODE) {
421  return sistrip::undefinedApvReadoutMode_;
422  } else {
423  return sistrip::unknownApvReadoutMode_;
424  }
425 }
426 
427 // -----------------------------------------------------------------------------
428 //
429 sistrip::ApvReadoutMode SiStripEnumsAndStrings::apvReadoutMode(const std::string& mode) {
430  if (mode.find(sistrip::apvPeakMode_) != std::string::npos) {
431  return sistrip::APV_PEAK_MODE;
432  } else if (mode.find(sistrip::apvDeconMode_) != std::string::npos) {
433  return sistrip::APV_DECON_MODE;
434  } else if (mode.find(sistrip::apvMultiMode_) != std::string::npos) {
435  return sistrip::APV_MULTI_MODE;
436  } else if (mode.find(sistrip::undefinedApvReadoutMode_) != std::string::npos) {
437  return sistrip::UNDEFINED_APV_READOUT_MODE;
438  } else if (mode.empty()) {
439  return sistrip::UNDEFINED_APV_READOUT_MODE;
440  } else {
441  return sistrip::UNKNOWN_APV_READOUT_MODE;
442  }
443 }
444 
445 // -----------------------------------------------------------------------------
446 //
447 std::string SiStripEnumsAndStrings::fedReadoutMode(const sistrip::FedReadoutMode& mode) {
448  if (mode == sistrip::FED_SCOPE_MODE) {
449  return sistrip::fedScopeMode_;
450  } else if (mode == sistrip::FED_VIRGIN_RAW) {
451  return sistrip::fedVirginRaw_;
452  } else if (mode == sistrip::FED_PROC_RAW) {
453  return sistrip::fedProcRaw_;
454  } else if (mode == sistrip::FED_ZERO_SUPPR) {
455  return sistrip::fedZeroSuppr_;
456  } else if (mode == sistrip::FED_ZERO_SUPPR_LITE) {
457  return sistrip::fedZeroSupprLite_;
458  } else if (mode == sistrip::FED_ZERO_SUPPR_LITE_CMO) {
459  return sistrip::fedZeroSupprLiteCMO_;
460  } else if (mode == sistrip::FED_ZERO_SUPPR_LITE8_TT) {
461  return sistrip::fedZeroSupprLite8TT_;
462  } else if (mode == sistrip::FED_ZERO_SUPPR_LITE8_TT_CMO) {
463  return sistrip::fedZeroSupprLite8TTCMO_;
464  } else if (mode == sistrip::FED_ZERO_SUPPR_LITE8_TB) {
465  return sistrip::fedZeroSupprLite8TB_;
466  } else if (mode == sistrip::FED_ZERO_SUPPR_LITE8_TB_CMO) {
467  return sistrip::fedZeroSupprLite8TBCMO_;
468  } else if (mode == sistrip::FED_ZERO_SUPPR_LITE8_BB) {
469  return sistrip::fedZeroSupprLite8BB_;
470  } else if (mode == sistrip::FED_ZERO_SUPPR_LITE8_BB_CMO) {
471  return sistrip::fedZeroSupprLite8BBCMO_;
472  } else if (mode == sistrip::UNDEFINED_FED_READOUT_MODE) {
473  return sistrip::undefinedFedReadoutMode_;
474  } else {
475  return sistrip::unknownFedReadoutMode_;
476  }
477 }
478 
479 // -----------------------------------------------------------------------------
480 //
481 sistrip::FedReadoutMode SiStripEnumsAndStrings::fedReadoutMode(const std::string& mode) {
482  if (mode.find(sistrip::fedScopeMode_) != std::string::npos) {
483  return sistrip::FED_SCOPE_MODE;
484  } else if (mode.find(sistrip::fedVirginRaw_) != std::string::npos) {
485  return sistrip::FED_VIRGIN_RAW;
486  } else if (mode.find(sistrip::fedProcRaw_) != std::string::npos) {
487  return sistrip::FED_PROC_RAW;
488  } else if (mode.find(sistrip::fedZeroSuppr_) != std::string::npos) {
489  return sistrip::FED_ZERO_SUPPR;
490  } else if (mode.find(sistrip::fedZeroSupprLite_) != std::string::npos) {
491  return sistrip::FED_ZERO_SUPPR_LITE;
492  } else if (mode.find(sistrip::fedZeroSupprLiteCMO_) != std::string::npos) {
493  return sistrip::FED_ZERO_SUPPR_LITE_CMO;
494  } else if (mode.find(sistrip::fedZeroSupprLite8TT_) != std::string::npos) {
495  return sistrip::FED_ZERO_SUPPR_LITE8_TT;
496  } else if (mode.find(sistrip::fedZeroSupprLite8TTCMO_) != std::string::npos) {
497  return sistrip::FED_ZERO_SUPPR_LITE8_TT_CMO;
498  } else if (mode.find(sistrip::fedZeroSupprLite8TB_) != std::string::npos) {
499  return sistrip::FED_ZERO_SUPPR_LITE8_TB;
500  } else if (mode.find(sistrip::fedZeroSupprLite8TBCMO_) != std::string::npos) {
501  return sistrip::FED_ZERO_SUPPR_LITE8_TB_CMO;
502  } else if (mode.find(sistrip::fedZeroSupprLite8BB_) != std::string::npos) {
503  return sistrip::FED_ZERO_SUPPR_LITE8_BB;
504  } else if (mode.find(sistrip::fedZeroSupprLite8BBCMO_) != std::string::npos) {
505  return sistrip::FED_ZERO_SUPPR_LITE8_BB_CMO;
506  } else if (mode.find(sistrip::undefinedFedReadoutMode_) != std::string::npos) {
507  return sistrip::UNDEFINED_FED_READOUT_MODE;
508  } else if (mode.empty()) {
509  return sistrip::UNDEFINED_FED_READOUT_MODE;
510  } else {
511  return sistrip::UNKNOWN_FED_READOUT_MODE;
512  }
513 }
514 
515 // -----------------------------------------------------------------------------
516 //
517 std::string SiStripEnumsAndStrings::histoType(const sistrip::HistoType& type) {
518  if (type == sistrip::EXPERT_HISTO) {
519  return sistrip::expertHisto_;
520  } else if (type == sistrip::SUMMARY_HISTO) {
521  return sistrip::summaryHisto_;
522  } else if (type == sistrip::UNDEFINED_HISTO_TYPE) {
523  return sistrip::undefinedHistoType_;
524  } else {
525  return sistrip::unknownHistoType_;
526  }
527 }
528 
529 // -----------------------------------------------------------------------------
530 //
531 sistrip::HistoType SiStripEnumsAndStrings::histoType(const std::string& type) {
532  if (type.find(sistrip::expertHisto_) != std::string::npos) {
533  return sistrip::EXPERT_HISTO;
534  } else if (type.find(sistrip::summaryHisto_) != std::string::npos) {
535  return sistrip::SUMMARY_HISTO;
536  } else if (type.find(sistrip::undefinedHistoType_) != std::string::npos) {
537  return sistrip::UNDEFINED_HISTO_TYPE;
538  } else if (type.empty()) {
539  return sistrip::UNDEFINED_HISTO_TYPE;
540  } else {
541  return sistrip::UNKNOWN_HISTO_TYPE;
542  }
543 }
544 
545 // -----------------------------------------------------------------------------
546 //
547 std::string SiStripEnumsAndStrings::monitorable(const sistrip::Monitorable& mon) {
548  // fed cabling
549  if (mon == sistrip::FED_CABLING_FED_ID) {
550  return sistrip::fedCablingFedId_;
551  } else if (mon == sistrip::FED_CABLING_FED_CH) {
552  return sistrip::fedCablingFedCh_;
553  } else if (mon == sistrip::FED_CABLING_ADC_LEVEL) {
554  return sistrip::fedCablingAdcLevel_;
555  }
556 
557  // fast fed cabling
558  else if (mon == sistrip::FAST_CABLING_DCU_ID) {
559  return sistrip::fastCablingDcuId_;
560  } else if (mon == sistrip::FAST_CABLING_LLD_CH) {
561  return sistrip::fastCablingLldCh_;
562  } else if (mon == sistrip::FAST_CABLING_HIGH_LEVEL) {
563  return sistrip::fastCablingHighLevel_;
564  } else if (mon == sistrip::FAST_CABLING_HIGH_RMS) {
565  return sistrip::fastCablingHighRms_;
566  } else if (mon == sistrip::FAST_CABLING_LOW_LEVEL) {
567  return sistrip::fastCablingLowLevel_;
568  } else if (mon == sistrip::FAST_CABLING_LOW_RMS) {
569  return sistrip::fastCablingLowRms_;
570  } else if (mon == sistrip::FAST_CABLING_MAX) {
571  return sistrip::fastCablingMax_;
572  } else if (mon == sistrip::FAST_CABLING_MIN) {
573  return sistrip::fastCablingMin_;
574  } else if (mon == sistrip::FAST_CABLING_CONNS_PER_FED) {
575  return sistrip::fastCablingConnsPerFed_;
576  }
577 
578  // apv timing
579  else if (mon == sistrip::APV_TIMING_TIME) {
580  return sistrip::apvTimingTime_;
581  } else if (mon == sistrip::APV_TIMING_MAX_TIME) {
582  return sistrip::apvTimingMax_;
583  } else if (mon == sistrip::APV_TIMING_DELAY) {
584  return sistrip::apvTimingDelay_;
585  } else if (mon == sistrip::APV_TIMING_ERROR) {
586  return sistrip::apvTimingError_;
587  } else if (mon == sistrip::APV_TIMING_BASE) {
588  return sistrip::apvTimingBase_;
589  } else if (mon == sistrip::APV_TIMING_PEAK) {
590  return sistrip::apvTimingPeak_;
591  } else if (mon == sistrip::APV_TIMING_HEIGHT) {
592  return sistrip::apvTimingHeight_;
593  }
594 
595  // fed timing
596  else if (mon == sistrip::FED_TIMING_TIME) {
597  return sistrip::fedTimingTime_;
598  } else if (mon == sistrip::FED_TIMING_MAX_TIME) {
599  return sistrip::fedTimingMax_;
600  } else if (mon == sistrip::FED_TIMING_DELAY) {
601  return sistrip::fedTimingDelay_;
602  } else if (mon == sistrip::FED_TIMING_ERROR) {
603  return sistrip::fedTimingError_;
604  } else if (mon == sistrip::FED_TIMING_BASE) {
605  return sistrip::fedTimingBase_;
606  } else if (mon == sistrip::FED_TIMING_PEAK) {
607  return sistrip::fedTimingPeak_;
608  } else if (mon == sistrip::FED_TIMING_HEIGHT) {
609  return sistrip::fedTimingHeight_;
610  }
611 
612  // opto scan
613  else if (mon == sistrip::OPTO_SCAN_LLD_GAIN_SETTING) {
614  return sistrip::optoScanLldGain_;
615  } else if (mon == sistrip::OPTO_SCAN_LLD_BIAS_SETTING) {
616  return sistrip::optoScanLldBias_;
617  } else if (mon == sistrip::OPTO_SCAN_MEASURED_GAIN) {
618  return sistrip::optoScanMeasGain_;
619  } else if (mon == sistrip::OPTO_SCAN_ZERO_LIGHT_LEVEL) {
620  return sistrip::optoScanZeroLight_;
621  } else if (mon == sistrip::OPTO_SCAN_LINK_NOISE) {
622  return sistrip::optoScanLinkNoise_;
623  } else if (mon == sistrip::OPTO_SCAN_BASELINE_LIFT_OFF) {
624  return sistrip::optoScanBaseLiftOff_;
625  } else if (mon == sistrip::OPTO_SCAN_LASER_THRESHOLD) {
626  return sistrip::optoScanLaserThresh_;
627  } else if (mon == sistrip::OPTO_SCAN_TICK_HEIGHT) {
628  return sistrip::optoScanTickHeight_;
629  }
630 
631  // vpsp scan
632  else if (mon == sistrip::VPSP_SCAN_APV_SETTINGS) {
633  return sistrip::vpspScanBothApvs_;
634  } else if (mon == sistrip::VPSP_SCAN_APV0_SETTING) {
635  return sistrip::vpspScanApv0_;
636  } else if (mon == sistrip::VPSP_SCAN_APV1_SETTING) {
637  return sistrip::vpspScanApv1_;
638  } else if (mon == sistrip::VPSP_SCAN_ADC_LEVEL) {
639  return sistrip::vpspScanAdcLevel_;
640  } else if (mon == sistrip::VPSP_SCAN_DIGITAL_HIGH) {
641  return sistrip::vpspScanDigitalHigh_;
642  } else if (mon == sistrip::VPSP_SCAN_DIGITAL_LOW) {
643  return sistrip::vpspScanDigitalLow_;
644  }
645 
646  // pedestals / noise
647  else if (mon == sistrip::PEDESTALS_ALL_STRIPS) {
648  return sistrip::pedestalsAllStrips_;
649  } else if (mon == sistrip::PEDESTALS_MEAN) {
650  return sistrip::pedestalsMean_;
651  } else if (mon == sistrip::PEDESTALS_SPREAD) {
652  return sistrip::pedestalsSpread_;
653  } else if (mon == sistrip::PEDESTALS_MAX) {
654  return sistrip::pedestalsMax_;
655  } else if (mon == sistrip::PEDESTALS_MIN) {
656  return sistrip::pedestalsMin_;
657  } else if (mon == sistrip::NOISE_ALL_STRIPS) {
658  return sistrip::noiseAllStrips_;
659  } else if (mon == sistrip::NOISE_MEAN) {
660  return sistrip::noiseMean_;
661  } else if (mon == sistrip::NOISE_SPREAD) {
662  return sistrip::noiseSpread_;
663  } else if (mon == sistrip::NOISE_MAX) {
664  return sistrip::noiseMax_;
665  } else if (mon == sistrip::NOISE_MIN) {
666  return sistrip::noiseMin_;
667  } else if (mon == sistrip::NUM_OF_DEAD) {
668  return sistrip::numOfDeadStrips_;
669  } else if (mon == sistrip::NUM_OF_NOISY) {
670  return sistrip::numOfNoisy_;
671  } else if (mon == sistrip::NUM_OF_BAD) {
672  return sistrip::numOfBadStrips_;
673  } else if (mon == sistrip::NUM_OF_BAD_SHIFTED) {
674  return sistrip::numOfBadShiftedStrips_;
675  } else if (mon == sistrip::NUM_OF_BAD_LOW_NOISE) {
676  return sistrip::numOfBadLowNoiseStrips_;
677  } else if (mon == sistrip::NUM_OF_BAD_LARGE_NOISE) {
678  return sistrip::numOfBadLargeNoiseStrips_;
679  } else if (mon == sistrip::NUM_OF_BAD_LARGE_SIGNIF) {
680  return sistrip::numOfBadLargeNoiseSignificanceStrips_;
681  } else if (mon == sistrip::NUM_OF_BAD_FIT_STATUS) {
682  return sistrip::numOfBadFitStatusStrips_;
683  } else if (mon == sistrip::NUM_OF_BAD_AD_PROBAB) {
684  return sistrip::numOfBadADProbabStrips_;
685  } else if (mon == sistrip::NUM_OF_BAD_KS_PROBAB) {
686  return sistrip::numOfBadKSProbabStrips_;
687  } else if (mon == sistrip::NUM_OF_BAD_JB_PROBAB) {
688  return sistrip::numOfBadJBProbabStrips_;
689  } else if (mon == sistrip::NUM_OF_BAD_CHI2_PROBAB) {
690  return sistrip::numOfBadChi2ProbabStrips_;
691  } else if (mon == sistrip::NUM_OF_BAD_TAIL) {
692  return sistrip::numOfBadTailStrips_;
693  } else if (mon == sistrip::NUM_OF_BAD_DOUBLE_PEAK) {
694  return sistrip::numOfBadDoublePeakStrips_;
695  }
696 
697  else if (mon == sistrip::BAD_STRIP_BIT_ALL_STRIPS) {
698  return sistrip::badStripBit_;
699  } else if (mon == sistrip::DEAD_STRIP_BIT_ALL_STRIPS) {
700  return sistrip::deadStripBit_;
701  } else if (mon == sistrip::AD_PROBAB_ALL_STRIPS) {
702  return sistrip::adProbabAllStrips_;
703  } else if (mon == sistrip::KS_PROBAB_ALL_STRIPS) {
704  return sistrip::ksProbabAllStrips_;
705  } else if (mon == sistrip::JB_PROBAB_ALL_STRIPS) {
706  return sistrip::jbProbabAllStrips_;
707  } else if (mon == sistrip::CHI2_PROBAB_ALL_STRIPS) {
708  return sistrip::chi2ProbabAllStrips_;
709  } else if (mon == sistrip::RESIDUAL_RMS_ALL_STRIPS) {
710  return sistrip::residualRMSAllStrips_;
711  } else if (mon == sistrip::RESIDUAL_GAUS_ALL_STRIPS) {
712  return sistrip::residualSigmaGausAllStrips_;
713  } else if (mon == sistrip::NOISE_SIGNIFICANCE_ALL_STRIPS) {
714  return sistrip::noiseSignificanceAllStrips_;
715  } else if (mon == sistrip::RESIDUAL_MEAN_ALL_STRIPS) {
716  return sistrip::residualMeanAllStrips_;
717  } else if (mon == sistrip::RESIDUAL_SKEWNESS_ALL_STRIPS) {
718  return sistrip::residualSkewnessAllStrips_;
719  } else if (mon == sistrip::RESIDUAL_KURTOSIS_ALL_STRIPS) {
720  return sistrip::residualKurtosisAllStrips_;
721  } else if (mon == sistrip::RESIDUAL_INTEGRALNSIGMA_ALL_STRIPS) {
722  return sistrip::residualIntegralNsigmaAllStrips_;
723  } else if (mon == sistrip::RESIDUAL_INTEGRAL_ALL_STRIPS) {
724  return sistrip::residualIntegralAllStrips_;
725  }
726 
727  // fine delay
728  else if (mon == sistrip::FINE_DELAY_POS) {
729  return sistrip::fineDelayPos_;
730  } else if (mon == sistrip::FINE_DELAY_ERROR) {
731  return sistrip::fineDelayErr_;
732  }
733 
734  else if (mon == sistrip::CALIBRATION_AMPLITUDE_MEAN) {
735  return sistrip::calibrationAmplitudeMean_;
736  } else if (mon == sistrip::CALIBRATION_TAIL_MEAN) {
737  return sistrip::calibrationTailMean_;
738  } else if (mon == sistrip::CALIBRATION_RISETIME_MEAN) {
739  return sistrip::calibrationRiseTimeMean_;
740  } else if (mon == sistrip::CALIBRATION_DECAYTIME_MEAN) {
741  return sistrip::calibrationDecayTimeMean_;
742  } else if (mon == sistrip::CALIBRATION_PEAKTIME_MEAN) {
743  return sistrip::calibrationPeakTimeMean_;
744  } else if (mon == sistrip::CALIBRATION_TURNON_MEAN) {
745  return sistrip::calibrationTurnOnMean_;
746  } else if (mon == sistrip::CALIBRATION_BASELINE_MEAN) {
747  return sistrip::calibrationBaselineMean_;
748  } else if (mon == sistrip::CALIBRATION_UNDERSHOOT_MEAN) {
749  return sistrip::calibrationUndershootMean_;
750  } else if (mon == sistrip::CALIBRATION_SMEARING_MEAN) {
751  return sistrip::calibrationSmearingMean_;
752  } else if (mon == sistrip::CALIBRATION_CHI2_MEAN) {
753  return sistrip::calibrationChi2Mean_;
754  }
755 
756  else if (mon == sistrip::CALIBRATION_AMPLITUDE_MIN) {
757  return sistrip::calibrationAmplitudeMin_;
758  } else if (mon == sistrip::CALIBRATION_TAIL_MIN) {
759  return sistrip::calibrationTailMin_;
760  } else if (mon == sistrip::CALIBRATION_RISETIME_MIN) {
761  return sistrip::calibrationRiseTimeMin_;
762  } else if (mon == sistrip::CALIBRATION_DECAYTIME_MIN) {
763  return sistrip::calibrationDecayTimeMin_;
764  } else if (mon == sistrip::CALIBRATION_PEAKTIME_MIN) {
765  return sistrip::calibrationPeakTimeMin_;
766  } else if (mon == sistrip::CALIBRATION_TURNON_MIN) {
767  return sistrip::calibrationTurnOnMin_;
768  } else if (mon == sistrip::CALIBRATION_BASELINE_MIN) {
769  return sistrip::calibrationBaselineMin_;
770  } else if (mon == sistrip::CALIBRATION_UNDERSHOOT_MIN) {
771  return sistrip::calibrationUndershootMin_;
772  } else if (mon == sistrip::CALIBRATION_SMEARING_MIN) {
773  return sistrip::calibrationSmearingMin_;
774  } else if (mon == sistrip::CALIBRATION_CHI2_MIN) {
775  return sistrip::calibrationChi2Min_;
776  }
777 
778  else if (mon == sistrip::CALIBRATION_AMPLITUDE_MAX) {
779  return sistrip::calibrationAmplitudeMax_;
780  } else if (mon == sistrip::CALIBRATION_TAIL_MAX) {
781  return sistrip::calibrationTailMax_;
782  } else if (mon == sistrip::CALIBRATION_RISETIME_MAX) {
783  return sistrip::calibrationRiseTimeMax_;
784  } else if (mon == sistrip::CALIBRATION_DECAYTIME_MAX) {
785  return sistrip::calibrationDecayTimeMax_;
786  } else if (mon == sistrip::CALIBRATION_PEAKTIME_MAX) {
787  return sistrip::calibrationPeakTimeMax_;
788  } else if (mon == sistrip::CALIBRATION_TURNON_MAX) {
789  return sistrip::calibrationTurnOnMax_;
790  } else if (mon == sistrip::CALIBRATION_BASELINE_MAX) {
791  return sistrip::calibrationBaselineMax_;
792  } else if (mon == sistrip::CALIBRATION_UNDERSHOOT_MAX) {
793  return sistrip::calibrationUndershootMax_;
794  } else if (mon == sistrip::CALIBRATION_SMEARING_MAX) {
795  return sistrip::calibrationSmearingMax_;
796  } else if (mon == sistrip::CALIBRATION_CHI2_MAX) {
797  return sistrip::calibrationChi2Max_;
798  }
799 
800  else if (mon == sistrip::CALIBRATION_AMPLITUDE_SPREAD) {
801  return sistrip::calibrationAmplitudeSpread_;
802  } else if (mon == sistrip::CALIBRATION_TAIL_SPREAD) {
803  return sistrip::calibrationTailSpread_;
804  } else if (mon == sistrip::CALIBRATION_RISETIME_SPREAD) {
805  return sistrip::calibrationRiseTimeSpread_;
806  } else if (mon == sistrip::CALIBRATION_DECAYTIME_SPREAD) {
807  return sistrip::calibrationDecayTimeSpread_;
808  } else if (mon == sistrip::CALIBRATION_PEAKTIME_SPREAD) {
809  return sistrip::calibrationPeakTimeSpread_;
810  } else if (mon == sistrip::CALIBRATION_TURNON_SPREAD) {
811  return sistrip::calibrationTurnOnSpread_;
812  } else if (mon == sistrip::CALIBRATION_BASELINE_SPREAD) {
813  return sistrip::calibrationBaselineSpread_;
814  } else if (mon == sistrip::CALIBRATION_UNDERSHOOT_SPREAD) {
815  return sistrip::calibrationUndershootSpread_;
816  } else if (mon == sistrip::CALIBRATION_SMEARING_SPREAD) {
817  return sistrip::calibrationSmearingSpread_;
818  } else if (mon == sistrip::CALIBRATION_CHI2_SPREAD) {
819  return sistrip::calibrationChi2Spread_;
820  }
821 
822  else if (mon == sistrip::CALIBRATION_AMPLITUDE_ALL_STRIPS) {
823  return sistrip::calibrationAmplitude_;
824  } else if (mon == sistrip::CALIBRATION_TAIL_ALL_STRIPS) {
825  return sistrip::calibrationTail_;
826  } else if (mon == sistrip::CALIBRATION_RISETIME_ALL_STRIPS) {
827  return sistrip::calibrationRiseTime_;
828  } else if (mon == sistrip::CALIBRATION_DECAYTIME_ALL_STRIPS) {
829  return sistrip::calibrationDecayTime_;
830  } else if (mon == sistrip::CALIBRATION_PEAKTIME_ALL_STRIPS) {
831  return sistrip::calibrationPeakTime_;
832  } else if (mon == sistrip::CALIBRATION_TURNON_ALL_STRIPS) {
833  return sistrip::calibrationTurnOn_;
834  } else if (mon == sistrip::CALIBRATION_BASELINE_ALL_STRIPS) {
835  return sistrip::calibrationBaseline_;
836  } else if (mon == sistrip::CALIBRATION_UNDERSHOOT_ALL_STRIPS) {
837  return sistrip::calibrationUndershoot_;
838  } else if (mon == sistrip::CALIBRATION_SMEARING_ALL_STRIPS) {
839  return sistrip::calibrationSmearing_;
840  } else if (mon == sistrip::CALIBRATION_CHI2_ALL_STRIPS) {
841  return sistrip::calibrationChi2_;
842  }
843 
844  else if (mon == sistrip::CALIBRATION_AMPLITUDE_TUNED) {
845  return sistrip::calibrationAmplitudeTuned_;
846  } else if (mon == sistrip::CALIBRATION_TAIL_TUNED) {
847  return sistrip::calibrationTailTuned_;
848  } else if (mon == sistrip::CALIBRATION_RISETIME_TUNED) {
849  return sistrip::calibrationRiseTimeTuned_;
850  } else if (mon == sistrip::CALIBRATION_DECAYTIME_TUNED) {
851  return sistrip::calibrationDecayTimeTuned_;
852  } else if (mon == sistrip::CALIBRATION_PEAKTIME_TUNED) {
853  return sistrip::calibrationPeakTimeTuned_;
854  } else if (mon == sistrip::CALIBRATION_TURNON_TUNED) {
855  return sistrip::calibrationTurnOnTuned_;
856  } else if (mon == sistrip::CALIBRATION_BASELINE_TUNED) {
857  return sistrip::calibrationBaselineTuned_;
858  } else if (mon == sistrip::CALIBRATION_UNDERSHOOT_TUNED) {
859  return sistrip::calibrationUndershootTuned_;
860  } else if (mon == sistrip::CALIBRATION_SMEARING_TUNED) {
861  return sistrip::calibrationSmearingTuned_;
862  } else if (mon == sistrip::CALIBRATION_CHI2_TUNED) {
863  return sistrip::calibrationChi2Tuned_;
864  } else if (mon == sistrip::CALIBRATION_ISHA_TUNED) {
865  return sistrip::calibrationISHATuned_;
866  } else if (mon == sistrip::CALIBRATION_VFS_TUNED) {
867  return sistrip::calibrationVFSTuned_;
868  } else if (mon == sistrip::CALIBRATION_ISHA_BEST) {
869  return sistrip::calibrationISHABest_;
870  } else if (mon == sistrip::CALIBRATION_VFS_BEST) {
871  return sistrip::calibrationVFSBest_;
872  }
873 
874  // scope mode
875  else if (mon == sistrip::DAQ_SCOPE_MODE_MEAN_SIGNAL) {
876  return sistrip::daqScopeModeMeanSignal_;
877  }
878 
879  // unknown
880  else if (mon == sistrip::UNDEFINED_MONITORABLE) {
881  return sistrip::undefinedMonitorable_;
882  } else {
883  return sistrip::unknownMonitorable_;
884  }
885 }
886 
887 // -----------------------------------------------------------------------------
888 //
889 sistrip::Monitorable SiStripEnumsAndStrings::monitorable(const std::string& mon) {
890  // fed cabling
891  if (mon.find(sistrip::fedCablingFedId_) != std::string::npos) {
892  return sistrip::FED_CABLING_FED_ID;
893  } else if (mon.find(sistrip::fedCablingFedCh_) != std::string::npos) {
894  return sistrip::FED_CABLING_FED_CH;
895  } else if (mon.find(sistrip::fedCablingAdcLevel_) != std::string::npos) {
896  return sistrip::FED_CABLING_ADC_LEVEL;
897  }
898 
899  // fed cabling
900  else if (mon.find(sistrip::fastCablingDcuId_) != std::string::npos) {
901  return sistrip::FAST_CABLING_DCU_ID;
902  } else if (mon.find(sistrip::fastCablingLldCh_) != std::string::npos) {
903  return sistrip::FAST_CABLING_LLD_CH;
904  } else if (mon.find(sistrip::fastCablingHighLevel_) != std::string::npos) {
905  return sistrip::FAST_CABLING_HIGH_LEVEL;
906  } else if (mon.find(sistrip::fastCablingHighRms_) != std::string::npos) {
907  return sistrip::FAST_CABLING_HIGH_RMS;
908  } else if (mon.find(sistrip::fastCablingLowLevel_) != std::string::npos) {
909  return sistrip::FAST_CABLING_LOW_LEVEL;
910  } else if (mon.find(sistrip::fastCablingLowRms_) != std::string::npos) {
911  return sistrip::FAST_CABLING_LOW_RMS;
912  } else if (mon.find(sistrip::fastCablingMax_) != std::string::npos) {
913  return sistrip::FAST_CABLING_MAX;
914  } else if (mon.find(sistrip::fastCablingMin_) != std::string::npos) {
915  return sistrip::FAST_CABLING_MIN;
916  } else if (mon.find(sistrip::fastCablingConnsPerFed_) != std::string::npos) {
917  return sistrip::FAST_CABLING_CONNS_PER_FED;
918  }
919 
920  // apv timing
921  else if (mon.find(sistrip::apvTimingTime_) != std::string::npos) {
922  return sistrip::APV_TIMING_TIME;
923  } else if (mon.find(sistrip::apvTimingMax_) != std::string::npos) {
924  return sistrip::APV_TIMING_MAX_TIME;
925  } else if (mon.find(sistrip::apvTimingDelay_) != std::string::npos) {
926  return sistrip::APV_TIMING_DELAY;
927  } else if (mon.find(sistrip::apvTimingError_) != std::string::npos) {
928  return sistrip::APV_TIMING_ERROR;
929  } else if (mon.find(sistrip::apvTimingBase_) != std::string::npos) {
930  return sistrip::APV_TIMING_BASE;
931  } else if (mon.find(sistrip::apvTimingPeak_) != std::string::npos) {
932  return sistrip::APV_TIMING_PEAK;
933  } else if (mon.find(sistrip::apvTimingHeight_) != std::string::npos) {
934  return sistrip::APV_TIMING_HEIGHT;
935  }
936 
937  // fed timing
938  else if (mon.find(sistrip::fedTimingTime_) != std::string::npos) {
939  return sistrip::FED_TIMING_TIME;
940  } else if (mon.find(sistrip::fedTimingMax_) != std::string::npos) {
941  return sistrip::FED_TIMING_MAX_TIME;
942  } else if (mon.find(sistrip::fedTimingDelay_) != std::string::npos) {
943  return sistrip::FED_TIMING_DELAY;
944  } else if (mon.find(sistrip::fedTimingError_) != std::string::npos) {
945  return sistrip::FED_TIMING_ERROR;
946  } else if (mon.find(sistrip::fedTimingBase_) != std::string::npos) {
947  return sistrip::FED_TIMING_BASE;
948  } else if (mon.find(sistrip::fedTimingPeak_) != std::string::npos) {
949  return sistrip::FED_TIMING_PEAK;
950  } else if (mon.find(sistrip::fedTimingHeight_) != std::string::npos) {
951  return sistrip::FED_TIMING_HEIGHT;
952  }
953 
954  // opto scan
955  else if (mon.find(sistrip::optoScanLldGain_) != std::string::npos) {
956  return sistrip::OPTO_SCAN_LLD_GAIN_SETTING;
957  } else if (mon.find(sistrip::optoScanLldBias_) != std::string::npos) {
958  return sistrip::OPTO_SCAN_LLD_BIAS_SETTING;
959  } else if (mon.find(sistrip::optoScanMeasGain_) != std::string::npos) {
960  return sistrip::OPTO_SCAN_MEASURED_GAIN;
961  } else if (mon.find(sistrip::optoScanZeroLight_) != std::string::npos) {
962  return sistrip::OPTO_SCAN_ZERO_LIGHT_LEVEL;
963  } else if (mon.find(sistrip::optoScanLinkNoise_) != std::string::npos) {
964  return sistrip::OPTO_SCAN_LINK_NOISE;
965  } else if (mon.find(sistrip::optoScanBaseLiftOff_) != std::string::npos) {
966  return sistrip::OPTO_SCAN_BASELINE_LIFT_OFF;
967  } else if (mon.find(sistrip::optoScanLaserThresh_) != std::string::npos) {
968  return sistrip::OPTO_SCAN_LASER_THRESHOLD;
969  } else if (mon.find(sistrip::optoScanTickHeight_) != std::string::npos) {
970  return sistrip::OPTO_SCAN_TICK_HEIGHT;
971  }
972 
973  // vpsp scan
974  else if (mon.find(sistrip::vpspScanBothApvs_) != std::string::npos) {
975  return sistrip::VPSP_SCAN_APV_SETTINGS;
976  } else if (mon.find(sistrip::vpspScanApv0_) != std::string::npos) {
977  return sistrip::VPSP_SCAN_APV0_SETTING;
978  } else if (mon.find(sistrip::vpspScanApv1_) != std::string::npos) {
979  return sistrip::VPSP_SCAN_APV1_SETTING;
980  } else if (mon.find(sistrip::vpspScanAdcLevel_) != std::string::npos) {
981  return sistrip::VPSP_SCAN_ADC_LEVEL;
982  } else if (mon.find(sistrip::vpspScanDigitalHigh_) != std::string::npos) {
983  return sistrip::VPSP_SCAN_DIGITAL_HIGH;
984  } else if (mon.find(sistrip::vpspScanDigitalLow_) != std::string::npos) {
985  return sistrip::VPSP_SCAN_DIGITAL_LOW;
986  }
987 
988  // pedestals / noise
989  else if (mon.find(sistrip::pedestalsAllStrips_) != std::string::npos) {
990  return sistrip::PEDESTALS_ALL_STRIPS;
991  } else if (mon.find(sistrip::pedestalsMean_) != std::string::npos) {
992  return sistrip::PEDESTALS_MEAN;
993  } else if (mon.find(sistrip::pedestalsSpread_) != std::string::npos) {
994  return sistrip::PEDESTALS_SPREAD;
995  } else if (mon.find(sistrip::pedestalsMax_) != std::string::npos) {
996  return sistrip::PEDESTALS_MAX;
997  } else if (mon.find(sistrip::pedestalsMin_) != std::string::npos) {
998  return sistrip::PEDESTALS_MIN;
999  }
1000 
1001  // noiseKS must come before the more general noiseAllStrips, since it contains that string
1002  else if (mon.find(sistrip::noiseAllStrips_) != std::string::npos) {
1003  return sistrip::NOISE_ALL_STRIPS;
1004  } else if (mon.find(sistrip::noiseMean_) != std::string::npos) {
1005  return sistrip::NOISE_MEAN;
1006  } else if (mon.find(sistrip::noiseSpread_) != std::string::npos) {
1007  return sistrip::NOISE_SPREAD;
1008  } else if (mon.find(sistrip::noiseMax_) != std::string::npos) {
1009  return sistrip::NOISE_MAX;
1010  } else if (mon.find(sistrip::noiseMin_) != std::string::npos) {
1011  return sistrip::NOISE_MIN;
1012  } else if (mon.find(sistrip::numOfDeadStrips_) != std::string::npos) {
1013  return sistrip::NUM_OF_DEAD;
1014  } else if (mon.find(sistrip::numOfNoisy_) != std::string::npos) {
1015  return sistrip::NUM_OF_NOISY;
1016  } else if (mon.find(sistrip::numOfBadStrips_) != std::string::npos) {
1017  return sistrip::NUM_OF_BAD;
1018  } else if (mon.find(sistrip::numOfBadShiftedStrips_) != std::string::npos) {
1019  return sistrip::NUM_OF_BAD_SHIFTED;
1020  } else if (mon.find(sistrip::numOfBadLowNoiseStrips_) != std::string::npos) {
1021  return sistrip::NUM_OF_BAD_LOW_NOISE;
1022  } else if (mon.find(sistrip::numOfBadLargeNoiseStrips_) != std::string::npos) {
1023  return sistrip::NUM_OF_BAD_LARGE_NOISE;
1024  } else if (mon.find(sistrip::numOfBadLargeNoiseSignificanceStrips_) != std::string::npos) {
1025  return sistrip::NUM_OF_BAD_LARGE_SIGNIF;
1026  } else if (mon.find(sistrip::numOfBadFitStatusStrips_) != std::string::npos) {
1027  return sistrip::NUM_OF_BAD_FIT_STATUS;
1028  } else if (mon.find(sistrip::numOfBadADProbabStrips_) != std::string::npos) {
1029  return sistrip::NUM_OF_BAD_AD_PROBAB;
1030  } else if (mon.find(sistrip::numOfBadKSProbabStrips_) != std::string::npos) {
1031  return sistrip::NUM_OF_BAD_KS_PROBAB;
1032  } else if (mon.find(sistrip::numOfBadJBProbabStrips_) != std::string::npos) {
1033  return sistrip::NUM_OF_BAD_JB_PROBAB;
1034  } else if (mon.find(sistrip::numOfBadChi2ProbabStrips_) != std::string::npos) {
1035  return sistrip::NUM_OF_BAD_CHI2_PROBAB;
1036  } else if (mon.find(sistrip::numOfBadTailStrips_) != std::string::npos) {
1037  return sistrip::NUM_OF_BAD_TAIL;
1038  } else if (mon.find(sistrip::numOfBadDoublePeakStrips_) != std::string::npos) {
1039  return sistrip::NUM_OF_BAD_DOUBLE_PEAK;
1040  }
1041 
1042  else if (mon.find(sistrip::badStripBit_) != std::string::npos) {
1043  return sistrip::BAD_STRIP_BIT_ALL_STRIPS;
1044  } else if (mon.find(sistrip::deadStripBit_) != std::string::npos) {
1045  return sistrip::DEAD_STRIP_BIT_ALL_STRIPS;
1046  } else if (mon.find(sistrip::adProbabAllStrips_) != std::string::npos) {
1047  return sistrip::AD_PROBAB_ALL_STRIPS;
1048  } else if (mon.find(sistrip::ksProbabAllStrips_) != std::string::npos) {
1049  return sistrip::KS_PROBAB_ALL_STRIPS;
1050  } else if (mon.find(sistrip::jbProbabAllStrips_) != std::string::npos) {
1051  return sistrip::JB_PROBAB_ALL_STRIPS;
1052  } else if (mon.find(sistrip::chi2ProbabAllStrips_) != std::string::npos) {
1053  return sistrip::CHI2_PROBAB_ALL_STRIPS;
1054  } else if (mon.find(sistrip::residualRMSAllStrips_) != std::string::npos) {
1055  return sistrip::RESIDUAL_RMS_ALL_STRIPS;
1056  } else if (mon.find(sistrip::residualSigmaGausAllStrips_) != std::string::npos) {
1057  return sistrip::RESIDUAL_GAUS_ALL_STRIPS;
1058  } else if (mon.find(sistrip::noiseSignificanceAllStrips_) != std::string::npos) {
1059  return sistrip::NOISE_SIGNIFICANCE_ALL_STRIPS;
1060  } else if (mon.find(sistrip::residualMeanAllStrips_) != std::string::npos) {
1061  return sistrip::RESIDUAL_MEAN_ALL_STRIPS;
1062  } else if (mon.find(sistrip::residualSkewnessAllStrips_) != std::string::npos) {
1063  return sistrip::RESIDUAL_SKEWNESS_ALL_STRIPS;
1064  } else if (mon.find(sistrip::residualKurtosisAllStrips_) != std::string::npos) {
1065  return sistrip::RESIDUAL_KURTOSIS_ALL_STRIPS;
1066  } else if (mon.find(sistrip::residualIntegralNsigmaAllStrips_) != std::string::npos) {
1067  return sistrip::RESIDUAL_INTEGRALNSIGMA_ALL_STRIPS;
1068  } else if (mon.find(sistrip::residualIntegralAllStrips_) != std::string::npos) {
1069  return sistrip::RESIDUAL_INTEGRAL_ALL_STRIPS;
1070  }
1071 
1072  // fine delay
1073  else if (mon.find(sistrip::fineDelayPos_) != std::string::npos) {
1074  return sistrip::FINE_DELAY_POS;
1075  } else if (mon.find(sistrip::fineDelayErr_) != std::string::npos) {
1076  return sistrip::FINE_DELAY_ERROR;
1077  }
1078 
1079  // calibration
1080  else if (mon.find(sistrip::calibrationAmplitudeMean_) != std::string::npos) {
1081  return sistrip::CALIBRATION_AMPLITUDE_MEAN;
1082  } else if (mon.find(sistrip::calibrationTailMean_) != std::string::npos) {
1083  return sistrip::CALIBRATION_TAIL_MEAN;
1084  } else if (mon.find(sistrip::calibrationRiseTimeMean_) != std::string::npos) {
1085  return sistrip::CALIBRATION_RISETIME_MEAN;
1086  } else if (mon.find(sistrip::calibrationDecayTimeMean_) != std::string::npos) {
1087  return sistrip::CALIBRATION_DECAYTIME_MEAN;
1088  } else if (mon.find(sistrip::calibrationPeakTimeMean_) != std::string::npos) {
1089  return sistrip::CALIBRATION_PEAKTIME_MEAN;
1090  } else if (mon.find(sistrip::calibrationTurnOnMean_) != std::string::npos) {
1091  return sistrip::CALIBRATION_TURNON_MEAN;
1092  } else if (mon.find(sistrip::calibrationBaselineMean_) != std::string::npos) {
1093  return sistrip::CALIBRATION_BASELINE_MEAN;
1094  } else if (mon.find(sistrip::calibrationUndershootMean_) != std::string::npos) {
1095  return sistrip::CALIBRATION_UNDERSHOOT_MEAN;
1096  } else if (mon.find(sistrip::calibrationSmearingMean_) != std::string::npos) {
1097  return sistrip::CALIBRATION_SMEARING_MEAN;
1098  } else if (mon.find(sistrip::calibrationChi2Mean_) != std::string::npos) {
1099  return sistrip::CALIBRATION_CHI2_MEAN;
1100  }
1101 
1102  else if (mon.find(sistrip::calibrationAmplitudeMax_) != std::string::npos) {
1103  return sistrip::CALIBRATION_AMPLITUDE_MAX;
1104  } else if (mon.find(sistrip::calibrationTailMax_) != std::string::npos) {
1105  return sistrip::CALIBRATION_TAIL_MAX;
1106  } else if (mon.find(sistrip::calibrationRiseTimeMax_) != std::string::npos) {
1107  return sistrip::CALIBRATION_RISETIME_MAX;
1108  } else if (mon.find(sistrip::calibrationDecayTimeMax_) != std::string::npos) {
1109  return sistrip::CALIBRATION_DECAYTIME_MAX;
1110  } else if (mon.find(sistrip::calibrationPeakTimeMax_) != std::string::npos) {
1111  return sistrip::CALIBRATION_PEAKTIME_MAX;
1112  } else if (mon.find(sistrip::calibrationTurnOnMax_) != std::string::npos) {
1113  return sistrip::CALIBRATION_TURNON_MAX;
1114  } else if (mon.find(sistrip::calibrationBaselineMax_) != std::string::npos) {
1115  return sistrip::CALIBRATION_BASELINE_MAX;
1116  } else if (mon.find(sistrip::calibrationUndershootMax_) != std::string::npos) {
1117  return sistrip::CALIBRATION_UNDERSHOOT_MAX;
1118  } else if (mon.find(sistrip::calibrationSmearingMax_) != std::string::npos) {
1119  return sistrip::CALIBRATION_SMEARING_MAX;
1120  } else if (mon.find(sistrip::calibrationChi2Max_) != std::string::npos) {
1121  return sistrip::CALIBRATION_CHI2_MAX;
1122  }
1123 
1124  else if (mon.find(sistrip::calibrationAmplitudeMin_) != std::string::npos) {
1125  return sistrip::CALIBRATION_AMPLITUDE_MIN;
1126  } else if (mon.find(sistrip::calibrationTailMin_) != std::string::npos) {
1127  return sistrip::CALIBRATION_TAIL_MIN;
1128  } else if (mon.find(sistrip::calibrationRiseTimeMin_) != std::string::npos) {
1129  return sistrip::CALIBRATION_RISETIME_MIN;
1130  } else if (mon.find(sistrip::calibrationDecayTimeMin_) != std::string::npos) {
1131  return sistrip::CALIBRATION_DECAYTIME_MIN;
1132  } else if (mon.find(sistrip::calibrationPeakTimeMin_) != std::string::npos) {
1133  return sistrip::CALIBRATION_PEAKTIME_MIN;
1134  } else if (mon.find(sistrip::calibrationTurnOnMin_) != std::string::npos) {
1135  return sistrip::CALIBRATION_TURNON_MIN;
1136  } else if (mon.find(sistrip::calibrationBaselineMin_) != std::string::npos) {
1137  return sistrip::CALIBRATION_BASELINE_MIN;
1138  } else if (mon.find(sistrip::calibrationUndershootMin_) != std::string::npos) {
1139  return sistrip::CALIBRATION_UNDERSHOOT_MIN;
1140  } else if (mon.find(sistrip::calibrationSmearingMin_) != std::string::npos) {
1141  return sistrip::CALIBRATION_SMEARING_MIN;
1142  } else if (mon.find(sistrip::calibrationChi2Min_) != std::string::npos) {
1143  return sistrip::CALIBRATION_CHI2_MIN;
1144  }
1145 
1146  else if (mon.find(sistrip::calibrationAmplitudeSpread_) != std::string::npos) {
1147  return sistrip::CALIBRATION_AMPLITUDE_SPREAD;
1148  } else if (mon.find(sistrip::calibrationTailSpread_) != std::string::npos) {
1149  return sistrip::CALIBRATION_TAIL_SPREAD;
1150  } else if (mon.find(sistrip::calibrationRiseTimeSpread_) != std::string::npos) {
1151  return sistrip::CALIBRATION_RISETIME_SPREAD;
1152  } else if (mon.find(sistrip::calibrationDecayTimeSpread_) != std::string::npos) {
1153  return sistrip::CALIBRATION_DECAYTIME_SPREAD;
1154  } else if (mon.find(sistrip::calibrationPeakTimeSpread_) != std::string::npos) {
1155  return sistrip::CALIBRATION_PEAKTIME_SPREAD;
1156  } else if (mon.find(sistrip::calibrationTurnOnSpread_) != std::string::npos) {
1157  return sistrip::CALIBRATION_TURNON_SPREAD;
1158  } else if (mon.find(sistrip::calibrationBaselineSpread_) != std::string::npos) {
1159  return sistrip::CALIBRATION_BASELINE_SPREAD;
1160  } else if (mon.find(sistrip::calibrationUndershootSpread_) != std::string::npos) {
1161  return sistrip::CALIBRATION_UNDERSHOOT_SPREAD;
1162  } else if (mon.find(sistrip::calibrationSmearingSpread_) != std::string::npos) {
1163  return sistrip::CALIBRATION_SMEARING_SPREAD;
1164  } else if (mon.find(sistrip::calibrationChi2Spread_) != std::string::npos) {
1165  return sistrip::CALIBRATION_CHI2_SPREAD;
1166  }
1167 
1168  else if (mon.find(sistrip::calibrationAmplitudeTuned_) != std::string::npos) {
1169  return sistrip::CALIBRATION_AMPLITUDE_TUNED;
1170  } else if (mon.find(sistrip::calibrationTailTuned_) != std::string::npos) {
1171  return sistrip::CALIBRATION_TAIL_TUNED;
1172  } else if (mon.find(sistrip::calibrationRiseTimeTuned_) != std::string::npos) {
1173  return sistrip::CALIBRATION_RISETIME_TUNED;
1174  } else if (mon.find(sistrip::calibrationDecayTimeTuned_) != std::string::npos) {
1175  return sistrip::CALIBRATION_DECAYTIME_TUNED;
1176  } else if (mon.find(sistrip::calibrationPeakTimeTuned_) != std::string::npos) {
1177  return sistrip::CALIBRATION_PEAKTIME_TUNED;
1178  } else if (mon.find(sistrip::calibrationTurnOnTuned_) != std::string::npos) {
1179  return sistrip::CALIBRATION_TURNON_TUNED;
1180  } else if (mon.find(sistrip::calibrationBaselineTuned_) != std::string::npos) {
1181  return sistrip::CALIBRATION_BASELINE_TUNED;
1182  } else if (mon.find(sistrip::calibrationUndershootTuned_) != std::string::npos) {
1183  return sistrip::CALIBRATION_UNDERSHOOT_TUNED;
1184  } else if (mon.find(sistrip::calibrationSmearingTuned_) != std::string::npos) {
1185  return sistrip::CALIBRATION_SMEARING_TUNED;
1186  } else if (mon.find(sistrip::calibrationChi2Tuned_) != std::string::npos) {
1187  return sistrip::CALIBRATION_CHI2_TUNED;
1188  } else if (mon.find(sistrip::calibrationISHATuned_) != std::string::npos) {
1189  return sistrip::CALIBRATION_ISHA_TUNED;
1190  } else if (mon.find(sistrip::calibrationVFSTuned_) != std::string::npos) {
1191  return sistrip::CALIBRATION_VFS_TUNED;
1192  } else if (mon.find(sistrip::calibrationISHABest_) != std::string::npos) {
1193  return sistrip::CALIBRATION_ISHA_BEST;
1194  } else if (mon.find(sistrip::calibrationVFSBest_) != std::string::npos) {
1195  return sistrip::CALIBRATION_VFS_BEST;
1196  }
1197 
1198  else if (mon.find(sistrip::calibrationAmplitude_) != std::string::npos) {
1199  return sistrip::CALIBRATION_AMPLITUDE_ALL_STRIPS;
1200  } else if (mon.find(sistrip::calibrationTail_) != std::string::npos) {
1201  return sistrip::CALIBRATION_TAIL_ALL_STRIPS;
1202  } else if (mon.find(sistrip::calibrationRiseTime_) != std::string::npos) {
1203  return sistrip::CALIBRATION_RISETIME_ALL_STRIPS;
1204  } else if (mon.find(sistrip::calibrationDecayTime_) != std::string::npos) {
1205  return sistrip::CALIBRATION_DECAYTIME_ALL_STRIPS;
1206  } else if (mon.find(sistrip::calibrationPeakTime_) != std::string::npos) {
1207  return sistrip::CALIBRATION_PEAKTIME_ALL_STRIPS;
1208  } else if (mon.find(sistrip::calibrationTurnOn_) != std::string::npos) {
1209  return sistrip::CALIBRATION_TURNON_ALL_STRIPS;
1210  } else if (mon.find(sistrip::calibrationBaseline_) != std::string::npos) {
1211  return sistrip::CALIBRATION_BASELINE_ALL_STRIPS;
1212  } else if (mon.find(sistrip::calibrationUndershoot_) != std::string::npos) {
1213  return sistrip::CALIBRATION_UNDERSHOOT_ALL_STRIPS;
1214  } else if (mon.find(sistrip::calibrationSmearing_) != std::string::npos) {
1215  return sistrip::CALIBRATION_SMEARING_ALL_STRIPS;
1216  } else if (mon.find(sistrip::calibrationChi2_) != std::string::npos) {
1217  return sistrip::CALIBRATION_CHI2_ALL_STRIPS;
1218  }
1219 
1220  // scope mode
1221  else if (mon.find(sistrip::daqScopeModeMeanSignal_) != std::string::npos) {
1222  return sistrip::DAQ_SCOPE_MODE_MEAN_SIGNAL;
1223  }
1224 
1225  // unknown
1226  else if (mon.find(sistrip::undefinedMonitorable_) != std::string::npos) {
1227  return sistrip::UNDEFINED_MONITORABLE;
1228  } else if (mon.empty()) {
1229  return sistrip::UNDEFINED_MONITORABLE;
1230  } else {
1231  return sistrip::UNKNOWN_MONITORABLE;
1232  }
1233 }
1234 
1235 // -----------------------------------------------------------------------------
1236 //
1237 std::string SiStripEnumsAndStrings::presentation(const sistrip::Presentation& type) {
1238  if (type == sistrip::HISTO_1D) {
1239  return sistrip::histo1d_;
1240  } else if (type == sistrip::HISTO_2D_SUM) {
1241  return sistrip::histo2dSum_;
1242  } else if (type == sistrip::HISTO_2D_SCATTER) {
1243  return sistrip::histo2dScatter_;
1244  } else if (type == sistrip::PROFILE_1D) {
1245  return sistrip::profile1D_;
1246  } else if (type == sistrip::UNDEFINED_PRESENTATION) {
1247  return sistrip::undefinedPresentation_;
1248  } else {
1249  return sistrip::unknownPresentation_;
1250  }
1251 }
1252 
1253 // -----------------------------------------------------------------------------
1254 //
1255 sistrip::Presentation SiStripEnumsAndStrings::presentation(const std::string& type) {
1256  if (type.find(sistrip::histo1d_) != std::string::npos) {
1257  return sistrip::HISTO_1D;
1258  } else if (type.find(sistrip::histo2dSum_) != std::string::npos) {
1259  return sistrip::HISTO_2D_SUM;
1260  } else if (type.find(sistrip::histo2dScatter_) != std::string::npos) {
1261  return sistrip::HISTO_2D_SCATTER;
1262  } else if (type.find(sistrip::profile1D_) != std::string::npos) {
1263  return sistrip::PROFILE_1D;
1264  } else if (type.find(sistrip::undefinedPresentation_) != std::string::npos) {
1265  return sistrip::UNDEFINED_PRESENTATION;
1266  } else if (type.empty()) {
1267  return sistrip::UNDEFINED_PRESENTATION;
1268  } else {
1269  return sistrip::UNKNOWN_PRESENTATION;
1270  }
1271 }
1272 
1273 // -----------------------------------------------------------------------------
1274 //
1275 std::string SiStripEnumsAndStrings::cablingSource(const sistrip::CablingSource& source) {
1276  if (source == sistrip::CABLING_FROM_CONNS) {
1277  return sistrip::cablingFromConns_;
1278  } else if (source == sistrip::CABLING_FROM_DEVICES) {
1279  return sistrip::cablingFromDevices_;
1280  } else if (source == sistrip::CABLING_FROM_DETIDS) {
1281  return sistrip::cablingFromDetIds_;
1282  } else if (source == sistrip::UNDEFINED_CABLING_SOURCE) {
1283  return sistrip::undefinedCablingSource_;
1284  } else {
1285  return sistrip::unknownCablingSource_;
1286  }
1287 }
1288 
1289 // -----------------------------------------------------------------------------
1290 //
1291 sistrip::CablingSource SiStripEnumsAndStrings::cablingSource(const std::string& source) {
1292  if (source.find(sistrip::cablingFromConns_) != std::string::npos) {
1293  return sistrip::CABLING_FROM_CONNS;
1294  } else if (source.find(sistrip::cablingFromDevices_) != std::string::npos) {
1295  return sistrip::CABLING_FROM_DEVICES;
1296  } else if (source.find(sistrip::cablingFromDetIds_) != std::string::npos) {
1297  return sistrip::CABLING_FROM_DETIDS;
1298  } else if (source.find(sistrip::undefinedCablingSource_) != std::string::npos) {
1299  return sistrip::UNDEFINED_CABLING_SOURCE;
1300  } else if (source.empty()) {
1301  return sistrip::UNDEFINED_CABLING_SOURCE;
1302  } else if (source == "CONNECTIONS") {
1303  return sistrip::CABLING_FROM_CONNS;
1304  } else if (source == "DEVICES") {
1305  return sistrip::CABLING_FROM_DEVICES;
1306  } else if (source == "DETIDS") {
1307  return sistrip::CABLING_FROM_DETIDS;
1308  } else if (source == "UNDEFINED") {
1309  return sistrip::UNDEFINED_CABLING_SOURCE;
1310  } else {
1311  return sistrip::UNKNOWN_CABLING_SOURCE;
1312  }
1313 }
sistrip::Granularity
Granularity
Definition: ConstantsForGranularity.h:60
sistrip::CALIBRATION_SCAN
Definition: ConstantsForRunType.h:87
sistrip::UNKNOWN_MONITORABLE
Definition: ConstantsForMonitorable.h:201
sistrip::APV_TIMING_TIME
Definition: ConstantsForMonitorable.h:218
sistrip::PHYSICS_ZS
Definition: ConstantsForRunType.h:86
sistrip::CALIBRATION_PEAKTIME_TUNED
Definition: ConstantsForMonitorable.h:355
SiStripEnumsAndStrings::runType
static std::string runType(const sistrip::RunType &)
Definition: SiStripEnumsAndStrings.cc:39
sistrip::CALIBRATION_DECAYTIME_MIN
Definition: ConstantsForMonitorable.h:321
sistrip::fastCablingHighLevel_
static const char fastCablingHighLevel_[]
Definition: ConstantsForMonitorable.h:29
sistrip::undefinedKey_
static const char undefinedKey_[]
Definition: ConstantsForKeyType.h:19
sistrip::apvTimingHeight_
static const char apvTimingHeight_[]
Definition: ConstantsForMonitorable.h:45
sistrip::CCU_CHAN
Definition: ConstantsForGranularity.h:93
sistrip::DEAD_STRIP_BIT_ALL_STRIPS
Definition: ConstantsForMonitorable.h:278
sistrip::apvLatencyRun_
static const char apvLatencyRun_[]
Definition: ConstantsForRunType.h:30
sistrip::LAYER
Definition: ConstantsForGranularity.h:70
sistrip::CALIBRATION_TAIL_MAX
Definition: ConstantsForMonitorable.h:335
sistrip::profile1D_
static const char profile1D_[]
Definition: ConstantsForPresentation.h:24
SiStripEnumsAndStrings::apvReadoutMode
static std::string apvReadoutMode(const sistrip::ApvReadoutMode &)
Definition: SiStripEnumsAndStrings.cc:413
sistrip::NUM_OF_DEAD
Bad strip.
Definition: ConstantsForMonitorable.h:262
sistrip::fedZeroSupprLite8TBCMO_
static const char fedZeroSupprLite8TBCMO_[]
Definition: ConstantsForHardwareSystems.h:114
sistrip::fecSystem_
static const char fecSystem_[]
Definition: ConstantsForGranularity.h:51
sistrip::DAQ_SCOPE_MODE
Definition: ConstantsForRunType.h:83
sistrip::petal_
static const char petal_[]
Definition: ConstantsForGranularity.h:34
sistrip::CALIBRATION_TURNON_SPREAD
Definition: ConstantsForMonitorable.h:341
sistrip::CALIBRATION_TAIL_ALL_STRIPS
Definition: ConstantsForMonitorable.h:313
sistrip::CALIBRATION_AMPLITUDE_ALL_STRIPS
Definition: ConstantsForMonitorable.h:306
sistrip::numOfBadFitStatusStrips_
static const char numOfBadFitStatusStrips_[]
Definition: ConstantsForMonitorable.h:100
sistrip::physicsRun_
static const char physicsRun_[]
Definition: ConstantsForRunType.h:37
sistrip::CALIBRATION
Definition: ConstantsForRunType.h:73
sistrip::calibrationAmplitudeMean_
static const char calibrationAmplitudeMean_[]
Definition: ConstantsForMonitorable.h:135
sistrip::module_
static const char module_[]
Definition: ConstantsForGranularity.h:38
sistrip::calibrationDecayTimeTuned_
static const char calibrationDecayTimeTuned_[]
Definition: ConstantsForMonitorable.h:182
sistrip::chi2ProbabAllStrips_
static const char chi2ProbabAllStrips_[]
Definition: ConstantsForMonitorable.h:108
sistrip::tob_
static const char tob_[]
Definition: ConstantsForGranularity.h:26
sistrip::optoScanTickHeight_
static const char optoScanTickHeight_[]
Definition: ConstantsForMonitorable.h:64
sistrip::CALIBRATION_UNDERSHOOT_TUNED
Definition: ConstantsForMonitorable.h:356
sistrip::PEDS_FULL_NOISE
Definition: ConstantsForRunType.h:92
sistrip::VPSP_SCAN
Definition: ConstantsForRunType.h:82
sistrip::TRACKER
Definition: ConstantsForGranularity.h:64
sistrip::FAST_CABLING
Definition: ConstantsForRunType.h:89
sistrip::numOfBadKSProbabStrips_
static const char numOfBadKSProbabStrips_[]
Definition: ConstantsForMonitorable.h:92
sistrip::FEC_RING
Definition: ConstantsForGranularity.h:91
sistrip::FEC_SYSTEM
Definition: ConstantsForGranularity.h:88
sistrip::vpspScanApv0_
static const char vpspScanApv0_[]
Definition: ConstantsForMonitorable.h:68
sistrip::optoScanLinkNoise_
static const char optoScanLinkNoise_[]
Definition: ConstantsForMonitorable.h:61
sistrip::APV_TIMING
Definition: ConstantsForRunType.h:75
sistrip::STRING
Definition: ConstantsForGranularity.h:72
sistrip::fastCablingDcuId_
static const char fastCablingDcuId_[]
Definition: ConstantsForMonitorable.h:27
sistrip::unknownCablingSource_
static const char unknownCablingSource_[]
Definition: ConstantsForCablingSource.h:18
sistrip::APV_MULTI_MODE
Definition: ConstantsForHardwareSystems.h:126
sistrip::calibrationVFSBest_
static const char calibrationVFSBest_[]
Definition: ConstantsForMonitorable.h:192
sistrip::FINE_DELAY_POS
Definition: ConstantsForMonitorable.h:292
sistrip::CALIBRATION_PEAKTIME_MEAN
Definition: ConstantsForMonitorable.h:300
sistrip::KeyType
KeyType
Definition: ConstantsForKeyType.h:27
sistrip::disk_
static const char disk_[]
Definition: ConstantsForGranularity.h:33
sistrip::View
View
Definition: ConstantsForView.h:26
sistrip::CABLING_FROM_DEVICES
Definition: ConstantsForCablingSource.h:31
sistrip::BAD_STRIP_BIT_ALL_STRIPS
Definition: ConstantsForMonitorable.h:277
sistrip::calibScanDeconRun_
static const char calibScanDeconRun_[]
Definition: ConstantsForRunType.h:35
sistrip::optoScanMeasGain_
static const char optoScanMeasGain_[]
Definition: ConstantsForMonitorable.h:59
sistrip::vpspScanRun_
static const char vpspScanRun_[]
Definition: ConstantsForRunType.h:25
sistrip::CALIBRATION_RISETIME_MAX
Definition: ConstantsForMonitorable.h:331
sistrip::tracker_
static const char tracker_[]
Definition: ConstantsForGranularity.h:23
sistrip::CCU_ADDR
Definition: ConstantsForGranularity.h:92
sistrip::RESIDUAL_INTEGRALNSIGMA_ALL_STRIPS
Definition: ConstantsForMonitorable.h:289
sistrip::tec_
static const char tec_[]
Definition: ConstantsForGranularity.h:27
sistrip::DET_KEY
Definition: ConstantsForKeyType.h:32
sistrip::UNDEFINED_VIEW
Definition: ConstantsForView.h:28
sistrip::FED_TIMING_HEIGHT
Definition: ConstantsForMonitorable.h:232
sistrip::calibrationTailTuned_
static const char calibrationTailTuned_[]
Definition: ConstantsForMonitorable.h:180
SiStripEnumsAndStrings::histoType
static std::string histoType(const sistrip::HistoType &)
Definition: SiStripEnumsAndStrings.cc:517
sistrip::apvMultiMode_
static const char apvMultiMode_[]
Definition: ConstantsForHardwareSystems.h:99
sistrip::detectorView_
static const char detectorView_[]
Definition: ConstantsForView.h:22
sistrip::fedZeroSuppr_
static const char fedZeroSuppr_[]
Definition: ConstantsForHardwareSystems.h:107
sistrip::fedTimingError_
static const char fedTimingError_[]
Definition: ConstantsForMonitorable.h:51
sistrip::calibrationSmearingSpread_
static const char calibrationSmearingSpread_[]
Definition: ConstantsForMonitorable.h:173
sistrip::apvTimingMax_
static const char apvTimingMax_[]
Definition: ConstantsForMonitorable.h:40
sistrip::pedestalsAllStrips_
static const char pedestalsAllStrips_[]
Definition: ConstantsForMonitorable.h:75
sistrip::unknownView_
static const char unknownView_[]
Definition: ConstantsForView.h:17
sistrip::HISTO_2D_SUM
Definition: ConstantsForPresentation.h:32
sistrip::fedKey_
static const char fedKey_[]
Definition: ConstantsForKeyType.h:21
sistrip::numOfBadLargeNoiseSignificanceStrips_
static const char numOfBadLargeNoiseSignificanceStrips_[]
Definition: ConstantsForMonitorable.h:98
ALCARECOPromptCalibProdSiPixelAli0T_cff.mode
mode
Definition: ALCARECOPromptCalibProdSiPixelAli0T_cff.py:96
sistrip::FINE_DELAY_ERROR
Definition: ConstantsForMonitorable.h:293
sistrip::DETECTOR_VIEW
Definition: ConstantsForView.h:31
sistrip::CALIBRATION_PEAKTIME_SPREAD
Definition: ConstantsForMonitorable.h:344
sistrip::calibrationDecayTimeMax_
static const char calibrationDecayTimeMax_[]
Definition: ConstantsForMonitorable.h:160
sistrip::NOISE_MEAN
Definition: ConstantsForMonitorable.h:256
sistrip::CALIBRATION_SMEARING_TUNED
Definition: ConstantsForMonitorable.h:358
sistrip::UNDEFINED_PRESENTATION
Definition: ConstantsForPresentation.h:30
sistrip::calibrationChi2Mean_
static const char calibrationChi2Mean_[]
Definition: ConstantsForMonitorable.h:144
sistrip::APV_TIMING_BASE
Definition: ConstantsForMonitorable.h:222
sistrip::OPTO_SCAN
Definition: ConstantsForRunType.h:74
sistrip::unknownKey_
static const char unknownKey_[]
Definition: ConstantsForKeyType.h:18
sistrip::undefinedView_
static const char undefinedView_[]
Definition: ConstantsForView.h:18
sistrip::rod_
static const char rod_[]
Definition: ConstantsForGranularity.h:31
sistrip::residualKurtosisAllStrips_
static const char residualKurtosisAllStrips_[]
Definition: ConstantsForMonitorable.h:114
sistrip::numOfBadChi2ProbabStrips_
static const char numOfBadChi2ProbabStrips_[]
Definition: ConstantsForMonitorable.h:94
sistrip::FED_APV
Definition: ConstantsForGranularity.h:85
sistrip::calibrationAmplitudeMax_
static const char calibrationAmplitudeMax_[]
Definition: ConstantsForMonitorable.h:157
sistrip::ROD
Definition: ConstantsForGranularity.h:71
sistrip::CALIBRATION_TAIL_TUNED
Definition: ConstantsForMonitorable.h:357
sistrip::unknownPresentation_
static const char unknownPresentation_[]
Definition: ConstantsForPresentation.h:18
sistrip::pedsOnlyRun_
static const char pedsOnlyRun_[]
Definition: ConstantsForRunType.h:27
sistrip::fedZeroSupprLite8BB_
static const char fedZeroSupprLite8BB_[]
Definition: ConstantsForHardwareSystems.h:115
sistrip::FED_CABLING_FED_CH
Definition: ConstantsForMonitorable.h:205
sistrip::FAST_CABLING_LLD_CH
Definition: ConstantsForMonitorable.h:209
sistrip::FE_UNIT
Definition: ConstantsForGranularity.h:83
sistrip::OPTO_SCAN_LLD_BIAS_SETTING
Definition: ConstantsForMonitorable.h:234
sistrip::NUM_OF_BAD_KS_PROBAB
Definition: ConstantsForMonitorable.h:271
sistrip::NUM_OF_NOISY
Definition: ConstantsForMonitorable.h:264
sistrip::NUM_OF_BAD_FIT_STATUS
Definition: ConstantsForMonitorable.h:269
sistrip::APV_TIMING_ERROR
Definition: ConstantsForMonitorable.h:221
sistrip::residualSkewnessAllStrips_
static const char residualSkewnessAllStrips_[]
Definition: ConstantsForMonitorable.h:113
sistrip::unknownHistoType_
static const char unknownHistoType_[]
Definition: ConstantsForHistoType.h:18
sistrip::numOfBadJBProbabStrips_
static const char numOfBadJBProbabStrips_[]
Definition: ConstantsForMonitorable.h:93
sistrip::histo2dScatter_
static const char histo2dScatter_[]
Definition: ConstantsForPresentation.h:23
sistrip::calibrationBaselineMin_
static const char calibrationBaselineMin_[]
Definition: ConstantsForMonitorable.h:155
sistrip::numOfBadLargeNoiseStrips_
static const char numOfBadLargeNoiseStrips_[]
Definition: ConstantsForMonitorable.h:97
sistrip::apvTimingDelay_
static const char apvTimingDelay_[]
Definition: ConstantsForMonitorable.h:41
sistrip::KS_PROBAB_ALL_STRIPS
Definition: ConstantsForMonitorable.h:280
sistrip::calibrationTurnOnMax_
static const char calibrationTurnOnMax_[]
Definition: ConstantsForMonitorable.h:163
sistrip::CALIBRATION_SMEARING_ALL_STRIPS
Definition: ConstantsForMonitorable.h:314
sistrip::undefinedGranularity_
static const char undefinedGranularity_[]
Definition: ConstantsForGranularity.h:20
sistrip::JB_PROBAB_ALL_STRIPS
Definition: ConstantsForMonitorable.h:281
sistrip::RunType
RunType
Definition: ConstantsForRunType.h:70
sistrip::undefinedCablingSource_
static const char undefinedCablingSource_[]
Definition: ConstantsForCablingSource.h:19
sistrip::RESIDUAL_MEAN_ALL_STRIPS
Definition: ConstantsForMonitorable.h:286
sistrip::UNKNOWN_GRAN
Definition: ConstantsForGranularity.h:62
sistrip::FAST_CABLING_HIGH_RMS
Definition: ConstantsForMonitorable.h:212
sistrip::CALIBRATION_TAIL_SPREAD
Definition: ConstantsForMonitorable.h:346
sistrip::FED_ZERO_SUPPR_LITE8_TB_CMO
Definition: ConstantsForHardwareSystems.h:141
sistrip::fineDelayPos_
static const char fineDelayPos_[]
Definition: ConstantsForMonitorable.h:119
sistrip::APV_TIMING_DELAY
Definition: ConstantsForMonitorable.h:220
sistrip::numOfNoisy_
static const char numOfNoisy_[]
Definition: ConstantsForMonitorable.h:89
sistrip::FED_CABLING_ADC_LEVEL
Definition: ConstantsForMonitorable.h:206
sistrip::NOISE_ALL_STRIPS
Definition: ConstantsForMonitorable.h:255
sistrip::UNDEFINED_APV_READOUT_MODE
Definition: ConstantsForHardwareSystems.h:123
sistrip::UNKNOWN_FED_READOUT_MODE
Definition: ConstantsForHardwareSystems.h:130
sistrip::calibrationSmearing_
static const char calibrationSmearing_[]
Definition: ConstantsForMonitorable.h:132
sistrip::CALIBRATION_AMPLITUDE_MEAN
Definition: ConstantsForMonitorable.h:295
sistrip::fedTimingHeight_
static const char fedTimingHeight_[]
Definition: ConstantsForMonitorable.h:54
sistrip::calibrationBaselineMax_
static const char calibrationBaselineMax_[]
Definition: ConstantsForMonitorable.h:166
sistrip::vpspScanDigitalHigh_
static const char vpspScanDigitalHigh_[]
Definition: ConstantsForMonitorable.h:71
sistrip::pedsFullNoiseRun_
static const char pedsFullNoiseRun_[]
Definition: ConstantsForRunType.h:29
sistrip::RESIDUAL_SKEWNESS_ALL_STRIPS
Definition: ConstantsForMonitorable.h:287
sistrip::fastCablingMin_
static const char fastCablingMin_[]
Definition: ConstantsForMonitorable.h:35
sistrip::RESIDUAL_INTEGRAL_ALL_STRIPS
Definition: ConstantsForMonitorable.h:290
sistrip::ccuAddr_
static const char ccuAddr_[]
Definition: ConstantsForGranularity.h:55
sistrip::CALIBRATION_DECAYTIME_TUNED
Definition: ConstantsForMonitorable.h:354
sistrip::calibrationISHABest_
static const char calibrationISHABest_[]
Definition: ConstantsForMonitorable.h:191
sistrip::PEDESTALS_ALL_STRIPS
Definition: ConstantsForMonitorable.h:249
sistrip::CALIBRATION_SMEARING_MIN
Definition: ConstantsForMonitorable.h:325
sistrip::residualIntegralNsigmaAllStrips_
static const char residualIntegralNsigmaAllStrips_[]
Definition: ConstantsForMonitorable.h:115
sistrip::CALIBRATION_RISETIME_TUNED
Definition: ConstantsForMonitorable.h:353
sistrip::CALIBRATION_UNDERSHOOT_SPREAD
Definition: ConstantsForMonitorable.h:345
sistrip::CALIBRATION_BASELINE_MAX
Definition: ConstantsForMonitorable.h:329
sistrip::FINE_DELAY
Definition: ConstantsForRunType.h:85
sistrip::pedestalsMean_
static const char pedestalsMean_[]
Definition: ConstantsForMonitorable.h:76
sistrip::CALIBRATION_CHI2_MIN
Definition: ConstantsForMonitorable.h:326
sistrip::CALIBRATION_CHI2_TUNED
Definition: ConstantsForMonitorable.h:359
sistrip::calibrationBaselineMean_
static const char calibrationBaselineMean_[]
Definition: ConstantsForMonitorable.h:140
sistrip::fedCablingAdcLevel_
static const char fedCablingAdcLevel_[]
Definition: ConstantsForMonitorable.h:24
sistrip::noiseMin_
static const char noiseMin_[]
Definition: ConstantsForMonitorable.h:86
sistrip::calibrationTailMax_
static const char calibrationTailMax_[]
Definition: ConstantsForMonitorable.h:158
sistrip::calibrationUndershootMean_
static const char calibrationUndershootMean_[]
Definition: ConstantsForMonitorable.h:141
sistrip::CALIBRATION_TAIL_MEAN
Definition: ConstantsForMonitorable.h:302
sistrip::FAST_CABLING_CONNS_PER_FED
Definition: ConstantsForMonitorable.h:216
sistrip::calibrationTurnOn_
static const char calibrationTurnOn_[]
Definition: ConstantsForMonitorable.h:126
SiStripEnumsAndStrings::fedReadoutMode
static std::string fedReadoutMode(const sistrip::FedReadoutMode &)
Definition: SiStripEnumsAndStrings.cc:447
sistrip::unknownGranularity_
static const char unknownGranularity_[]
Definition: ConstantsForGranularity.h:19
sistrip::Monitorable
Monitorable
Definition: ConstantsForMonitorable.h:200
sistrip::FAST_CABLING_MAX
Definition: ConstantsForMonitorable.h:214
sistrip::FED_CABLING
Definition: ConstantsForRunType.h:81
sistrip::calibrationBaselineSpread_
static const char calibrationBaselineSpread_[]
Definition: ConstantsForMonitorable.h:177
sistrip::noiseMax_
static const char noiseMax_[]
Definition: ConstantsForMonitorable.h:85
sistrip::fecKey_
static const char fecKey_[]
Definition: ConstantsForKeyType.h:22
sistrip::calibrationUndershootMin_
static const char calibrationUndershootMin_[]
Definition: ConstantsForMonitorable.h:153
sistrip::fedChannel_
static const char fedChannel_[]
Definition: ConstantsForGranularity.h:48
sistrip::CALIBRATION_UNDERSHOOT_MEAN
Definition: ConstantsForMonitorable.h:301
sistrip::calibPeakRun_
static const char calibPeakRun_[]
Definition: ConstantsForRunType.h:32
sistrip::expertHisto_
static const char expertHisto_[]
Definition: ConstantsForHistoType.h:21
sistrip::MODULE
Definition: ConstantsForGranularity.h:77
sistrip::VPSP_SCAN_DIGITAL_HIGH
Definition: ConstantsForMonitorable.h:246
sistrip::APV_PEAK_MODE
Definition: ConstantsForHardwareSystems.h:124
sistrip::TIB
Definition: ConstantsForGranularity.h:66
sistrip::CALIBRATION_TURNON_TUNED
Definition: ConstantsForMonitorable.h:352
sistrip::histo2dSum_
static const char histo2dSum_[]
Definition: ConstantsForPresentation.h:22
sistrip::VPSP_SCAN_APV1_SETTING
Definition: ConstantsForMonitorable.h:244
sistrip::calibrationSmearingMean_
static const char calibrationSmearingMean_[]
Definition: ConstantsForMonitorable.h:143
sistrip::apvTimingRun_
static const char apvTimingRun_[]
Definition: ConstantsForRunType.h:22
sistrip::fedCablingFedCh_
static const char fedCablingFedCh_[]
Definition: ConstantsForMonitorable.h:23
sistrip::PETAL
Definition: ConstantsForGranularity.h:74
sistrip::FINE_DELAY_TTC
Definition: ConstantsForRunType.h:78
sistrip::UNKNOWN_KEY
Definition: ConstantsForKeyType.h:28
sistrip::calibrationBaseline_
static const char calibrationBaseline_[]
Definition: ConstantsForMonitorable.h:125
sistrip::CALIBRATION_BASELINE_MEAN
Definition: ConstantsForMonitorable.h:296
sistrip::fedProcRaw_
static const char fedProcRaw_[]
Definition: ConstantsForHardwareSystems.h:106
sistrip::EXPERT_HISTO
Definition: ConstantsForHistoType.h:29
sistrip::PEDESTALS_MEAN
Definition: ConstantsForMonitorable.h:250
source
static const std::string source
Definition: EdmProvDump.cc:47
sistrip::UNDEFINED_HISTO_TYPE
Definition: ConstantsForHistoType.h:28
sistrip::fedZeroSupprLite_
static const char fedZeroSupprLite_[]
Definition: ConstantsForHardwareSystems.h:109
sistrip::OPTO_SCAN_LASER_THRESHOLD
Definition: ConstantsForMonitorable.h:239
sistrip::calibrationRiseTimeTuned_
static const char calibrationRiseTimeTuned_[]
Definition: ConstantsForMonitorable.h:181
sistrip::FED_TIMING_PEAK
Definition: ConstantsForMonitorable.h:231
sistrip::fecCrate_
static const char fecCrate_[]
Definition: ConstantsForGranularity.h:52
sistrip::Presentation
Presentation
Definition: ConstantsForPresentation.h:28
sistrip::calibrationUndershootMax_
static const char calibrationUndershootMax_[]
Definition: ConstantsForMonitorable.h:164
sistrip::ring_
static const char ring_[]
Definition: ConstantsForGranularity.h:35
sistrip::fineDelayRun_
static const char fineDelayRun_[]
Definition: ConstantsForRunType.h:31
sistrip::residualSigmaGausAllStrips_
static const char residualSigmaGausAllStrips_[]
Definition: ConstantsForMonitorable.h:110
sistrip::NOISE_SIGNIFICANCE_ALL_STRIPS
Definition: ConstantsForMonitorable.h:285
sistrip::calibrationAmplitudeMin_
static const char calibrationAmplitudeMin_[]
Definition: ConstantsForMonitorable.h:146
sistrip::CALIBRATION_SMEARING_MEAN
Definition: ConstantsForMonitorable.h:303
SiStripEnumsAndStrings::presentation
static std::string presentation(const sistrip::Presentation &)
Definition: SiStripEnumsAndStrings.cc:1237
sistrip::optoScanRun_
static const char optoScanRun_[]
Definition: ConstantsForRunType.h:24
sistrip::calibrationISHATuned_
static const char calibrationISHATuned_[]
Definition: ConstantsForMonitorable.h:189
sistrip::partition_
static const char partition_[]
Definition: ConstantsForGranularity.h:24
sistrip::fastCablingLowLevel_
static const char fastCablingLowLevel_[]
Definition: ConstantsForMonitorable.h:31
sistrip::CALIBRATION_TURNON_MEAN
Definition: ConstantsForMonitorable.h:297
sistrip::PEDESTALS_MIN
Definition: ConstantsForMonitorable.h:253
SiStripEnumsAndStrings::granularity
static std::string granularity(const sistrip::Granularity &)
Definition: SiStripEnumsAndStrings.cc:265
sistrip::pedestalsRun_
static const char pedestalsRun_[]
Definition: ConstantsForRunType.h:26
sistrip::string_
static const char string_[]
Definition: ConstantsForGranularity.h:32
sistrip::fecSlot_
static const char fecSlot_[]
Definition: ConstantsForGranularity.h:53
sistrip::adProbabAllStrips_
static const char adProbabAllStrips_[]
Definition: ConstantsForMonitorable.h:105
sistrip::numOfBadTailStrips_
static const char numOfBadTailStrips_[]
Definition: ConstantsForMonitorable.h:99
sistrip::calibrationBaselineTuned_
static const char calibrationBaselineTuned_[]
Definition: ConstantsForMonitorable.h:188
sistrip::fastCablingConnsPerFed_
static const char fastCablingConnsPerFed_[]
Definition: ConstantsForMonitorable.h:36
sistrip::calibrationChi2Tuned_
static const char calibrationChi2Tuned_[]
Definition: ConstantsForMonitorable.h:187
LaserDQM_cfi.mon
mon
Definition: LaserDQM_cfi.py:3
sistrip::CALIBRATION_DECAYTIME_MAX
Definition: ConstantsForMonitorable.h:332
sistrip::FED_ZERO_SUPPR_LITE8_TB
Definition: ConstantsForHardwareSystems.h:140
sistrip::noiseSpread_
static const char noiseSpread_[]
Definition: ConstantsForMonitorable.h:84
sistrip::OPTO_SCAN_TICK_HEIGHT
Definition: ConstantsForMonitorable.h:240
sistrip::calibrationDecayTimeMin_
static const char calibrationDecayTimeMin_[]
Definition: ConstantsForMonitorable.h:149
sistrip::APV_TIMING_MAX_TIME
Definition: ConstantsForMonitorable.h:219
sistrip::fedCablingFedId_
static const char fedCablingFedId_[]
Definition: ConstantsForMonitorable.h:22
sistrip::VPSP_SCAN_ADC_LEVEL
Definition: ConstantsForMonitorable.h:245
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
sistrip::VPSP_SCAN_APV_SETTINGS
Definition: ConstantsForMonitorable.h:242
sistrip::TEC
Definition: ConstantsForGranularity.h:68
sistrip::FED_CABLING_FED_ID
Definition: ConstantsForMonitorable.h:204
sistrip::unknownRunType_
static const char unknownRunType_[]
Definition: ConstantsForRunType.h:17
sistrip::NUM_OF_BAD_LARGE_NOISE
Definition: ConstantsForMonitorable.h:267
sistrip::CALIBRATION_PEAKTIME_MAX
Definition: ConstantsForMonitorable.h:333
sistrip::CALIBRATION_PEAKTIME_ALL_STRIPS
Definition: ConstantsForMonitorable.h:311
sistrip::numOfBadShiftedStrips_
static const char numOfBadShiftedStrips_[]
Definition: ConstantsForMonitorable.h:95
sistrip::FED_ZERO_SUPPR_LITE8_TT
Definition: ConstantsForHardwareSystems.h:138
sistrip::FED_TIMING_BASE
Definition: ConstantsForMonitorable.h:230
sistrip::fastCablingLowRms_
static const char fastCablingLowRms_[]
Definition: ConstantsForMonitorable.h:32
sistrip::apvTimingError_
static const char apvTimingError_[]
Definition: ConstantsForMonitorable.h:42
sistrip::CALIBRATION_SMEARING_MAX
Definition: ConstantsForMonitorable.h:336
sistrip::HISTO_1D
Definition: ConstantsForPresentation.h:31
sistrip::optoScanZeroLight_
static const char optoScanZeroLight_[]
Definition: ConstantsForMonitorable.h:60
sistrip::vpspScanDigitalLow_
static const char vpspScanDigitalLow_[]
Definition: ConstantsForMonitorable.h:72
sistrip::ccuChan_
static const char ccuChan_[]
Definition: ConstantsForGranularity.h:56
sistrip::CALIBRATION_DECAYTIME_SPREAD
Definition: ConstantsForMonitorable.h:343
sistrip::CALIBRATION_PEAKTIME_MIN
Definition: ConstantsForMonitorable.h:322
SiStripEnumsAndStrings::cablingSource
static std::string cablingSource(const sistrip::CablingSource &)
Definition: SiStripEnumsAndStrings.cc:1275
sistrip::optoScanLldBias_
static const char optoScanLldBias_[]
Definition: ConstantsForMonitorable.h:57
sistrip::lldChan_
static const char lldChan_[]
Definition: ConstantsForGranularity.h:39
sistrip::FED_TIMING_MAX_TIME
Definition: ConstantsForMonitorable.h:227
sistrip::FED_SCOPE_MODE
Definition: ConstantsForHardwareSystems.h:132
sistrip::NUM_OF_BAD_JB_PROBAB
Definition: ConstantsForMonitorable.h:272
sistrip::calibrationAmplitudeSpread_
static const char calibrationAmplitudeSpread_[]
Definition: ConstantsForMonitorable.h:168
sistrip::fedTimingMax_
static const char fedTimingMax_[]
Definition: ConstantsForMonitorable.h:49
sistrip::CALIBRATION_DECO
Definition: ConstantsForRunType.h:93
sistrip::calibrationTurnOnMin_
static const char calibrationTurnOnMin_[]
Definition: ConstantsForMonitorable.h:152
sistrip::undefinedFedReadoutMode_
static const char undefinedFedReadoutMode_[]
Definition: ConstantsForHardwareSystems.h:102
sistrip::FED_ZERO_SUPPR_LITE
Definition: ConstantsForHardwareSystems.h:136
sistrip::calibrationChi2_
static const char calibrationChi2_[]
Definition: ConstantsForMonitorable.h:133
sistrip::FED_ZERO_SUPPR_LITE8_BB_CMO
Definition: ConstantsForHardwareSystems.h:143
sistrip::RING
Definition: ConstantsForGranularity.h:75
sistrip::NUM_OF_BAD_TAIL
Definition: ConstantsForMonitorable.h:274
sistrip::FAST_CABLING_LOW_LEVEL
Definition: ConstantsForMonitorable.h:211
sistrip::UNKNOWN_HISTO_TYPE
Definition: ConstantsForHistoType.h:27
sistrip::calibrationUndershootSpread_
static const char calibrationUndershootSpread_[]
Definition: ConstantsForMonitorable.h:175
sistrip::NOISE_MAX
Definition: ConstantsForMonitorable.h:258
type
type
Definition: SiPixelVCal_PayloadInspector.cc:37
sistrip::FED_ZERO_SUPPR
Definition: ConstantsForHardwareSystems.h:135
sistrip::UNDEFINED_KEY
Definition: ConstantsForKeyType.h:29
sistrip::noiseRun_
static const char noiseRun_[]
Definition: ConstantsForRunType.h:28
sistrip::QUITE_FAST_CABLING
Definition: ConstantsForRunType.h:84
sistrip::apvTimingBase_
static const char apvTimingBase_[]
Definition: ConstantsForMonitorable.h:43
sistrip::CALIBRATION_VFS_BEST
Definition: ConstantsForMonitorable.h:363
sistrip::undefinedPresentation_
static const char undefinedPresentation_[]
Definition: ConstantsForPresentation.h:19
sistrip::undefinedMonitorable_
static const char undefinedMonitorable_[]
Definition: ConstantsForMonitorable.h:19
sistrip::calibrationTailMin_
static const char calibrationTailMin_[]
Definition: ConstantsForMonitorable.h:147
sistrip::controlView_
static const char controlView_[]
Definition: ConstantsForView.h:21
sistrip::PEDESTALS
Definition: ConstantsForRunType.h:72
sistrip::calibrationTurnOnSpread_
static const char calibrationTurnOnSpread_[]
Definition: ConstantsForMonitorable.h:174
sistrip::noiseSignificanceAllStrips_
static const char noiseSignificanceAllStrips_[]
Definition: ConstantsForMonitorable.h:111
sistrip::OPTO_SCAN_LLD_GAIN_SETTING
Definition: ConstantsForMonitorable.h:233
sistrip::cablingFromDetIds_
static const char cablingFromDetIds_[]
Definition: ConstantsForCablingSource.h:23
sistrip::RESIDUAL_KURTOSIS_ALL_STRIPS
Definition: ConstantsForMonitorable.h:288
sistrip::NUM_OF_BAD_DOUBLE_PEAK
Definition: ConstantsForMonitorable.h:275
sistrip::CALIBRATION_AMPLITUDE_MAX
Definition: ConstantsForMonitorable.h:328
sistrip::calibrationPeakTimeTuned_
static const char calibrationPeakTimeTuned_[]
Definition: ConstantsForMonitorable.h:183
sistrip::HISTO_2D_SCATTER
Definition: ConstantsForPresentation.h:33
sistrip::fedZeroSupprLite8BBCMO_
static const char fedZeroSupprLite8BBCMO_[]
Definition: ConstantsForHardwareSystems.h:116
sistrip::UNKNOWN_RUN_TYPE
Definition: ConstantsForRunType.h:94
sistrip::vpspScanAdcLevel_
static const char vpspScanAdcLevel_[]
Definition: ConstantsForMonitorable.h:70
sistrip::PROFILE_1D
Definition: ConstantsForPresentation.h:34
sistrip::APV
Definition: ConstantsForGranularity.h:79
sistrip::optoScanBaseLiftOff_
static const char optoScanBaseLiftOff_[]
Definition: ConstantsForMonitorable.h:62
sistrip::fedApv_
static const char fedApv_[]
Definition: ConstantsForGranularity.h:47
sistrip::UNKNOWN_APV_READOUT_MODE
Definition: ConstantsForHardwareSystems.h:122
sistrip::FED_ZERO_SUPPR_LITE8_TT_CMO
Definition: ConstantsForHardwareSystems.h:139
sistrip::DISK
Definition: ConstantsForGranularity.h:73
sistrip::FED_SYSTEM
Definition: ConstantsForGranularity.h:81
sistrip::numOfBadDoublePeakStrips_
static const char numOfBadDoublePeakStrips_[]
Definition: ConstantsForMonitorable.h:101
SiStripEnumsAndStrings::view
static std::string view(const sistrip::View &)
Definition: SiStripEnumsAndStrings.cc:5
sistrip::jbProbabAllStrips_
static const char jbProbabAllStrips_[]
Definition: ConstantsForMonitorable.h:107
sistrip::CALIBRATION_BASELINE_SPREAD
Definition: ConstantsForMonitorable.h:340
sistrip::FED_TIMING
Definition: ConstantsForRunType.h:80
sistrip::UNKNOWN_CABLING_SOURCE
Definition: ConstantsForCablingSource.h:28
sistrip::APV_TIMING_PEAK
Definition: ConstantsForMonitorable.h:223
sistrip::calibrationRiseTimeMean_
static const char calibrationRiseTimeMean_[]
Definition: ConstantsForMonitorable.h:137
sistrip::daqScopeModeRun_
static const char daqScopeModeRun_[]
Definition: ConstantsForRunType.h:36
sistrip::undefinedRunType_
static const char undefinedRunType_[]
Definition: ConstantsForRunType.h:18
sistrip::fedZeroSupprLiteCMO_
static const char fedZeroSupprLiteCMO_[]
Definition: ConstantsForHardwareSystems.h:110
sistrip::fastCablingMax_
static const char fastCablingMax_[]
Definition: ConstantsForMonitorable.h:34
sistrip::calibrationTailMean_
static const char calibrationTailMean_[]
Definition: ConstantsForMonitorable.h:142
sistrip::FED_ZERO_SUPPR_LITE_CMO
Definition: ConstantsForHardwareSystems.h:137
sistrip::CALIBRATION_AMPLITUDE_SPREAD
Definition: ConstantsForMonitorable.h:339
sistrip::residualMeanAllStrips_
static const char residualMeanAllStrips_[]
Definition: ConstantsForMonitorable.h:112
sistrip::calibrationSmearingTuned_
static const char calibrationSmearingTuned_[]
Definition: ConstantsForMonitorable.h:184
sistrip::FEC_KEY
Definition: ConstantsForKeyType.h:31
sistrip::fastCablingLldCh_
static const char fastCablingLldCh_[]
Definition: ConstantsForMonitorable.h:28
sistrip::PEDS_ONLY
Definition: ConstantsForRunType.h:90
sistrip::CALIBRATION_DECAYTIME_ALL_STRIPS
Definition: ConstantsForMonitorable.h:310
sistrip::daqScopeModeMeanSignal_
static const char daqScopeModeMeanSignal_[]
Definition: ConstantsForMonitorable.h:195
sistrip::unknownMonitorable_
static const char unknownMonitorable_[]
Definition: ConstantsForMonitorable.h:18
sistrip::CALIBRATION_UNDERSHOOT_ALL_STRIPS
Definition: ConstantsForMonitorable.h:312
sistrip::fineDelayErr_
static const char fineDelayErr_[]
Definition: ConstantsForMonitorable.h:120
sistrip::fedCablingRun_
static const char fedCablingRun_[]
Definition: ConstantsForRunType.h:21
sistrip::invalid_
static const uint16_t invalid_
Definition: Constants.h:16
sistrip::UNDEFINED_CABLING_SOURCE
Definition: ConstantsForCablingSource.h:29
sistrip::fedVirginRaw_
static const char fedVirginRaw_[]
Definition: ConstantsForHardwareSystems.h:105
sistrip::cablingFromDevices_
static const char cablingFromDevices_[]
Definition: ConstantsForCablingSource.h:22
sistrip::CALIBRATION_CHI2_MEAN
Definition: ConstantsForMonitorable.h:304
sistrip::calibrationChi2Min_
static const char calibrationChi2Min_[]
Definition: ConstantsForMonitorable.h:154
SiStripEnumsAndStrings::monitorable
static std::string monitorable(const sistrip::Monitorable &)
Definition: SiStripEnumsAndStrings.cc:547
sistrip::fedSystem_
static const char fedSystem_[]
Definition: ConstantsForGranularity.h:43
sistrip::CALIBRATION_SMEARING_SPREAD
Definition: ConstantsForMonitorable.h:347
sistrip::CALIBRATION_CHI2_ALL_STRIPS
Definition: ConstantsForMonitorable.h:315
sistrip::UNKNOWN_VIEW
Definition: ConstantsForView.h:27
sistrip::calibrationSmearingMin_
static const char calibrationSmearingMin_[]
Definition: ConstantsForMonitorable.h:151
sistrip::residualRMSAllStrips_
static const char residualRMSAllStrips_[]
Definition: ConstantsForMonitorable.h:109
sistrip::CALIBRATION_RISETIME_MEAN
Definition: ConstantsForMonitorable.h:298
sistrip::calibrationPeakTimeMin_
static const char calibrationPeakTimeMin_[]
Definition: ConstantsForMonitorable.h:150
sistrip::FED_ZERO_SUPPR_LITE8_BB
Definition: ConstantsForHardwareSystems.h:142
sistrip::fedTimingBase_
static const char fedTimingBase_[]
Definition: ConstantsForMonitorable.h:52
sistrip::fedTimingRun_
static const char fedTimingRun_[]
Definition: ConstantsForRunType.h:23
sistrip::detKey_
static const char detKey_[]
Definition: ConstantsForKeyType.h:23
sistrip::vpspScanApv1_
static const char vpspScanApv1_[]
Definition: ConstantsForMonitorable.h:69
sistrip::FED_VIRGIN_RAW
Definition: ConstantsForHardwareSystems.h:133
sistrip::MULTI_MODE
Definition: ConstantsForRunType.h:79
sistrip::calibrationPeakTime_
static const char calibrationPeakTime_[]
Definition: ConstantsForMonitorable.h:129
sistrip::calibrationUndershootTuned_
static const char calibrationUndershootTuned_[]
Definition: ConstantsForMonitorable.h:186
sistrip::ApvReadoutMode
ApvReadoutMode
Definition: ConstantsForHardwareSystems.h:121
sistrip::calibrationRiseTime_
static const char calibrationRiseTime_[]
Definition: ConstantsForMonitorable.h:127
sistrip::NUM_OF_BAD_CHI2_PROBAB
Definition: ConstantsForMonitorable.h:273
sistrip::DAQ_SCOPE_MODE_MEAN_SIGNAL
Definition: ConstantsForMonitorable.h:365
sistrip::unknownFedReadoutMode_
static const char unknownFedReadoutMode_[]
Definition: ConstantsForHardwareSystems.h:101
sistrip::NUM_OF_BAD_AD_PROBAB
Definition: ConstantsForMonitorable.h:270
sistrip::FINE_DELAY_PLL
Definition: ConstantsForRunType.h:77
sistrip::cablingFromConns_
static const char cablingFromConns_[]
Definition: ConstantsForCablingSource.h:21
sistrip::calibrationAmplitudeTuned_
static const char calibrationAmplitudeTuned_[]
Definition: ConstantsForMonitorable.h:179
sistrip::calibrationPeakTimeMean_
static const char calibrationPeakTimeMean_[]
Definition: ConstantsForMonitorable.h:139
sistrip::fedTimingDelay_
static const char fedTimingDelay_[]
Definition: ConstantsForMonitorable.h:50
sistrip::calibrationChi2Spread_
static const char calibrationChi2Spread_[]
Definition: ConstantsForMonitorable.h:176
sistrip::apvTimingPeak_
static const char apvTimingPeak_[]
Definition: ConstantsForMonitorable.h:44
sistrip::calibrationVFSTuned_
static const char calibrationVFSTuned_[]
Definition: ConstantsForMonitorable.h:190
sistrip::CALIBRATION_DECAYTIME_MEAN
Definition: ConstantsForMonitorable.h:299
sistrip::feChan_
static const char feChan_[]
Definition: ConstantsForGranularity.h:46
sistrip::pedestalsMin_
static const char pedestalsMin_[]
Definition: ConstantsForMonitorable.h:79
sistrip::apvTimingTime_
static const char apvTimingTime_[]
Definition: ConstantsForMonitorable.h:39
sistrip::CALIBRATION_SCAN_DECO
Definition: ConstantsForRunType.h:88
sistrip::FAST_CABLING_HIGH_LEVEL
Definition: ConstantsForMonitorable.h:210
sistrip::fedZeroSupprLite8TB_
static const char fedZeroSupprLite8TB_[]
Definition: ConstantsForHardwareSystems.h:113
sistrip::PEDESTALS_SPREAD
Definition: ConstantsForMonitorable.h:251
sistrip::CALIBRATION_AMPLITUDE_MIN
Definition: ConstantsForMonitorable.h:317
sistrip::UNDEFINED_MONITORABLE
Definition: ConstantsForMonitorable.h:202
sistrip::apv_
static const char apv_[]
Definition: ConstantsForGranularity.h:40
sistrip::PHYSICS
Definition: ConstantsForRunType.h:71
sistrip::CALIBRATION_TURNON_ALL_STRIPS
Definition: ConstantsForMonitorable.h:308
sistrip::NOISE_MIN
Definition: ConstantsForMonitorable.h:259
sistrip::fedScopeMode_
static const char fedScopeMode_[]
Definition: ConstantsForHardwareSystems.h:104
sistrip::AD_PROBAB_ALL_STRIPS
Definition: ConstantsForMonitorable.h:279
sistrip::calibrationRiseTimeSpread_
static const char calibrationRiseTimeSpread_[]
Definition: ConstantsForMonitorable.h:170
sistrip::CALIBRATION_RISETIME_MIN
Definition: ConstantsForMonitorable.h:320
sistrip::FED_TIMING_DELAY
Definition: ConstantsForMonitorable.h:228
sistrip::ksProbabAllStrips_
static const char ksProbabAllStrips_[]
Definition: ConstantsForMonitorable.h:106
sistrip::APV_TIMING_HEIGHT
Definition: ConstantsForMonitorable.h:224
sistrip::NUM_OF_BAD_SHIFTED
Definition: ConstantsForMonitorable.h:265
sistrip::FED_TIMING_TIME
Definition: ConstantsForMonitorable.h:226
sistrip::CALIBRATION_RISETIME_SPREAD
Definition: ConstantsForMonitorable.h:342
sistrip::numOfBadLowNoiseStrips_
static const char numOfBadLowNoiseStrips_[]
Definition: ConstantsForMonitorable.h:96
sistrip::APV_LATENCY
Definition: ConstantsForRunType.h:76
SiStripEnumsAndStrings.h
sistrip::HistoType
HistoType
Definition: ConstantsForHistoType.h:26
sistrip::TOB
Definition: ConstantsForGranularity.h:67
sistrip::tib_
static const char tib_[]
Definition: ConstantsForGranularity.h:25
sistrip::UNDEFINED_RUN_TYPE
Definition: ConstantsForRunType.h:95
sistrip::calibrationTurnOnTuned_
static const char calibrationTurnOnTuned_[]
Definition: ConstantsForMonitorable.h:185
sistrip::residualIntegralAllStrips_
static const char residualIntegralAllStrips_[]
Definition: ConstantsForMonitorable.h:116
sistrip::CABLING_FROM_CONNS
Definition: ConstantsForCablingSource.h:30
sistrip::UNDEFINED_FED_READOUT_MODE
Definition: ConstantsForHardwareSystems.h:131
sistrip::calibrationPeakTimeMax_
static const char calibrationPeakTimeMax_[]
Definition: ConstantsForMonitorable.h:161
sistrip::fastCablingHighRms_
static const char fastCablingHighRms_[]
Definition: ConstantsForMonitorable.h:30
sistrip::calibrationDecayTimeMean_
static const char calibrationDecayTimeMean_[]
Definition: ConstantsForMonitorable.h:138
sistrip::fedTimingPeak_
static const char fedTimingPeak_[]
Definition: ConstantsForMonitorable.h:53
sistrip::CALIBRATION_BASELINE_TUNED
Definition: ConstantsForMonitorable.h:351
sistrip::calibrationTailSpread_
static const char calibrationTailSpread_[]
Definition: ConstantsForMonitorable.h:169
sistrip::CALIBRATION_TURNON_MIN
Definition: ConstantsForMonitorable.h:319
sistrip::calibrationDecayTimeSpread_
static const char calibrationDecayTimeSpread_[]
Definition: ConstantsForMonitorable.h:171
sistrip::FED_CHANNEL
Definition: ConstantsForGranularity.h:86
sistrip::SUMMARY_HISTO
Definition: ConstantsForHistoType.h:30
sistrip::calibDeconRun_
static const char calibDeconRun_[]
Definition: ConstantsForRunType.h:33
sistrip::NOISE
Definition: ConstantsForRunType.h:91
sistrip::calibrationRiseTimeMin_
static const char calibrationRiseTimeMin_[]
Definition: ConstantsForMonitorable.h:148
sistrip::CALIBRATION_VFS_TUNED
Definition: ConstantsForMonitorable.h:361
sistrip::PEDESTALS_MAX
Definition: ConstantsForMonitorable.h:252
sistrip::OPTO_SCAN_ZERO_LIGHT_LEVEL
Definition: ConstantsForMonitorable.h:236
sistrip::RESIDUAL_RMS_ALL_STRIPS
Definition: ConstantsForMonitorable.h:283
sistrip::calibrationUndershoot_
static const char calibrationUndershoot_[]
Definition: ConstantsForMonitorable.h:130
sistrip::CALIBRATION_ISHA_BEST
Definition: ConstantsForMonitorable.h:362
sistrip::CONTROL_VIEW
Definition: ConstantsForView.h:30
sistrip::OPTO_SCAN_BASELINE_LIFT_OFF
Definition: ConstantsForMonitorable.h:238
sistrip::CALIBRATION_ISHA_TUNED
Definition: ConstantsForMonitorable.h:360
sistrip::RESIDUAL_GAUS_ALL_STRIPS
Definition: ConstantsForMonitorable.h:284
sistrip::PARTITION
Definition: ConstantsForGranularity.h:65
sistrip::FAST_CABLING_LOW_RMS
Definition: ConstantsForMonitorable.h:213
sistrip::deadStripBit_
static const char deadStripBit_[]
Definition: ConstantsForMonitorable.h:104
sistrip::CALIBRATION_UNDERSHOOT_MAX
Definition: ConstantsForMonitorable.h:334
sistrip::undefinedApvReadoutMode_
static const char undefinedApvReadoutMode_[]
Definition: ConstantsForHardwareSystems.h:95
sistrip::NOISE_SPREAD
Definition: ConstantsForMonitorable.h:257
sistrip::apvPeakMode_
static const char apvPeakMode_[]
Definition: ConstantsForHardwareSystems.h:97
sistrip::calibrationTail_
static const char calibrationTail_[]
Definition: ConstantsForMonitorable.h:131
sistrip::fecRing_
static const char fecRing_[]
Definition: ConstantsForGranularity.h:54
sistrip::calibrationSmearingMax_
static const char calibrationSmearingMax_[]
Definition: ConstantsForMonitorable.h:162
sistrip::APV_DECON_MODE
Definition: ConstantsForHardwareSystems.h:125
sistrip::readoutView_
static const char readoutView_[]
Definition: ConstantsForView.h:20
sistrip::CALIBRATION_UNDERSHOOT_MIN
Definition: ConstantsForMonitorable.h:323
sistrip::fastCablingRun_
static const char fastCablingRun_[]
Definition: ConstantsForRunType.h:20
sistrip::numOfBadADProbabStrips_
static const char numOfBadADProbabStrips_[]
Definition: ConstantsForMonitorable.h:91
sistrip::NUM_OF_BAD_LARGE_SIGNIF
Definition: ConstantsForMonitorable.h:268
sistrip::FE_DRIVER
Definition: ConstantsForGranularity.h:82
sistrip::optoScanLldGain_
static const char optoScanLldGain_[]
Definition: ConstantsForMonitorable.h:58
sistrip::CALIBRATION_CHI2_SPREAD
Definition: ConstantsForMonitorable.h:348
sistrip::FED_KEY
Definition: ConstantsForKeyType.h:30
sistrip::FedReadoutMode
FedReadoutMode
Definition: ConstantsForHardwareSystems.h:129
sistrip::OPTO_SCAN_MEASURED_GAIN
Definition: ConstantsForMonitorable.h:235
sistrip::calibrationTurnOnMean_
static const char calibrationTurnOnMean_[]
Definition: ConstantsForMonitorable.h:136
sistrip::VPSP_SCAN_DIGITAL_LOW
Definition: ConstantsForMonitorable.h:247
sistrip::pedestalsMax_
static const char pedestalsMax_[]
Definition: ConstantsForMonitorable.h:78
sistrip::summaryHisto_
static const char summaryHisto_[]
Definition: ConstantsForHistoType.h:22
sistrip::NUM_OF_BAD_LOW_NOISE
Definition: ConstantsForMonitorable.h:266
sistrip::apvDeconMode_
static const char apvDeconMode_[]
Definition: ConstantsForHardwareSystems.h:98
sistrip::FED_PROC_RAW
Definition: ConstantsForHardwareSystems.h:134
sistrip::UNKNOWN_PRESENTATION
Definition: ConstantsForPresentation.h:29
sistrip::layer_
static const char layer_[]
Definition: ConstantsForGranularity.h:30
sistrip::OPTO_SCAN_LINK_NOISE
Definition: ConstantsForMonitorable.h:237
sistrip::NUM_OF_BAD
Definition: ConstantsForMonitorable.h:263
sistrip::fedTimingTime_
static const char fedTimingTime_[]
Definition: ConstantsForMonitorable.h:48
sistrip::CALIBRATION_CHI2_MAX
Definition: ConstantsForMonitorable.h:337
sistrip::CALIBRATION_BASELINE_ALL_STRIPS
Definition: ConstantsForMonitorable.h:307
sistrip::optoScanLaserThresh_
static const char optoScanLaserThresh_[]
Definition: ConstantsForMonitorable.h:63
sistrip::FEC_CRATE
Definition: ConstantsForGranularity.h:89
sistrip::calibrationRiseTimeMax_
static const char calibrationRiseTimeMax_[]
Definition: ConstantsForMonitorable.h:159
sistrip::UNDEFINED_GRAN
Definition: ConstantsForGranularity.h:61
sistrip::vpspScanBothApvs_
static const char vpspScanBothApvs_[]
Definition: ConstantsForMonitorable.h:67
sistrip::numOfBadStrips_
static const char numOfBadStrips_[]
Definition: ConstantsForMonitorable.h:90
sistrip::histo1d_
static const char histo1d_[]
Definition: ConstantsForPresentation.h:21
sistrip::CALIBRATION_BASELINE_MIN
Definition: ConstantsForMonitorable.h:318
sistrip::CABLING_FROM_DETIDS
Definition: ConstantsForCablingSource.h:32
sistrip::READOUT_VIEW
Definition: ConstantsForView.h:29
sistrip::calibrationPeakTimeSpread_
static const char calibrationPeakTimeSpread_[]
Definition: ConstantsForMonitorable.h:172
sistrip::FAST_CABLING_DCU_ID
Definition: ConstantsForMonitorable.h:208
sistrip::LLD_CHAN
Definition: ConstantsForGranularity.h:78
sistrip::FE_CHAN
Definition: ConstantsForGranularity.h:84
sistrip::CALIBRATION_TAIL_MIN
Definition: ConstantsForMonitorable.h:324
sistrip::CALIBRATION_AMPLITUDE_TUNED
Definition: ConstantsForMonitorable.h:350
sistrip::CALIBRATION_TURNON_MAX
Definition: ConstantsForMonitorable.h:330
sistrip::VPSP_SCAN_APV0_SETTING
Definition: ConstantsForMonitorable.h:243
sistrip::calibScanPeakRun_
static const char calibScanPeakRun_[]
Definition: ConstantsForRunType.h:34
SiStripEnumsAndStrings::keyType
static std::string keyType(const sistrip::KeyType &)
Definition: SiStripEnumsAndStrings.cc:231
sistrip::CHI2_PROBAB_ALL_STRIPS
Definition: ConstantsForMonitorable.h:282
sistrip::noiseAllStrips_
static const char noiseAllStrips_[]
Definition: ConstantsForMonitorable.h:82
sistrip::CALIBRATION_RISETIME_ALL_STRIPS
Definition: ConstantsForMonitorable.h:309
sistrip::fedZeroSupprLite8TTCMO_
static const char fedZeroSupprLite8TTCMO_[]
Definition: ConstantsForHardwareSystems.h:112
sistrip::calibrationChi2Max_
static const char calibrationChi2Max_[]
Definition: ConstantsForMonitorable.h:165
sistrip::feDriver_
static const char feDriver_[]
Definition: ConstantsForGranularity.h:44
sistrip::calibrationDecayTime_
static const char calibrationDecayTime_[]
Definition: ConstantsForMonitorable.h:128
DeadROC_duringRun.dir
dir
Definition: DeadROC_duringRun.py:23
sistrip::noiseMean_
static const char noiseMean_[]
Definition: ConstantsForMonitorable.h:83
sistrip::badStripBit_
static const char badStripBit_[]
Definition: ConstantsForMonitorable.h:103
sistrip::fedZeroSupprLite8TT_
static const char fedZeroSupprLite8TT_[]
Definition: ConstantsForHardwareSystems.h:111
sistrip::calibrationAmplitude_
static const char calibrationAmplitude_[]
Definition: ConstantsForMonitorable.h:124
sistrip::feUnit_
static const char feUnit_[]
Definition: ConstantsForGranularity.h:45
sistrip::FAST_CABLING_MIN
Definition: ConstantsForMonitorable.h:215
sistrip::unknownApvReadoutMode_
static const char unknownApvReadoutMode_[]
Definition: ConstantsForHardwareSystems.h:94
sistrip::undefinedHistoType_
static const char undefinedHistoType_[]
Definition: ConstantsForHistoType.h:19
sistrip::FED_TIMING_ERROR
Definition: ConstantsForMonitorable.h:229
sistrip::FEC_SLOT
Definition: ConstantsForGranularity.h:90
sistrip::numOfDeadStrips_
static const char numOfDeadStrips_[]
Definition: ConstantsForMonitorable.h:88
sistrip::CablingSource
CablingSource
Definition: ConstantsForCablingSource.h:27
sistrip::pedestalsSpread_
static const char pedestalsSpread_[]
Definition: ConstantsForMonitorable.h:77
Generated for CMSSW Reference Manual by doxygen 1.8.16