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