CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
SiStripEnumsAndStrings.cc
Go to the documentation of this file.
1 
2 #include "DataFormats/SiStripCommon/interface/SiStripEnumsAndStrings.h"
3 
4 // -----------------------------------------------------------------------------
5 //
6 std::string SiStripEnumsAndStrings::view( const sistrip::View& view ) {
7  if ( view == sistrip::READOUT_VIEW ) { return sistrip::readoutView_; }
8  else if ( view == sistrip::CONTROL_VIEW ) { return sistrip::controlView_; }
9  else if ( view == sistrip::DETECTOR_VIEW ) { return sistrip::detectorView_; }
10  else if ( view == sistrip::UNDEFINED_VIEW ) { return sistrip::undefinedView_; }
11  else { return sistrip::unknownView_; }
12 }
13 
14 // -----------------------------------------------------------------------------
15 //
16 sistrip::View SiStripEnumsAndStrings::view( const std::string& dir ) {
17  if ( dir.find( sistrip::readoutView_ ) != std::string::npos ) { return sistrip::READOUT_VIEW; }
18  else if ( dir.find( sistrip::controlView_ ) != std::string::npos ) { return sistrip::CONTROL_VIEW; }
19  else if ( dir.find( sistrip::detectorView_ ) != std::string::npos ) { return sistrip::DETECTOR_VIEW; }
20  else if ( dir.find( sistrip::undefinedView_ ) != std::string::npos ) { return sistrip::UNDEFINED_VIEW; }
21  else if ( dir.empty() ) { return sistrip::UNDEFINED_VIEW; }
22  else { return sistrip::UNKNOWN_VIEW; }
23 }
24 
25 // -----------------------------------------------------------------------------
26 //
27 std::string SiStripEnumsAndStrings::runType( const sistrip::RunType& run_type ) {
28  if ( run_type == sistrip::FAST_CABLING ) { return sistrip::fastCablingRun_; }
29  else if ( run_type == sistrip::FED_CABLING ) { return sistrip::fedCablingRun_; }
30  else if ( run_type == sistrip::APV_TIMING ) { return sistrip::apvTimingRun_; }
31  else if ( run_type == sistrip::FED_TIMING ) { return sistrip::fedTimingRun_; }
32  else if ( run_type == sistrip::OPTO_SCAN ) { return sistrip::optoScanRun_; }
33  else if ( run_type == sistrip::VPSP_SCAN ) { return sistrip::vpspScanRun_; }
34  else if ( run_type == sistrip::PEDESTALS ) { return sistrip::pedestalsRun_; }
35  else if ( run_type == sistrip::PEDS_ONLY ) { return sistrip::pedsOnlyRun_; }
36  else if ( run_type == sistrip::NOISE ) { return sistrip::noiseRun_; }
37  else if ( run_type == sistrip::PEDS_FULL_NOISE ) { return sistrip::pedsFullNoiseRun_; }
38  else if ( run_type == sistrip::APV_LATENCY ){ return sistrip::apvLatencyRun_; }
39  else if ( run_type == sistrip::FINE_DELAY ){ return sistrip::fineDelayRun_; }
40  else if ( run_type == sistrip::CALIBRATION ){ return sistrip::calibPeakRun_; }
41  else if ( run_type == sistrip::CALIBRATION_DECO ){ return sistrip::calibDeconRun_; }
42  else if ( run_type == sistrip::CALIBRATION_SCAN ){ return sistrip::calibScanPeakRun_; }
43  else if ( run_type == sistrip::CALIBRATION_SCAN_DECO ){ return sistrip::calibScanDeconRun_; }
44  else if ( run_type == sistrip::DAQ_SCOPE_MODE ){ return sistrip::daqScopeModeRun_; }
45  else if ( run_type == sistrip::PHYSICS ){ return sistrip::physicsRun_; }
46  else if ( run_type == sistrip::UNDEFINED_RUN_TYPE ) { return sistrip::undefinedRunType_; }
47  else { return sistrip::unknownRunType_; }
48 }
49 
50 // -----------------------------------------------------------------------------
51 //
52 sistrip::RunType SiStripEnumsAndStrings::runType( const std::string& run_type ) {
53  if ( run_type.find( sistrip::fastCablingRun_ ) != std::string::npos ) { return sistrip::FAST_CABLING; }
54  else if ( run_type.find( sistrip::fedCablingRun_ ) != std::string::npos ) { return sistrip::FED_CABLING; }
55  else if ( run_type.find( sistrip::apvTimingRun_ ) != std::string::npos ) { return sistrip::APV_TIMING; }
56  else if ( run_type.find( sistrip::fedTimingRun_ ) != std::string::npos ) { return sistrip::FED_TIMING; }
57  else if ( run_type.find( sistrip::optoScanRun_ ) != std::string::npos ) { return sistrip::OPTO_SCAN; }
58  else if ( run_type.find( sistrip::vpspScanRun_ ) != std::string::npos ) { return sistrip::VPSP_SCAN; }
59  else if ( run_type.find( sistrip::pedestalsRun_ ) != std::string::npos ) { return sistrip::PEDESTALS; }
60  else if ( run_type.find( sistrip::pedsOnlyRun_ ) != std::string::npos ) { return sistrip::PEDS_ONLY; }
61  else if ( run_type.find( sistrip::pedsFullNoiseRun_ ) != std::string::npos ) { return sistrip::PEDS_FULL_NOISE; } // needs to be before noise, otherwise name mismatch
62  else if ( run_type.find( sistrip::noiseRun_ ) != std::string::npos ) { return sistrip::NOISE; }
63  else if ( run_type.find( sistrip::fineDelayRun_ ) != std::string::npos ) { return sistrip::FINE_DELAY; }
64  else if ( run_type.find( sistrip::calibPeakRun_ ) != std::string::npos ) { return sistrip::CALIBRATION; }
65  else if ( run_type.find( sistrip::calibScanPeakRun_ ) != std::string::npos ) { return sistrip::CALIBRATION_SCAN; }
66  else if ( run_type.find( sistrip::calibDeconRun_ ) != std::string::npos ) { return sistrip::CALIBRATION_DECO; }
67  else if ( run_type.find( sistrip::calibScanDeconRun_ ) != std::string::npos ) { return sistrip::CALIBRATION_SCAN_DECO; }
68  else if ( run_type.find( sistrip::apvLatencyRun_ ) != std::string::npos ) { return sistrip::APV_LATENCY; }
69  else if ( run_type.find( sistrip::daqScopeModeRun_ ) != std::string::npos ) { return sistrip::DAQ_SCOPE_MODE; }
70  else if ( run_type.find( sistrip::physicsRun_ ) != std::string::npos ) { return sistrip::PHYSICS; }
71  else if ( run_type.find( sistrip::undefinedRunType_ ) != std::string::npos ) { return sistrip::UNDEFINED_RUN_TYPE; }
72  else if ( run_type.empty() ) { return sistrip::UNDEFINED_RUN_TYPE; }
73  else if ( run_type == "FAST_CABLING" ) { return sistrip::FAST_CABLING; }
74  else if ( run_type == "FED_CABLING" ) { return sistrip::FED_CABLING; }
75  else if ( run_type == "APV_TIMING" ) { return sistrip::APV_TIMING; }
76  else if ( run_type == "FED_TIMING" ) { return sistrip::FED_TIMING; }
77  else if ( run_type == "OPTO_SCAN" ) { return sistrip::OPTO_SCAN; }
78  else if ( run_type == "VPSP_SCAN" ) { return sistrip::VPSP_SCAN; }
79  else if ( run_type == "PEDESTALS" ) { return sistrip::PEDESTALS; }
80  else if ( run_type == "PEDS_FULL_NOISE" ) { return sistrip::PEDS_FULL_NOISE; }
81  else if ( run_type == "PEDS_ONLY" ) { return sistrip::PEDS_ONLY; }
82  else if ( run_type == "NOISE" ) { return sistrip::NOISE; }
83  else if ( run_type == "APV_LATENCY" ) { return sistrip::APV_LATENCY; }
84  else if ( run_type == "FINE_DELAY" ) { return sistrip::FINE_DELAY; }
85  else if ( run_type == "CALIBRATION" ) { return sistrip::CALIBRATION; }
86  else if ( run_type == "CALIBRATION_SCAN" ) { return sistrip::CALIBRATION_SCAN; }
87  else if ( run_type == "CALIBRATION_DECO" ) { return sistrip::CALIBRATION_DECO; }
88  else if ( run_type == "CALIBRATION_SCAN_DECO" ) { return sistrip::CALIBRATION_SCAN_DECO; }
89  else if ( run_type == "DAQ_SCOPE_MODE" ) { return sistrip::DAQ_SCOPE_MODE; }
90  else if ( run_type == "PHYSICS" ) { return sistrip::PHYSICS; }
91  else if ( run_type == "UNDEFINED" ) { return sistrip::UNDEFINED_RUN_TYPE; }
92  else { return sistrip::UNKNOWN_RUN_TYPE; }
93 }
94 
95 // -----------------------------------------------------------------------------
96 //
97 sistrip::RunType SiStripEnumsAndStrings::runType( const uint16_t& run_type ) {
98  if ( run_type == 1 ) { return sistrip::PHYSICS; }
99  else if ( run_type == 2 ) { return sistrip::PEDESTALS; }
100  else if ( run_type == 3 ) { return sistrip::CALIBRATION; }
101  else if ( run_type == 4 ) { return sistrip::OPTO_SCAN; }
102  else if ( run_type == 5 ) { return sistrip::APV_TIMING; }
103  else if ( run_type == 6 ) { return sistrip::APV_LATENCY; }
104  else if ( run_type == 7 ) { return sistrip::FINE_DELAY_PLL; }
105  else if ( run_type == 8 ) { return sistrip::FINE_DELAY_TTC; }
106  else if ( run_type == 10 ) { return sistrip::MULTI_MODE; }
107  else if ( run_type == 11 ) { return sistrip::FED_CABLING; }
108  else if ( run_type == 12 ) { return sistrip::FED_TIMING; }
109  else if ( run_type == 13 ) { return sistrip::FED_CABLING; }
110  else if ( run_type == 14 ) { return sistrip::VPSP_SCAN; }
111  else if ( run_type == 15 ) { return sistrip::DAQ_SCOPE_MODE; }
112  else if ( run_type == 16 ) { return sistrip::QUITE_FAST_CABLING; }
113  else if ( run_type == 17 ) { return sistrip::FINE_DELAY; } //@@ layer
114  else if ( run_type == 18 ) { return sistrip::PHYSICS_ZS; }
115  else if ( run_type == 19 ) { return sistrip::CALIBRATION_SCAN; }
116  else if ( run_type == 20 ) { return sistrip::CALIBRATION_SCAN_DECO; }
117  else if ( run_type == 21 ) { return sistrip::FAST_CABLING; }
118  else if ( run_type == 22 ) { return sistrip::PEDS_ONLY; }
119  else if ( run_type == 23 ) { return sistrip::NOISE; }
120  else if ( run_type == 24 ) { return sistrip::PEDS_FULL_NOISE; }
121  else if ( run_type == 33 ) { return sistrip::CALIBRATION_DECO; }
122  else if ( run_type == sistrip::invalid_ ) { return sistrip::UNDEFINED_RUN_TYPE; }
123  else { return sistrip::UNKNOWN_RUN_TYPE; }
124 }
125 
126 // -----------------------------------------------------------------------------
127 //
128 std::string SiStripEnumsAndStrings::keyType( const sistrip::KeyType& key_type ) {
129  if ( key_type == sistrip::FED_KEY ) { return sistrip::fedKey_; }
130  else if ( key_type == sistrip::FEC_KEY ) { return sistrip::fecKey_; }
131  else if ( key_type == sistrip::DET_KEY ) { return sistrip::detKey_; }
132  else if ( key_type == sistrip::UNDEFINED_KEY ) { return sistrip::undefinedKey_; }
133  else { return sistrip::unknownKey_; }
134 }
135 
136 // -----------------------------------------------------------------------------
137 //
138 sistrip::KeyType SiStripEnumsAndStrings::keyType( const std::string& key_type ) {
139  if ( key_type.find ( sistrip::fedKey_) != std::string::npos ) { return sistrip::FED_KEY; }
140  else if ( key_type.find( sistrip::fecKey_) != std::string::npos ) { return sistrip::FEC_KEY; }
141  else if ( key_type.find( sistrip::detKey_) != std::string::npos ) { return sistrip::DET_KEY; }
142  else if ( key_type.find( sistrip::undefinedKey_) != std::string::npos ) { return sistrip::UNDEFINED_KEY; }
143  else if ( key_type.empty() ) { return sistrip::UNDEFINED_KEY; }
144  else { return sistrip::UNKNOWN_KEY; }
145 }
146 
147 // -----------------------------------------------------------------------------
148 //
149 std::string SiStripEnumsAndStrings::granularity( const sistrip::Granularity& granularity ) {
150  // System
151  if ( granularity == sistrip::TRACKER ) { return sistrip::tracker_; }
152  else if ( granularity == sistrip::PARTITION ) { return sistrip::partition_; }
153  else if ( granularity == sistrip::TIB ) { return sistrip::tib_; }
154  else if ( granularity == sistrip::TOB ) { return sistrip::tob_; }
155  else if ( granularity == sistrip::TEC ) { return sistrip::tec_; }
156  // Sub-structure
157  else if ( granularity == sistrip::LAYER ) { return sistrip::layer_; }
158  else if ( granularity == sistrip::ROD ) { return sistrip::rod_; }
159  else if ( granularity == sistrip::STRING ) { return sistrip::string_; }
160  else if ( granularity == sistrip::DISK ) { return sistrip::disk_; }
161  else if ( granularity == sistrip::PETAL ) { return sistrip::petal_; }
162  else if ( granularity == sistrip::RING ) { return sistrip::ring_; }
163  // Module and below
164  else if ( granularity == sistrip::MODULE ) { return sistrip::module_; }
165  else if ( granularity == sistrip::LLD_CHAN ) { return sistrip::lldChan_; }
166  else if ( granularity == sistrip::APV ) { return sistrip::apv_; }
167  // Readout
168  else if ( granularity == sistrip::FED_SYSTEM ) { return sistrip::fedSystem_; }
169  else if ( granularity == sistrip::FE_DRIVER ) { return sistrip::feDriver_; }
170  else if ( granularity == sistrip::FE_UNIT ) { return sistrip::feUnit_; }
171  else if ( granularity == sistrip::FE_CHAN ) { return sistrip::feChan_; }
172  else if ( granularity == sistrip::FED_APV ) { return sistrip::fedApv_; }
173  else if ( granularity == sistrip::FED_CHANNEL ) { return sistrip::fedChannel_; }
174  // Control
175  else if ( granularity == sistrip::FEC_SYSTEM ) { return sistrip::fecSystem_; }
176  else if ( granularity == sistrip::FEC_CRATE ) { return sistrip::fecCrate_; }
177  else if ( granularity == sistrip::FEC_SLOT ) { return sistrip::fecSlot_; }
178  else if ( granularity == sistrip::FEC_RING ) { return sistrip::fecRing_; }
179  else if ( granularity == sistrip::CCU_ADDR ) { return sistrip::ccuAddr_; }
180  else if ( granularity == sistrip::CCU_CHAN ) { return sistrip::ccuChan_; }
181  // Unknown
182  else if ( granularity == sistrip::UNDEFINED_GRAN ) { return sistrip::undefinedGranularity_; }
183  else { return sistrip::unknownGranularity_; }
184 }
185 
186 // -----------------------------------------------------------------------------
187 //
188 sistrip::Granularity SiStripEnumsAndStrings::granularity( const std::string& granularity ) {
189  // System
190  if ( granularity.find( sistrip::tracker_ ) != std::string::npos ) { return sistrip::TRACKER; }
191  else if ( granularity.find( sistrip::partition_ ) != std::string::npos ) { return sistrip::PARTITION; }
192  else if ( granularity.find( sistrip::tib_ ) != std::string::npos ) { return sistrip::TIB; }
193  else if ( granularity.find( sistrip::tob_ ) != std::string::npos ) { return sistrip::TOB; }
194  else if ( granularity.find( sistrip::tec_ ) != std::string::npos ) { return sistrip::TEC; }
195  // Readout
196  else if ( granularity.find( sistrip::fedSystem_ ) != std::string::npos ) { return sistrip::FED_SYSTEM; }
197  else if ( granularity.find( sistrip::feDriver_ ) != std::string::npos ) { return sistrip::FE_DRIVER; }
198  else if ( granularity.find( sistrip::feUnit_ ) != std::string::npos ) { return sistrip::FE_UNIT; }
199  else if ( granularity.find( sistrip::feChan_ ) != std::string::npos ) { return sistrip::FE_CHAN; }
200  else if ( granularity.find( sistrip::fedApv_ ) != std::string::npos ) { return sistrip::FED_APV; }
201  else if ( granularity.find( sistrip::fedChannel_ ) != std::string::npos ) { return sistrip::FED_CHANNEL; }
202  // Control
203  else if ( granularity.find( sistrip::fecSystem_ ) != std::string::npos ) { return sistrip::FEC_SYSTEM; }
204  else if ( granularity.find( sistrip::fecCrate_ ) != std::string::npos ) { return sistrip::FEC_CRATE; }
205  else if ( granularity.find( sistrip::fecSlot_ ) != std::string::npos ) { return sistrip::FEC_SLOT; }
206  else if ( granularity.find( sistrip::fecRing_ ) != std::string::npos ) { return sistrip::FEC_RING; }
207  else if ( granularity.find( sistrip::ccuAddr_ ) != std::string::npos ) { return sistrip::CCU_ADDR; }
208  else if ( granularity.find( sistrip::ccuChan_ ) != std::string::npos ) { return sistrip::CCU_CHAN; }
209  // Sub-structure
210  else if ( granularity.find( sistrip::layer_ ) != std::string::npos ) { return sistrip::LAYER; }
211  else if ( granularity.find( sistrip::rod_ ) != std::string::npos ) { return sistrip::ROD; }
212  else if ( granularity.find( sistrip::string_ ) != std::string::npos ) { return sistrip::STRING; }
213  else if ( granularity.find( sistrip::disk_ ) != std::string::npos ) { return sistrip::DISK; }
214  else if ( granularity.find( sistrip::petal_ ) != std::string::npos ) { return sistrip::PETAL; }
215  else if ( granularity.find( sistrip::ring_ ) != std::string::npos ) { return sistrip::RING; }
216  // Module and below
217  else if ( granularity.find( sistrip::module_ ) != std::string::npos ) { return sistrip::MODULE; }
218  else if ( granularity.find( sistrip::lldChan_ ) != std::string::npos ) { return sistrip::LLD_CHAN; }
219  else if ( granularity.find( sistrip::apv_ ) != std::string::npos ) { return sistrip::APV; } //@@ bug if before "FedApv"!
220  // Unknown
221  else if ( granularity.find( sistrip::undefinedGranularity_ ) != std::string::npos ) { return sistrip::UNDEFINED_GRAN; }
222  else if ( granularity.empty() ) { return sistrip::UNDEFINED_GRAN; }
223  else { return sistrip::UNKNOWN_GRAN; }
224 }
225 
226 // -----------------------------------------------------------------------------
227 //
228 std::string SiStripEnumsAndStrings::apvReadoutMode( const sistrip::ApvReadoutMode& mode ) {
229  if ( mode == sistrip::APV_PEAK_MODE ) { return sistrip::apvPeakMode_; }
230  else if ( mode == sistrip::APV_DECON_MODE ) { return sistrip::apvDeconMode_; }
231  else if ( mode == sistrip::APV_MULTI_MODE ) { return sistrip::apvMultiMode_; }
232  else if ( mode == sistrip::UNDEFINED_APV_READOUT_MODE ) { return sistrip::undefinedApvReadoutMode_; }
233  else { return sistrip::unknownApvReadoutMode_; }
234 }
235 
236 // -----------------------------------------------------------------------------
237 //
238 sistrip::ApvReadoutMode SiStripEnumsAndStrings::apvReadoutMode( const std::string& mode ) {
239  if ( mode.find( sistrip::apvPeakMode_ ) != std::string::npos ) { return sistrip::APV_PEAK_MODE; }
240  else if ( mode.find( sistrip::apvDeconMode_ ) != std::string::npos ) { return sistrip::APV_DECON_MODE; }
241  else if ( mode.find( sistrip::apvMultiMode_ ) != std::string::npos ) { return sistrip::APV_MULTI_MODE; }
242  else if ( mode.find( sistrip::undefinedApvReadoutMode_ ) != std::string::npos ) { return sistrip::UNDEFINED_APV_READOUT_MODE; }
243  else if ( mode.empty() ) { return sistrip::UNDEFINED_APV_READOUT_MODE; }
244  else { return sistrip::UNKNOWN_APV_READOUT_MODE; }
245 }
246 
247 // -----------------------------------------------------------------------------
248 //
249 std::string SiStripEnumsAndStrings::fedReadoutMode( const sistrip::FedReadoutMode& mode ) {
250  if ( mode == sistrip::FED_SCOPE_MODE ) { return sistrip::fedScopeMode_; }
251  else if ( mode == sistrip::FED_VIRGIN_RAW ) { return sistrip::fedVirginRaw_; }
252  else if ( mode == sistrip::FED_PROC_RAW ) { return sistrip::fedProcRaw_; }
253  else if ( mode == sistrip::FED_ZERO_SUPPR ) { return sistrip::fedZeroSuppr_; }
254  else if ( mode == sistrip::FED_ZERO_SUPPR_LITE ) { return sistrip::fedZeroSupprLite_; }
255  else if ( mode == sistrip::UNDEFINED_FED_READOUT_MODE ) { return sistrip::undefinedFedReadoutMode_; }
256  else { return sistrip::unknownFedReadoutMode_; }
257 }
258 
259 // -----------------------------------------------------------------------------
260 //
261 sistrip::FedReadoutMode SiStripEnumsAndStrings::fedReadoutMode( const std::string& mode ) {
262  if ( mode.find( sistrip::fedScopeMode_ ) != std::string::npos ) { return sistrip::FED_SCOPE_MODE; }
263  else if ( mode.find( sistrip::fedVirginRaw_ ) != std::string::npos ) { return sistrip::FED_VIRGIN_RAW; }
264  else if ( mode.find( sistrip::fedProcRaw_ ) != std::string::npos ) { return sistrip::FED_PROC_RAW; }
265  else if ( mode.find( sistrip::fedZeroSuppr_ ) != std::string::npos ) { return sistrip::FED_ZERO_SUPPR; }
266  else if ( mode.find( sistrip::fedZeroSupprLite_ ) != std::string::npos ) { return sistrip::FED_ZERO_SUPPR_LITE; }
267  else if ( mode.find( sistrip::undefinedFedReadoutMode_ ) != std::string::npos ) { return sistrip::UNDEFINED_FED_READOUT_MODE; }
268  else if ( mode.empty() ) { return sistrip::UNDEFINED_FED_READOUT_MODE; }
269  else { return sistrip::UNKNOWN_FED_READOUT_MODE; }
270 }
271 
272 // -----------------------------------------------------------------------------
273 //
274 std::string SiStripEnumsAndStrings::histoType( const sistrip::HistoType& type ) {
275  if ( type == sistrip::EXPERT_HISTO ) { return sistrip::expertHisto_; }
276  else if ( type == sistrip::SUMMARY_HISTO ) { return sistrip::summaryHisto_; }
277  else if ( type == sistrip::UNDEFINED_HISTO_TYPE ) { return sistrip::undefinedHistoType_; }
278  else { return sistrip::unknownHistoType_; }
279 }
280 
281 // -----------------------------------------------------------------------------
282 //
283 sistrip::HistoType SiStripEnumsAndStrings::histoType( const std::string& type ) {
284  if ( type.find( sistrip::expertHisto_ ) != std::string::npos ) { return sistrip::EXPERT_HISTO; }
285  else if ( type.find( sistrip::summaryHisto_ ) != std::string::npos ) { return sistrip::SUMMARY_HISTO; }
286  else if ( type.find( sistrip::undefinedHistoType_ ) != std::string::npos ) { return sistrip::UNDEFINED_HISTO_TYPE; }
287  else if ( type.empty() ) { return sistrip::UNDEFINED_HISTO_TYPE; }
288  else { return sistrip::UNKNOWN_HISTO_TYPE; }
289 }
290 
291 // -----------------------------------------------------------------------------
292 //
293 std::string SiStripEnumsAndStrings::monitorable( const sistrip::Monitorable& mon ) {
294 
295  // fed cabling
296  if ( mon == sistrip::FED_CABLING_FED_ID ) { return sistrip::fedCablingFedId_; }
297  else if ( mon == sistrip::FED_CABLING_FED_CH ) { return sistrip::fedCablingFedCh_; }
298  else if ( mon == sistrip::FED_CABLING_ADC_LEVEL ) { return sistrip::fedCablingAdcLevel_; }
299 
300  // fast fed cabling
301  else if ( mon == sistrip::FAST_CABLING_DCU_ID ) { return sistrip::fastCablingDcuId_; }
302  else if ( mon == sistrip::FAST_CABLING_LLD_CH ) { return sistrip::fastCablingLldCh_; }
303  else if ( mon == sistrip::FAST_CABLING_HIGH_LEVEL ) { return sistrip::fastCablingHighLevel_; }
304  else if ( mon == sistrip::FAST_CABLING_HIGH_RMS ) { return sistrip::fastCablingHighRms_; }
305  else if ( mon == sistrip::FAST_CABLING_LOW_LEVEL ) { return sistrip::fastCablingLowLevel_; }
306  else if ( mon == sistrip::FAST_CABLING_LOW_RMS ) { return sistrip::fastCablingLowRms_; }
307  else if ( mon == sistrip::FAST_CABLING_MAX ) { return sistrip::fastCablingMax_; }
308  else if ( mon == sistrip::FAST_CABLING_MIN ) { return sistrip::fastCablingMin_; }
309  else if ( mon == sistrip::FAST_CABLING_CONNS_PER_FED ) { return sistrip::fastCablingConnsPerFed_; }
310 
311  // apv timing
312  else if ( mon == sistrip::APV_TIMING_TIME ) { return sistrip::apvTimingTime_; }
313  else if ( mon == sistrip::APV_TIMING_MAX_TIME ) { return sistrip::apvTimingMax_; }
314  else if ( mon == sistrip::APV_TIMING_DELAY ) { return sistrip::apvTimingDelay_; }
315  else if ( mon == sistrip::APV_TIMING_ERROR ) { return sistrip::apvTimingError_; }
316  else if ( mon == sistrip::APV_TIMING_BASE ) { return sistrip::apvTimingBase_; }
317  else if ( mon == sistrip::APV_TIMING_PEAK ) { return sistrip::apvTimingPeak_; }
318  else if ( mon == sistrip::APV_TIMING_HEIGHT ) { return sistrip::apvTimingHeight_; }
319 
320  // fed timing
321  else if ( mon == sistrip::FED_TIMING_TIME ) { return sistrip::fedTimingTime_; }
322  else if ( mon == sistrip::FED_TIMING_MAX_TIME ) { return sistrip::fedTimingMax_; }
323  else if ( mon == sistrip::FED_TIMING_DELAY ) { return sistrip::fedTimingDelay_; }
324  else if ( mon == sistrip::FED_TIMING_ERROR ) { return sistrip::fedTimingError_; }
325  else if ( mon == sistrip::FED_TIMING_BASE ) { return sistrip::fedTimingBase_; }
326  else if ( mon == sistrip::FED_TIMING_PEAK ) { return sistrip::fedTimingPeak_; }
327  else if ( mon == sistrip::FED_TIMING_HEIGHT ) { return sistrip::fedTimingHeight_; }
328 
329  // opto scan
330  else if ( mon == sistrip::OPTO_SCAN_LLD_GAIN_SETTING ) { return sistrip::optoScanLldGain_; }
331  else if ( mon == sistrip::OPTO_SCAN_LLD_BIAS_SETTING ) { return sistrip::optoScanLldBias_; }
332  else if ( mon == sistrip::OPTO_SCAN_MEASURED_GAIN ) { return sistrip::optoScanMeasGain_; }
333  else if ( mon == sistrip::OPTO_SCAN_ZERO_LIGHT_LEVEL ) { return sistrip::optoScanZeroLight_; }
334  else if ( mon == sistrip::OPTO_SCAN_LINK_NOISE ) { return sistrip::optoScanLinkNoise_; }
335  else if ( mon == sistrip::OPTO_SCAN_BASELINE_LIFT_OFF ) { return sistrip::optoScanBaseLiftOff_; }
336  else if ( mon == sistrip::OPTO_SCAN_LASER_THRESHOLD ) { return sistrip::optoScanLaserThresh_; }
337  else if ( mon == sistrip::OPTO_SCAN_TICK_HEIGHT ) { return sistrip::optoScanTickHeight_; }
338 
339  // vpsp scan
340  else if ( mon == sistrip::VPSP_SCAN_APV_SETTINGS ) { return sistrip::vpspScanBothApvs_; }
341  else if ( mon == sistrip::VPSP_SCAN_APV0_SETTING ) { return sistrip::vpspScanApv0_; }
342  else if ( mon == sistrip::VPSP_SCAN_APV1_SETTING ) { return sistrip::vpspScanApv1_; }
343  else if ( mon == sistrip::VPSP_SCAN_ADC_LEVEL ) { return sistrip::vpspScanAdcLevel_; }
344  else if ( mon == sistrip::VPSP_SCAN_DIGITAL_HIGH ) { return sistrip::vpspScanDigitalHigh_; }
345  else if ( mon == sistrip::VPSP_SCAN_DIGITAL_LOW ) { return sistrip::vpspScanDigitalLow_; }
346 
347  // pedestals / noise
348  else if ( mon == sistrip::PEDESTALS_ALL_STRIPS ) { return sistrip::pedestalsAllStrips_; }
349  else if ( mon == sistrip::PEDESTALS_MEAN ) { return sistrip::pedestalsMean_; }
350  else if ( mon == sistrip::PEDESTALS_SPREAD ) { return sistrip::pedestalsSpread_; }
351  else if ( mon == sistrip::PEDESTALS_MAX ) { return sistrip::pedestalsMax_; }
352  else if ( mon == sistrip::PEDESTALS_MIN ) { return sistrip::pedestalsMin_; }
353  else if ( mon == sistrip::NOISE_ALL_STRIPS ) { return sistrip::noiseAllStrips_; }
354  else if ( mon == sistrip::NOISE_MEAN ) { return sistrip::noiseMean_; }
355  else if ( mon == sistrip::NOISE_SPREAD ) { return sistrip::noiseSpread_; }
356  else if ( mon == sistrip::NOISE_MAX ) { return sistrip::noiseMax_; }
357  else if ( mon == sistrip::NOISE_MIN ) { return sistrip::noiseMin_; }
358  else if ( mon == sistrip::NUM_OF_DEAD ) { return sistrip::numOfDead_; }
359  else if ( mon == sistrip::NUM_OF_NOISY ) { return sistrip::numOfNoisy_; }
360  else if ( mon == sistrip::NOISE_GAUS_ALL_STRIPS ) { return sistrip::noiseGausAllStrips_; }
361  else if ( mon == sistrip::NOISE_KS_ALL_STRIPS ) { return sistrip::noiseKSAllStrips_; }
362  else if ( mon == sistrip::NOISE_CHI2_ALL_STRIPS ) { return sistrip::noiseChi2AllStrips_; }
363  else if ( mon == sistrip::NOISE_BIN_84_ALL_STRIPS) { return sistrip::noiseBin84AllStrips_; }
364  else if ( mon == sistrip::NOISE_RMS_ALL_STRIPS) { return sistrip::noiseRMSAllStrips_; }
365  else if ( mon == sistrip::NOISE_SIGNIF_ALL_STRIPS ) { return sistrip::noiseSignif_; }
366 
367  // fine delay
368  else if ( mon == sistrip::FINE_DELAY_POS) { return sistrip::fineDelayPos_; }
369  else if ( mon == sistrip::FINE_DELAY_ERROR) { return sistrip::fineDelayErr_; }
370 
371  // calibration
372  else if ( mon == sistrip::CALIBRATION_AMPLITUDE) { return sistrip::calibrationAmplitude_; }
373  else if ( mon == sistrip::CALIBRATION_TAIL) { return sistrip::calibrationTail_; }
374  else if ( mon == sistrip::CALIBRATION_RISETIME) { return sistrip::calibrationRiseTime_; }
375  else if ( mon == sistrip::CALIBRATION_TIMECONSTANT) { return sistrip::calibrationTimeConstant_; }
376  else if ( mon == sistrip::CALIBRATION_SMEARING) { return sistrip::calibrationSmearing_; }
377  else if ( mon == sistrip::CALIBRATION_CHI2) { return sistrip::calibrationChi2_; }
378  else if ( mon == sistrip::CALIBRATION_AMPLITUDE_ALLSTRIPS) { return sistrip::calibrationAmplitudeAS_; }
379  else if ( mon == sistrip::CALIBRATION_TAIL_ALLSTRIPS) { return sistrip::calibrationTailAS_; }
380  else if ( mon == sistrip::CALIBRATION_RISETIME_ALLSTRIPS) { return sistrip::calibrationRiseTimeAS_; }
381  else if ( mon == sistrip::CALIBRATION_TIMECONSTANT_ALLSTRIPS) { return sistrip::calibrationTimeConstantAS_; }
382  else if ( mon == sistrip::CALIBRATION_SMEARING_ALLSTRIPS) { return sistrip::calibrationSmearingAS_; }
383  else if ( mon == sistrip::CALIBRATION_CHI2_ALLSTRIPS) { return sistrip::calibrationChi2AS_; }
384  else if ( mon == sistrip::CALIBRATION_AMPLITUDE_MIN) { return sistrip::calibrationAmplitudeMin_; }
385  else if ( mon == sistrip::CALIBRATION_TAIL_MIN) { return sistrip::calibrationTailMin_; }
386  else if ( mon == sistrip::CALIBRATION_RISETIME_MIN) { return sistrip::calibrationRiseTimeMin_; }
387  else if ( mon == sistrip::CALIBRATION_TIMECONSTANT_MIN) { return sistrip::calibrationTimeConstantMin_; }
388  else if ( mon == sistrip::CALIBRATION_SMEARING_MIN) { return sistrip::calibrationSmearingMin_; }
389  else if ( mon == sistrip::CALIBRATION_CHI2_MIN) { return sistrip::calibrationChi2Min_; }
390  else if ( mon == sistrip::CALIBRATION_AMPLITUDE_MAX) { return sistrip::calibrationAmplitudeMax_; }
391  else if ( mon == sistrip::CALIBRATION_TAIL_MAX) { return sistrip::calibrationTailMax_; }
392  else if ( mon == sistrip::CALIBRATION_RISETIME_MAX) { return sistrip::calibrationRiseTimeMax_; }
393  else if ( mon == sistrip::CALIBRATION_TIMECONSTANT_MAX) { return sistrip::calibrationTimeConstantMax_; }
394  else if ( mon == sistrip::CALIBRATION_SMEARING_MAX) { return sistrip::calibrationSmearingMax_; }
395  else if ( mon == sistrip::CALIBRATION_CHI2_MAX) { return sistrip::calibrationChi2Max_; }
396 
397  // scope mode
398  else if ( mon == sistrip::DAQ_SCOPE_MODE_MEAN_SIGNAL ) { return sistrip::daqScopeModeMeanSignal_; }
399 
400  // unknown
401  else if ( mon == sistrip::UNDEFINED_MONITORABLE ) { return sistrip::undefinedMonitorable_; }
402  else { return sistrip::unknownMonitorable_; }
403 
404 }
405 
406 // -----------------------------------------------------------------------------
407 //
408 sistrip::Monitorable SiStripEnumsAndStrings::monitorable( const std::string& mon ) {
409 
410  // fed cabling
411  if ( mon.find( sistrip::fedCablingFedId_ ) != std::string::npos ) { return sistrip::FED_CABLING_FED_ID; }
412  else if ( mon.find( sistrip::fedCablingFedCh_ ) != std::string::npos ) { return sistrip::FED_CABLING_FED_CH; }
413  else if ( mon.find( sistrip::fedCablingAdcLevel_ ) != std::string::npos ) { return sistrip::FED_CABLING_ADC_LEVEL; }
414 
415  // fed cabling
416  else if ( mon.find( sistrip::fastCablingDcuId_ ) != std::string::npos ) { return sistrip::FAST_CABLING_DCU_ID; }
417  else if ( mon.find( sistrip::fastCablingLldCh_ ) != std::string::npos ) { return sistrip::FAST_CABLING_LLD_CH; }
418  else if ( mon.find( sistrip::fastCablingHighLevel_ ) != std::string::npos ) { return sistrip::FAST_CABLING_HIGH_LEVEL; }
419  else if ( mon.find( sistrip::fastCablingHighRms_ ) != std::string::npos ) { return sistrip::FAST_CABLING_HIGH_RMS; }
420  else if ( mon.find( sistrip::fastCablingLowLevel_ ) != std::string::npos ) { return sistrip::FAST_CABLING_LOW_LEVEL; }
421  else if ( mon.find( sistrip::fastCablingLowRms_ ) != std::string::npos ) { return sistrip::FAST_CABLING_LOW_RMS; }
422  else if ( mon.find( sistrip::fastCablingMax_ ) != std::string::npos ) { return sistrip::FAST_CABLING_MAX; }
423  else if ( mon.find( sistrip::fastCablingMin_ ) != std::string::npos ) { return sistrip::FAST_CABLING_MIN; }
424  else if ( mon.find( sistrip::fastCablingConnsPerFed_ ) != std::string::npos ) { return sistrip::FAST_CABLING_CONNS_PER_FED; }
425 
426  // apv timing
427  else if ( mon.find( sistrip::apvTimingTime_ ) != std::string::npos ) { return sistrip::APV_TIMING_TIME; }
428  else if ( mon.find( sistrip::apvTimingMax_ ) != std::string::npos ) { return sistrip::APV_TIMING_MAX_TIME; }
429  else if ( mon.find( sistrip::apvTimingDelay_ ) != std::string::npos ) { return sistrip::APV_TIMING_DELAY; }
430  else if ( mon.find( sistrip::apvTimingError_ ) != std::string::npos ) { return sistrip::APV_TIMING_ERROR; }
431  else if ( mon.find( sistrip::apvTimingBase_ ) != std::string::npos ) { return sistrip::APV_TIMING_BASE; }
432  else if ( mon.find( sistrip::apvTimingPeak_ ) != std::string::npos ) { return sistrip::APV_TIMING_PEAK; }
433  else if ( mon.find( sistrip::apvTimingHeight_ ) != std::string::npos ) { return sistrip::APV_TIMING_HEIGHT; }
434 
435  // fed timing
436  else if ( mon.find( sistrip::fedTimingTime_ ) != std::string::npos ) { return sistrip::FED_TIMING_TIME; }
437  else if ( mon.find( sistrip::fedTimingMax_ ) != std::string::npos ) { return sistrip::FED_TIMING_MAX_TIME; }
438  else if ( mon.find( sistrip::fedTimingDelay_ ) != std::string::npos ) { return sistrip::FED_TIMING_DELAY; }
439  else if ( mon.find( sistrip::fedTimingError_ ) != std::string::npos ) { return sistrip::FED_TIMING_ERROR; }
440  else if ( mon.find( sistrip::fedTimingBase_ ) != std::string::npos ) { return sistrip::FED_TIMING_BASE; }
441  else if ( mon.find( sistrip::fedTimingPeak_ ) != std::string::npos ) { return sistrip::FED_TIMING_PEAK; }
442  else if ( mon.find( sistrip::fedTimingHeight_ ) != std::string::npos ) { return sistrip::FED_TIMING_HEIGHT; }
443 
444  // opto scan
445  else if ( mon.find( sistrip::optoScanLldGain_ ) != std::string::npos ) { return sistrip::OPTO_SCAN_LLD_GAIN_SETTING; }
446  else if ( mon.find( sistrip::optoScanLldBias_ ) != std::string::npos ) { return sistrip::OPTO_SCAN_LLD_BIAS_SETTING; }
447  else if ( mon.find( sistrip::optoScanMeasGain_ ) != std::string::npos ) { return sistrip::OPTO_SCAN_MEASURED_GAIN; }
448  else if ( mon.find( sistrip::optoScanZeroLight_ ) != std::string::npos ) { return sistrip::OPTO_SCAN_ZERO_LIGHT_LEVEL; }
449  else if ( mon.find( sistrip::optoScanLinkNoise_ ) != std::string::npos ) { return sistrip::OPTO_SCAN_LINK_NOISE; }
450  else if ( mon.find( sistrip::optoScanBaseLiftOff_ ) != std::string::npos ) { return sistrip::OPTO_SCAN_BASELINE_LIFT_OFF; }
451  else if ( mon.find( sistrip::optoScanLaserThresh_ ) != std::string::npos ) { return sistrip::OPTO_SCAN_LASER_THRESHOLD; }
452  else if ( mon.find( sistrip::optoScanTickHeight_ ) != std::string::npos ) { return sistrip::OPTO_SCAN_TICK_HEIGHT; }
453 
454  // vpsp scan
455  else if ( mon.find( sistrip::vpspScanBothApvs_ ) != std::string::npos ) { return sistrip::VPSP_SCAN_APV_SETTINGS; }
456  else if ( mon.find( sistrip::vpspScanApv0_ ) != std::string::npos ) { return sistrip::VPSP_SCAN_APV0_SETTING; }
457  else if ( mon.find( sistrip::vpspScanApv1_ ) != std::string::npos ) { return sistrip::VPSP_SCAN_APV1_SETTING; }
458  else if ( mon.find( sistrip::vpspScanAdcLevel_ ) != std::string::npos ) { return sistrip::VPSP_SCAN_ADC_LEVEL; }
459  else if ( mon.find( sistrip::vpspScanDigitalHigh_ ) != std::string::npos ) { return sistrip::VPSP_SCAN_DIGITAL_HIGH; }
460  else if ( mon.find( sistrip::vpspScanDigitalLow_ ) != std::string::npos ) { return sistrip::VPSP_SCAN_DIGITAL_LOW; }
461 
462  // pedestals / noise
463  else if ( mon.find( sistrip::pedestalsAllStrips_ ) != std::string::npos ) { return sistrip::PEDESTALS_ALL_STRIPS; }
464  else if ( mon.find( sistrip::pedestalsMean_ ) != std::string::npos ) { return sistrip::PEDESTALS_MEAN; }
465  else if ( mon.find( sistrip::pedestalsSpread_ ) != std::string::npos ) { return sistrip::PEDESTALS_SPREAD; }
466  else if ( mon.find( sistrip::pedestalsMax_ ) != std::string::npos ) { return sistrip::PEDESTALS_MAX; }
467  else if ( mon.find( sistrip::pedestalsMin_ ) != std::string::npos ) { return sistrip::PEDESTALS_MIN; }
468 
469  // noiseKS must come before the more general noiseAllStrips, since it contains that string
470  else if ( mon.find( sistrip::noiseGausAllStrips_ ) != std::string::npos ) { return sistrip::NOISE_GAUS_ALL_STRIPS; }
471  else if ( mon.find( sistrip::noiseKSAllStrips_ ) != std::string::npos ) { return sistrip::NOISE_KS_ALL_STRIPS; }
472  else if ( mon.find( sistrip::noiseChi2AllStrips_ ) != std::string::npos ) { return sistrip::NOISE_CHI2_ALL_STRIPS; }
473  else if ( mon.find( sistrip::noiseBin84AllStrips_ ) != std::string::npos ) { return sistrip::NOISE_BIN_84_ALL_STRIPS;}
474  else if ( mon.find( sistrip::noiseRMSAllStrips_ ) != std::string::npos ) { return sistrip::NOISE_RMS_ALL_STRIPS;}
475  else if ( mon.find( sistrip::noiseSignif_ ) != std::string::npos ) { return sistrip::NOISE_SIGNIF_ALL_STRIPS; }
476  else if ( mon.find( sistrip::noiseAllStrips_ ) != std::string::npos ) { return sistrip::NOISE_ALL_STRIPS; }
477  else if ( mon.find( sistrip::noiseMean_ ) != std::string::npos ) { return sistrip::NOISE_MEAN; }
478  else if ( mon.find( sistrip::noiseSpread_ ) != std::string::npos ) { return sistrip::NOISE_SPREAD; }
479  else if ( mon.find( sistrip::noiseMax_ ) != std::string::npos ) { return sistrip::NOISE_MAX; }
480  else if ( mon.find( sistrip::noiseMin_ ) != std::string::npos ) { return sistrip::NOISE_MIN; }
481  else if ( mon.find( sistrip::numOfDead_ ) != std::string::npos ) { return sistrip::NUM_OF_DEAD; }
482  else if ( mon.find( sistrip::numOfNoisy_ ) != std::string::npos ) { return sistrip::NUM_OF_NOISY; }
483 
484  // fine delay
485  else if ( mon.find( sistrip::fineDelayPos_ ) != std::string::npos ) { return sistrip::FINE_DELAY_POS; }
486  else if ( mon.find( sistrip::fineDelayErr_ ) != std::string::npos ) { return sistrip::FINE_DELAY_ERROR; }
487 
488  // calibration
489  else if ( mon.find( sistrip::calibrationAmplitudeAS_ ) != std::string::npos ) { return sistrip::CALIBRATION_AMPLITUDE_ALLSTRIPS; }
490  else if ( mon.find( sistrip::calibrationTailAS_ ) != std::string::npos ) { return sistrip::CALIBRATION_TAIL_ALLSTRIPS; }
491  else if ( mon.find( sistrip::calibrationRiseTimeAS_ ) != std::string::npos ) { return sistrip::CALIBRATION_RISETIME_ALLSTRIPS; }
492  else if ( mon.find( sistrip::calibrationTimeConstantAS_ ) != std::string::npos ) { return sistrip::CALIBRATION_TIMECONSTANT_ALLSTRIPS; }
493  else if ( mon.find( sistrip::calibrationSmearingAS_ ) != std::string::npos ) { return sistrip::CALIBRATION_SMEARING_ALLSTRIPS; }
494  else if ( mon.find( sistrip::calibrationChi2AS_ ) != std::string::npos ) { return sistrip::CALIBRATION_CHI2_ALLSTRIPS; }
495  else if ( mon.find( sistrip::calibrationAmplitudeMin_ ) != std::string::npos ) { return sistrip::CALIBRATION_AMPLITUDE_MIN; }
496  else if ( mon.find( sistrip::calibrationTailMin_ ) != std::string::npos ) { return sistrip::CALIBRATION_TAIL_MIN; }
497  else if ( mon.find( sistrip::calibrationRiseTimeMin_ ) != std::string::npos ) { return sistrip::CALIBRATION_RISETIME_MIN; }
498  else if ( mon.find( sistrip::calibrationTimeConstantMin_ ) != std::string::npos ) { return sistrip::CALIBRATION_TIMECONSTANT_MIN; }
499  else if ( mon.find( sistrip::calibrationSmearingMin_ ) != std::string::npos ) { return sistrip::CALIBRATION_SMEARING_MIN; }
500  else if ( mon.find( sistrip::calibrationChi2Min_ ) != std::string::npos ) { return sistrip::CALIBRATION_CHI2_MIN; }
501  else if ( mon.find( sistrip::calibrationAmplitudeMax_ ) != std::string::npos ) { return sistrip::CALIBRATION_AMPLITUDE_MAX; }
502  else if ( mon.find( sistrip::calibrationTailMax_ ) != std::string::npos ) { return sistrip::CALIBRATION_TAIL_MAX; }
503  else if ( mon.find( sistrip::calibrationRiseTimeMax_ ) != std::string::npos ) { return sistrip::CALIBRATION_RISETIME_MAX; }
504  else if ( mon.find( sistrip::calibrationTimeConstantMax_ ) != std::string::npos ) { return sistrip::CALIBRATION_TIMECONSTANT_MAX; }
505  else if ( mon.find( sistrip::calibrationSmearingMax_ ) != std::string::npos ) { return sistrip::CALIBRATION_SMEARING_MAX; }
506  else if ( mon.find( sistrip::calibrationChi2Max_ ) != std::string::npos ) { return sistrip::CALIBRATION_CHI2_MAX; }
507  else if ( mon.find( sistrip::calibrationAmplitude_ ) != std::string::npos ) { return sistrip::CALIBRATION_AMPLITUDE; }
508  else if ( mon.find( sistrip::calibrationTail_ ) != std::string::npos ) { return sistrip::CALIBRATION_TAIL; }
509  else if ( mon.find( sistrip::calibrationRiseTime_ ) != std::string::npos ) { return sistrip::CALIBRATION_RISETIME; }
510  else if ( mon.find( sistrip::calibrationTimeConstant_ ) != std::string::npos ) { return sistrip::CALIBRATION_TIMECONSTANT; }
511  else if ( mon.find( sistrip::calibrationSmearing_ ) != std::string::npos ) { return sistrip::CALIBRATION_SMEARING; }
512  else if ( mon.find( sistrip::calibrationChi2_ ) != std::string::npos ) { return sistrip::CALIBRATION_CHI2; }
513 
514  // scope mode
515  else if ( mon.find( sistrip::daqScopeModeMeanSignal_ ) != std::string::npos ) { return sistrip::DAQ_SCOPE_MODE_MEAN_SIGNAL; }
516 
517  // unknown
518  else if ( mon.find( sistrip::undefinedMonitorable_ ) != std::string::npos ) { return sistrip::UNDEFINED_MONITORABLE; }
519  else if ( mon.empty() ) { return sistrip::UNDEFINED_MONITORABLE; }
520  else { return sistrip::UNKNOWN_MONITORABLE; }
521 
522 }
523 
524 // -----------------------------------------------------------------------------
525 //
526 std::string SiStripEnumsAndStrings::presentation( const sistrip::Presentation& type ) {
527  if ( type == sistrip::HISTO_1D ) { return sistrip::histo1d_; }
528  else if ( type == sistrip::HISTO_2D_SUM ) { return sistrip::histo2dSum_; }
529  else if ( type == sistrip::HISTO_2D_SCATTER ) { return sistrip::histo2dScatter_; }
530  else if ( type == sistrip::PROFILE_1D ) { return sistrip::profile1D_; }
531  else if ( type == sistrip::UNDEFINED_PRESENTATION ) { return sistrip::undefinedPresentation_; }
532  else { return sistrip::unknownPresentation_; }
533 }
534 
535 // -----------------------------------------------------------------------------
536 //
537 sistrip::Presentation SiStripEnumsAndStrings::presentation( const std::string& type ) {
538  if ( type.find( sistrip::histo1d_ ) != std::string::npos ) { return sistrip::HISTO_1D; }
539  else if ( type.find( sistrip::histo2dSum_ ) != std::string::npos ) { return sistrip::HISTO_2D_SUM; }
540  else if ( type.find( sistrip::histo2dScatter_ ) != std::string::npos ) { return sistrip::HISTO_2D_SCATTER; }
541  else if ( type.find( sistrip::profile1D_ ) != std::string::npos ) { return sistrip::PROFILE_1D; }
542  else if ( type.find( sistrip::undefinedPresentation_ ) != std::string::npos ) { return sistrip::UNDEFINED_PRESENTATION; }
543  else if ( type.empty() ) { return sistrip::UNDEFINED_PRESENTATION; }
544  else { return sistrip::UNKNOWN_PRESENTATION; }
545 }
546 
547 // -----------------------------------------------------------------------------
548 //
549 std::string SiStripEnumsAndStrings::cablingSource( const sistrip::CablingSource& source ) {
550  if ( source == sistrip::CABLING_FROM_CONNS ) { return sistrip::cablingFromConns_; }
551  else if ( source == sistrip::CABLING_FROM_DEVICES ) { return sistrip::cablingFromDevices_; }
552  else if ( source == sistrip::CABLING_FROM_DETIDS ) { return sistrip::cablingFromDetIds_; }
553  else if ( source == sistrip::UNDEFINED_CABLING_SOURCE ) { return sistrip::undefinedCablingSource_; }
554  else { return sistrip::unknownCablingSource_; }
555 }
556 
557 // -----------------------------------------------------------------------------
558 //
559 sistrip::CablingSource SiStripEnumsAndStrings::cablingSource( const std::string& source ) {
560  if ( source.find( sistrip::cablingFromConns_ ) != std::string::npos ) { return sistrip::CABLING_FROM_CONNS; }
561  else if ( source.find( sistrip::cablingFromDevices_ ) != std::string::npos ) { return sistrip::CABLING_FROM_DEVICES; }
562  else if ( source.find( sistrip::cablingFromDetIds_ ) != std::string::npos ) { return sistrip::CABLING_FROM_DETIDS; }
563  else if ( source.find( sistrip::undefinedCablingSource_ ) != std::string::npos ) { return sistrip::UNDEFINED_CABLING_SOURCE; }
564  else if ( source.empty() ) { return sistrip::UNDEFINED_CABLING_SOURCE; }
565  else if ( source == "CONNECTIONS" ) { return sistrip::CABLING_FROM_CONNS; }
566  else if ( source == "DEVICES" ) { return sistrip::CABLING_FROM_DEVICES; }
567  else if ( source == "DETIDS" ) { return sistrip::CABLING_FROM_DETIDS; }
568  else if ( source == "UNDEFINED" ) { return sistrip::UNDEFINED_CABLING_SOURCE; }
569  else { return sistrip::UNKNOWN_CABLING_SOURCE; }
570 }
571 
sistrip::unknownView_
static const char unknownView_[]
Definition: ConstantsForView.h:17
sistrip::module_
static const char module_[]
Definition: ConstantsForGranularity.h:38
type
type
Definition: HCALResponse.h:21
sistrip::optoScanLinkNoise_
static const char optoScanLinkNoise_[]
Definition: ConstantsForMonitorable.h:62
sistrip::calibrationAmplitude_
static const char calibrationAmplitude_[]
Definition: ConstantsForMonitorable.h:102
sistrip::fastCablingDcuId_
static const char fastCablingDcuId_[]
Definition: ConstantsForMonitorable.h:28
sistrip::feDriver_
static const char feDriver_[]
Definition: ConstantsForGranularity.h:44
SiStripEnumsAndStrings::monitorable
static std::string monitorable(const sistrip::Monitorable &)
Definition: SiStripEnumsAndStrings.cc:293
sistrip::fastCablingRun_
static const char fastCablingRun_[]
Definition: ConstantsForRunType.h:20
sistrip::optoScanLldGain_
static const char optoScanLldGain_[]
Definition: ConstantsForMonitorable.h:59
sistrip::calibrationAmplitudeAS_
static const char calibrationAmplitudeAS_[]
Definition: ConstantsForMonitorable.h:108
sistrip::layer_
static const char layer_[]
Definition: ConstantsForGranularity.h:30
sistrip::tec_
static const char tec_[]
Definition: ConstantsForGranularity.h:27
sistrip::calibrationTimeConstantMax_
static const char calibrationTimeConstantMax_[]
Definition: ConstantsForMonitorable.h:123
sistrip::undefinedKey_
static const char undefinedKey_[]
Definition: ConstantsForKeyType.h:19
sistrip::vpspScanRun_
static const char vpspScanRun_[]
Definition: ConstantsForRunType.h:25
sistrip::apvDeconMode_
static const char apvDeconMode_[]
Definition: ConstantsForHardwareSystems.h:99
sistrip::tracker_
static const char tracker_[]
Definition: ConstantsForGranularity.h:23
sistrip::summaryHisto_
static const char summaryHisto_[]
Definition: ConstantsForHistoType.h:22
sistrip::calibrationRiseTimeMax_
static const char calibrationRiseTimeMax_[]
Definition: ConstantsForMonitorable.h:122
sistrip::noiseKSAllStrips_
static const char noiseKSAllStrips_[]
Definition: ConstantsForMonitorable.h:90
sistrip::fedTimingError_
static const char fedTimingError_[]
Definition: ConstantsForMonitorable.h:52
sistrip::calibScanPeakRun_
static const char calibScanPeakRun_[]
Definition: ConstantsForRunType.h:34
sistrip::tob_
static const char tob_[]
Definition: ConstantsForGranularity.h:26
sistrip::unknownCablingSource_
static const char unknownCablingSource_[]
Definition: ConstantsForCablingSource.h:18
sistrip::noiseMean_
static const char noiseMean_[]
Definition: ConstantsForMonitorable.h:84
sistrip::unknownKey_
static const char unknownKey_[]
Definition: ConstantsForKeyType.h:18
sistrip::fastCablingMin_
static const char fastCablingMin_[]
Definition: ConstantsForMonitorable.h:36
sistrip::numOfDead_
static const char numOfDead_[]
Definition: ConstantsForMonitorable.h:88
sistrip::calibScanDeconRun_
static const char calibScanDeconRun_[]
Definition: ConstantsForRunType.h:35
sistrip::unknownHistoType_
static const char unknownHistoType_[]
Definition: ConstantsForHistoType.h:18
sistrip::calibrationTimeConstantMin_
static const char calibrationTimeConstantMin_[]
Definition: ConstantsForMonitorable.h:117
sistrip::fedCablingAdcLevel_
static const char fedCablingAdcLevel_[]
Definition: ConstantsForMonitorable.h:25
sistrip::calibrationAmplitudeMax_
static const char calibrationAmplitudeMax_[]
Definition: ConstantsForMonitorable.h:120
sistrip::unknownPresentation_
static const char unknownPresentation_[]
Definition: ConstantsForPresentation.h:18
sistrip::apvTimingHeight_
static const char apvTimingHeight_[]
Definition: ConstantsForMonitorable.h:46
sistrip::histo2dScatter_
static const char histo2dScatter_[]
Definition: ConstantsForPresentation.h:23
sistrip::profile1D_
static const char profile1D_[]
Definition: ConstantsForPresentation.h:24
sistrip::physicsRun_
static const char physicsRun_[]
Definition: ConstantsForRunType.h:37
sistrip::apvTimingMax_
static const char apvTimingMax_[]
Definition: ConstantsForMonitorable.h:41
sistrip::optoScanTickHeight_
static const char optoScanTickHeight_[]
Definition: ConstantsForMonitorable.h:65
sistrip::fedKey_
static const char fedKey_[]
Definition: ConstantsForKeyType.h:21
SiStripEnumsAndStrings::granularity
static std::string granularity(const sistrip::Granularity &)
Definition: SiStripEnumsAndStrings.cc:149
sistrip::fineDelayPos_
static const char fineDelayPos_[]
Definition: ConstantsForMonitorable.h:98
sistrip::noiseMax_
static const char noiseMax_[]
Definition: ConstantsForMonitorable.h:86
sistrip::calibrationSmearingAS_
static const char calibrationSmearingAS_[]
Definition: ConstantsForMonitorable.h:112
sistrip::rod_
static const char rod_[]
Definition: ConstantsForGranularity.h:31
sistrip::noiseMin_
static const char noiseMin_[]
Definition: ConstantsForMonitorable.h:87
sistrip::fedZeroSupprLite_
static const char fedZeroSupprLite_[]
Definition: ConstantsForHardwareSystems.h:109
sistrip::calibrationTimeConstantAS_
static const char calibrationTimeConstantAS_[]
Definition: ConstantsForMonitorable.h:111
alignBH_cfg.mode
list mode
Definition: alignBH_cfg.py:7
sistrip::optoScanMeasGain_
static const char optoScanMeasGain_[]
Definition: ConstantsForMonitorable.h:60
sistrip::fineDelayRun_
static const char fineDelayRun_[]
Definition: ConstantsForRunType.h:31
sistrip::pedestalsMean_
static const char pedestalsMean_[]
Definition: ConstantsForMonitorable.h:77
sistrip::detectorView_
static const char detectorView_[]
Definition: ConstantsForView.h:22
sistrip::fedTimingHeight_
static const char fedTimingHeight_[]
Definition: ConstantsForMonitorable.h:55
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
sistrip::string_
static const char string_[]
Definition: ConstantsForGranularity.h:32
sistrip::histo2dSum_
static const char histo2dSum_[]
Definition: ConstantsForPresentation.h:22
sistrip::fecSlot_
static const char fecSlot_[]
Definition: ConstantsForGranularity.h:53
sistrip::undefinedView_
static const char undefinedView_[]
Definition: ConstantsForView.h:18
sistrip::ccuChan_
static const char ccuChan_[]
Definition: ConstantsForGranularity.h:56
sistrip::ccuAddr_
static const char ccuAddr_[]
Definition: ConstantsForGranularity.h:55
sistrip::apvTimingRun_
static const char apvTimingRun_[]
Definition: ConstantsForRunType.h:22
sistrip::fedCablingFedId_
static const char fedCablingFedId_[]
Definition: ConstantsForMonitorable.h:23
sistrip::fedCablingFedCh_
static const char fedCablingFedCh_[]
Definition: ConstantsForMonitorable.h:24
SiStripEnumsAndStrings::view
static std::string view(const sistrip::View &)
Definition: SiStripEnumsAndStrings.cc:6
SiStripEnumsAndStrings::runType
static std::string runType(const sistrip::RunType &)
Definition: SiStripEnumsAndStrings.cc:27
sistrip::optoScanLldBias_
static const char optoScanLldBias_[]
Definition: ConstantsForMonitorable.h:58
sistrip::pedsOnlyRun_
static const char pedsOnlyRun_[]
Definition: ConstantsForRunType.h:27
sistrip::lldChan_
static const char lldChan_[]
Definition: ConstantsForGranularity.h:39
sistrip::undefinedGranularity_
static const char undefinedGranularity_[]
Definition: ConstantsForGranularity.h:20
sistrip::calibrationAmplitudeMin_
static const char calibrationAmplitudeMin_[]
Definition: ConstantsForMonitorable.h:114
SiStripEnumsAndStrings::apvReadoutMode
static std::string apvReadoutMode(const sistrip::ApvReadoutMode &)
Definition: SiStripEnumsAndStrings.cc:228
sistrip::apvTimingDelay_
static const char apvTimingDelay_[]
Definition: ConstantsForMonitorable.h:42
sistrip::pedestalsRun_
static const char pedestalsRun_[]
Definition: ConstantsForRunType.h:26
sistrip::calibrationSmearing_
static const char calibrationSmearing_[]
Definition: ConstantsForMonitorable.h:106
sistrip::undefinedCablingSource_
static const char undefinedCablingSource_[]
Definition: ConstantsForCablingSource.h:19
sistrip::noiseRun_
static const char noiseRun_[]
Definition: ConstantsForRunType.h:28
sistrip::partition_
static const char partition_[]
Definition: ConstantsForGranularity.h:24
sistrip::numOfNoisy_
static const char numOfNoisy_[]
Definition: ConstantsForMonitorable.h:89
sistrip::calibrationTailMin_
static const char calibrationTailMin_[]
Definition: ConstantsForMonitorable.h:115
sistrip::vpspScanDigitalHigh_
static const char vpspScanDigitalHigh_[]
Definition: ConstantsForMonitorable.h:72
sistrip::fedApv_
static const char fedApv_[]
Definition: ConstantsForGranularity.h:47
sistrip::pedsFullNoiseRun_
static const char pedsFullNoiseRun_[]
Definition: ConstantsForRunType.h:29
sistrip::expertHisto_
static const char expertHisto_[]
Definition: ConstantsForHistoType.h:21
sistrip::undefinedMonitorable_
static const char undefinedMonitorable_[]
Definition: ConstantsForMonitorable.h:20
sistrip::undefinedPresentation_
static const char undefinedPresentation_[]
Definition: ConstantsForPresentation.h:19
sistrip::controlView_
static const char controlView_[]
Definition: ConstantsForView.h:21
sistrip::fastCablingLowRms_
static const char fastCablingLowRms_[]
Definition: ConstantsForMonitorable.h:33
sistrip::optoScanBaseLiftOff_
static const char optoScanBaseLiftOff_[]
Definition: ConstantsForMonitorable.h:63
sistrip::fedProcRaw_
static const char fedProcRaw_[]
Definition: ConstantsForHardwareSystems.h:107
sistrip::calibrationTailMax_
static const char calibrationTailMax_[]
Definition: ConstantsForMonitorable.h:121
sistrip::fastCablingLldCh_
static const char fastCablingLldCh_[]
Definition: ConstantsForMonitorable.h:29
sistrip::optoScanZeroLight_
static const char optoScanZeroLight_[]
Definition: ConstantsForMonitorable.h:61
sistrip::vpspScanDigitalLow_
static const char vpspScanDigitalLow_[]
Definition: ConstantsForMonitorable.h:73
sistrip::unknownGranularity_
static const char unknownGranularity_[]
Definition: ConstantsForGranularity.h:19
sistrip::ring_
static const char ring_[]
Definition: ConstantsForGranularity.h:35
SiStripEnumsAndStrings::histoType
static std::string histoType(const sistrip::HistoType &)
Definition: SiStripEnumsAndStrings.cc:274
sistrip::calibrationTimeConstant_
static const char calibrationTimeConstant_[]
Definition: ConstantsForMonitorable.h:105
sistrip::undefinedRunType_
static const char undefinedRunType_[]
Definition: ConstantsForRunType.h:18
sistrip::calibrationTailAS_
static const char calibrationTailAS_[]
Definition: ConstantsForMonitorable.h:109
sistrip::fedVirginRaw_
static const char fedVirginRaw_[]
Definition: ConstantsForHardwareSystems.h:106
sistrip::fecCrate_
static const char fecCrate_[]
Definition: ConstantsForGranularity.h:52
sistrip::noiseGausAllStrips_
static const char noiseGausAllStrips_[]
Definition: ConstantsForMonitorable.h:92
sistrip::cablingFromDevices_
static const char cablingFromDevices_[]
Definition: ConstantsForCablingSource.h:22
sistrip::calibPeakRun_
static const char calibPeakRun_[]
Definition: ConstantsForRunType.h:32
sistrip::unknownMonitorable_
static const char unknownMonitorable_[]
Definition: ConstantsForMonitorable.h:19
sistrip::fedChannel_
static const char fedChannel_[]
Definition: ConstantsForGranularity.h:48
sistrip::fedTimingRun_
static const char fedTimingRun_[]
Definition: ConstantsForRunType.h:23
sistrip::noiseSpread_
static const char noiseSpread_[]
Definition: ConstantsForMonitorable.h:85
sistrip::fecKey_
static const char fecKey_[]
Definition: ConstantsForKeyType.h:22
sistrip::unknownFedReadoutMode_
static const char unknownFedReadoutMode_[]
Definition: ConstantsForHardwareSystems.h:102
sistrip::unknownRunType_
static const char unknownRunType_[]
Definition: ConstantsForRunType.h:17
sistrip::fastCablingMax_
static const char fastCablingMax_[]
Definition: ConstantsForMonitorable.h:35
sistrip::fedScopeMode_
static const char fedScopeMode_[]
Definition: ConstantsForHardwareSystems.h:105
sistrip::pedestalsMin_
static const char pedestalsMin_[]
Definition: ConstantsForMonitorable.h:80
sistrip::apv_
static const char apv_[]
Definition: ConstantsForGranularity.h:40
sistrip::fineDelayErr_
static const char fineDelayErr_[]
Definition: ConstantsForMonitorable.h:99
sistrip::optoScanRun_
static const char optoScanRun_[]
Definition: ConstantsForRunType.h:24
sistrip::undefinedFedReadoutMode_
static const char undefinedFedReadoutMode_[]
Definition: ConstantsForHardwareSystems.h:103
sistrip::noiseBin84AllStrips_
static const char noiseBin84AllStrips_[]
Definition: ConstantsForMonitorable.h:93
sistrip::fastCablingLowLevel_
static const char fastCablingLowLevel_[]
Definition: ConstantsForMonitorable.h:32
sistrip::fedCablingRun_
static const char fedCablingRun_[]
Definition: ConstantsForRunType.h:21
sistrip::calibrationRiseTime_
static const char calibrationRiseTime_[]
Definition: ConstantsForMonitorable.h:104
sistrip::apvTimingError_
static const char apvTimingError_[]
Definition: ConstantsForMonitorable.h:43
sistrip::fedTimingPeak_
static const char fedTimingPeak_[]
Definition: ConstantsForMonitorable.h:54
sistrip::fastCablingConnsPerFed_
static const char fastCablingConnsPerFed_[]
Definition: ConstantsForMonitorable.h:37
sistrip::calibrationRiseTimeMin_
static const char calibrationRiseTimeMin_[]
Definition: ConstantsForMonitorable.h:116
sistrip::tib_
static const char tib_[]
Definition: ConstantsForGranularity.h:25
sistrip::calibDeconRun_
static const char calibDeconRun_[]
Definition: ConstantsForRunType.h:33
sistrip::feChan_
static const char feChan_[]
Definition: ConstantsForGranularity.h:46
sistrip::daqScopeModeRun_
static const char daqScopeModeRun_[]
Definition: ConstantsForRunType.h:36
sistrip::fedTimingMax_
static const char fedTimingMax_[]
Definition: ConstantsForMonitorable.h:50
sistrip::fedSystem_
static const char fedSystem_[]
Definition: ConstantsForGranularity.h:43
SiStripEnumsAndStrings::presentation
static std::string presentation(const sistrip::Presentation &)
Definition: SiStripEnumsAndStrings.cc:526
sistrip::apvPeakMode_
static const char apvPeakMode_[]
Definition: ConstantsForHardwareSystems.h:98
sistrip::fecRing_
static const char fecRing_[]
Definition: ConstantsForGranularity.h:54
sistrip::calibrationChi2_
static const char calibrationChi2_[]
Definition: ConstantsForMonitorable.h:107
SiStripEnumsAndStrings::keyType
static std::string keyType(const sistrip::KeyType &)
Definition: SiStripEnumsAndStrings.cc:128
sistrip::invalid_
static const uint16_t invalid_
Definition: Constants.h:16
sistrip::calibrationSmearingMin_
static const char calibrationSmearingMin_[]
Definition: ConstantsForMonitorable.h:118
sistrip::apvTimingBase_
static const char apvTimingBase_[]
Definition: ConstantsForMonitorable.h:44
sistrip::fedTimingBase_
static const char fedTimingBase_[]
Definition: ConstantsForMonitorable.h:53
sistrip::optoScanLaserThresh_
static const char optoScanLaserThresh_[]
Definition: ConstantsForMonitorable.h:64
sistrip::vpspScanAdcLevel_
static const char vpspScanAdcLevel_[]
Definition: ConstantsForMonitorable.h:71
sistrip::cablingFromConns_
static const char cablingFromConns_[]
Definition: ConstantsForCablingSource.h:21
sistrip::cablingFromDetIds_
static const char cablingFromDetIds_[]
Definition: ConstantsForCablingSource.h:23
sistrip::detKey_
static const char detKey_[]
Definition: ConstantsForKeyType.h:23
sistrip::apvTimingTime_
static const char apvTimingTime_[]
Definition: ConstantsForMonitorable.h:40
sistrip::fedTimingDelay_
static const char fedTimingDelay_[]
Definition: ConstantsForMonitorable.h:51
sistrip::undefinedApvReadoutMode_
static const char undefinedApvReadoutMode_[]
Definition: ConstantsForHardwareSystems.h:96
sistrip::histo1d_
static const char histo1d_[]
Definition: ConstantsForPresentation.h:21
SiStripEnumsAndStrings::cablingSource
static std::string cablingSource(const sistrip::CablingSource &)
Definition: SiStripEnumsAndStrings.cc:549
sistrip::daqScopeModeMeanSignal_
static const char daqScopeModeMeanSignal_[]
Definition: ConstantsForMonitorable.h:128
LaserDQM_cfi.mon
tuple mon
Definition: LaserDQM_cfi.py:3
sistrip::calibrationSmearingMax_
static const char calibrationSmearingMax_[]
Definition: ConstantsForMonitorable.h:124
sistrip::calibrationTail_
static const char calibrationTail_[]
Definition: ConstantsForMonitorable.h:103
sistrip::noiseAllStrips_
static const char noiseAllStrips_[]
Definition: ConstantsForMonitorable.h:83
sistrip::noiseChi2AllStrips_
static const char noiseChi2AllStrips_[]
Definition: ConstantsForMonitorable.h:91
sistrip::fedTimingTime_
static const char fedTimingTime_[]
Definition: ConstantsForMonitorable.h:49
sistrip::feUnit_
static const char feUnit_[]
Definition: ConstantsForGranularity.h:45
sistrip::calibrationChi2Min_
static const char calibrationChi2Min_[]
Definition: ConstantsForMonitorable.h:119
sistrip::calibrationChi2Max_
static const char calibrationChi2Max_[]
Definition: ConstantsForMonitorable.h:125
sistrip::pedestalsMax_
static const char pedestalsMax_[]
Definition: ConstantsForMonitorable.h:79
sistrip::fastCablingHighLevel_
static const char fastCablingHighLevel_[]
Definition: ConstantsForMonitorable.h:30
sistrip::fecSystem_
static const char fecSystem_[]
Definition: ConstantsForGranularity.h:51
sistrip::vpspScanApv1_
static const char vpspScanApv1_[]
Definition: ConstantsForMonitorable.h:70
dir
dbl *** dir
Definition: mlp_gen.cc:35
sistrip::noiseRMSAllStrips_
static const char noiseRMSAllStrips_[]
Definition: ConstantsForMonitorable.h:94
sistrip::calibrationRiseTimeAS_
static const char calibrationRiseTimeAS_[]
Definition: ConstantsForMonitorable.h:110
sistrip::calibrationChi2AS_
static const char calibrationChi2AS_[]
Definition: ConstantsForMonitorable.h:113
sistrip::apvTimingPeak_
static const char apvTimingPeak_[]
Definition: ConstantsForMonitorable.h:45
sistrip::vpspScanApv0_
static const char vpspScanApv0_[]
Definition: ConstantsForMonitorable.h:69
sistrip::readoutView_
static const char readoutView_[]
Definition: ConstantsForView.h:20
source
static std::string const source
Definition: EdmProvDump.cc:42
sistrip::disk_
static const char disk_[]
Definition: ConstantsForGranularity.h:33
sistrip::apvLatencyRun_
static const char apvLatencyRun_[]
Definition: ConstantsForRunType.h:30
sistrip::pedestalsSpread_
static const char pedestalsSpread_[]
Definition: ConstantsForMonitorable.h:78
sistrip::undefinedHistoType_
static const char undefinedHistoType_[]
Definition: ConstantsForHistoType.h:19
sistrip::vpspScanBothApvs_
static const char vpspScanBothApvs_[]
Definition: ConstantsForMonitorable.h:68
sistrip::unknownApvReadoutMode_
static const char unknownApvReadoutMode_[]
Definition: ConstantsForHardwareSystems.h:95
sistrip::fedZeroSuppr_
static const char fedZeroSuppr_[]
Definition: ConstantsForHardwareSystems.h:108
sistrip::apvMultiMode_
static const char apvMultiMode_[]
Definition: ConstantsForHardwareSystems.h:100
sistrip::fastCablingHighRms_
static const char fastCablingHighRms_[]
Definition: ConstantsForMonitorable.h:31
sistrip::noiseSignif_
static const char noiseSignif_[]
Definition: ConstantsForMonitorable.h:95
SiStripEnumsAndStrings::fedReadoutMode
static std::string fedReadoutMode(const sistrip::FedReadoutMode &)
Definition: SiStripEnumsAndStrings.cc:249
sistrip::petal_
static const char petal_[]
Definition: ConstantsForGranularity.h:34
sistrip::pedestalsAllStrips_
static const char pedestalsAllStrips_[]
Definition: ConstantsForMonitorable.h:76
Generated for CMSSW Reference Manual by doxygen 1.8.5