CMS 3D CMS Logo
EcalPedestals_PayloadInspector.cc
Go to the documentation of this file.
1 #include "CondCore/Utilities/interface/PayloadInspectorModule.h"
2 #include "CondCore/Utilities/interface/PayloadInspector.h"
3 #include "CondCore/CondDB/interface/Time.h"
4 
5 // the data format of the condition to be inspected
6 #include "CondFormats/EcalObjects/interface/EcalPedestals.h"
7 #include "DataFormats/EcalDetId/interface/EBDetId.h"
8 #include "DataFormats/EcalDetId/interface/EEDetId.h"
9 
10 #include <memory>
11 #include <sstream>
12 
13 
14 
15 namespace {
16 
17 
18 
19  /************************************************
20 
21  1d histogram of ECAL barrel pedestal of 1 IOV
22 
23  *************************************************/
24 
25 
26  // inherit from one of the predefined plot class: Histogram1D
27  class EcalPedestalsEBMean12 : public cond::payloadInspector::Histogram1D<EcalPedestals> {
28 
29  public:
30  EcalPedestalsEBMean12() : cond::payloadInspector::Histogram1D<EcalPedestals>( "ECAL Barrel pedestal average gain12",
31  "ECAL Barrel pedestal average gain12", 200, 150, 250){
32  Base::setSingleIov( true );
33  }
34 
35  bool fill( const std::vector<std::tuple<cond::Time_t,cond::Hash> >& iovs ){
36  for ( auto const & iov: iovs) {
37  std::shared_ptr<EcalPedestals> payload = Base::fetchPayload( std::get<1>(iov) );
38  if( payload.get() ){
39 
40  if (!payload->barrelItems().size()) return false;
41 
42  // looping over the EB channels, via the dense-index, mapped into EBDetId's
43  for(int cellid = EBDetId::MIN_HASH;
44  cellid < EBDetId::kSizeForDenseIndexing;
45  ++cellid) {
46  uint32_t rawid = EBDetId::unhashIndex(cellid);
47 
48  // check the existence of ECAL pedestal, for a given ECAL barrel channel
49  if (payload->find(rawid) == payload->end()) continue;
50  if (!(*payload)[rawid].mean_x12 && !(*payload)[rawid].rms_x12) continue;
51 
52  // to be used to fill the histogram
53  fillWithValue( (*payload)[rawid].mean_x12 );
54 
55  }// loop over EB cells
56  }// payload
57  }// iovs
58 
59  return true;
60  }// fill
61  };
62 
63  class EcalPedestalsEBMean6 : public cond::payloadInspector::Histogram1D<EcalPedestals> {
64 
65  public:
66  EcalPedestalsEBMean6() : cond::payloadInspector::Histogram1D<EcalPedestals>( "ECAL Barrel pedestal average gain6",
67  "ECAL Barrel pedestal average gain6", 200, 150, 250){
68  Base::setSingleIov( true );
69  }
70 
71  bool fill( const std::vector<std::tuple<cond::Time_t,cond::Hash> >& iovs ){
72 
73  for( auto const & iov : iovs ) {
74 
75  std::shared_ptr<EcalPedestals> payload = Base::fetchPayload( std::get<1>(iov) );
76  if( payload.get() ){
77 
78  if (!payload->barrelItems().size()) return false;
79 
80  // looping over the EB channels, via the dense-index, mapped into EBDetId's
81  for(int cellid = EBDetId::MIN_HASH;
82  cellid < EBDetId::kSizeForDenseIndexing;
83  ++cellid) {
84  uint32_t rawid = EBDetId::unhashIndex(cellid);
85 
86  // check the existence of ECAL pedestal, for a given ECAL barrel channel
87  if (payload->find(rawid) == payload->end()) continue;
88  if (!(*payload)[rawid].mean_x6 && !(*payload)[rawid].rms_x6) continue;
89 
90  // to be used to fill the histogram
91  fillWithValue( (*payload)[rawid].mean_x6);
92 
93  }// loop over EB cells
94  }// payload
95  }// iovs
96 
97  return true;
98  }// fill
99  };
100 
101  class EcalPedestalsEBMean1 : public cond::payloadInspector::Histogram1D<EcalPedestals> {
102 
103  public:
104  EcalPedestalsEBMean1() : cond::payloadInspector::Histogram1D<EcalPedestals>("ECAL Barrel pedestal average gain1",
105  "ECAL Barrel pedestal average gain1", 200, 150, 250){
106  Base::setSingleIov( true );
107  }
108 
109  bool fill( const std::vector<std::tuple<cond::Time_t,cond::Hash> >& iovs ){
110  for( auto const & iov : iovs ) {
111  std::shared_ptr<EcalPedestals> payload = Base::fetchPayload( std::get<1>(iov) );
112  if( payload.get() ){
113  if (!payload->barrelItems().size()) return false;
114  // looping over the EB channels, via the dense-index, mapped into EBDetId's
115  for(int cellid = EBDetId::MIN_HASH;
116  cellid < EBDetId::kSizeForDenseIndexing;
117  ++cellid) {
118  uint32_t rawid = EBDetId::unhashIndex(cellid);
119 
120  // check the existence of ECAL pedestal, for a given ECAL barrel channel
121  if (payload->find(rawid) == payload->end()) continue;
122  if (!(*payload)[rawid].mean_x1 && !(*payload)[rawid].rms_x1) continue;
123 
124  // to be used to fill the histogram
125  fillWithValue( (*payload)[rawid].mean_x1);
126 
127  }// loop over EB cells
128  }// payload
129  }// iovs
130  return true;
131  }// fill
132  };
133 
134  class EcalPedestalsEEMean12 : public cond::payloadInspector::Histogram1D<EcalPedestals> {
135 
136  public:
137  static const int IX_MIN =1;
138 
141  static const int IY_MIN =1;
142 
145  static const int IX_MAX =100;
146 
149  static const int IY_MAX =100;
150  EcalPedestalsEEMean12() : cond::payloadInspector::Histogram1D<EcalPedestals>( "ECAL Endcap pedestal average gain12",
151  "ECAL Endcap pedestal average gain12", 200, 150, 250){
152  Base::setSingleIov( true );
153  }
154 
155  bool fill( const std::vector<std::tuple<cond::Time_t,cond::Hash> >& iovs ){
156  for( auto const & iov : iovs ) {
157  std::shared_ptr<EcalPedestals> payload = Base::fetchPayload( std::get<1>(iov) );
158  if( payload.get() ){
159 
160  if (!payload->endcapItems().size()) return false;
161 
162  // looping over the EE channels
163  for(int iz = -1; iz < 2; iz = iz + 2) // -1 or +1
164  for(int iy = IY_MIN; iy < IY_MAX+IY_MIN; iy++)
165  for(int ix = IX_MIN; ix < IX_MAX+IX_MIN; ix++)
166  if(EEDetId::validDetId(ix, iy, iz)) {
167  EEDetId myEEId = EEDetId(ix, iy, iz, EEDetId::XYMODE);
168  uint32_t rawid = myEEId.rawId();
169  // check the existence of ECAL pedestal, for a given ECAL endcap channel
170  if (payload->find(rawid) == payload->end()) continue;
171  if (!(*payload)[rawid].mean_x12 && !(*payload)[rawid].rms_x12) continue;
172  fillWithValue( (*payload)[rawid].mean_x12 );
173 
174  } // validDetId
175  } // payload
176  } // loop over iovs
177 
178  return true;
179  }// fill
180  };
181 
182  class EcalPedestalsEEMean6 : public cond::payloadInspector::Histogram1D<EcalPedestals> {
183 
184  public:
185  static const int IX_MIN =1;
186 
189  static const int IY_MIN =1;
190 
193  static const int IX_MAX =100;
194 
197  static const int IY_MAX =100;
198  EcalPedestalsEEMean6() : cond::payloadInspector::Histogram1D<EcalPedestals>( "ECAL Endcap pedestal average gain6",
199  "ECAL Endcap pedestal average gain6", 200, 150, 250){
200  Base::setSingleIov( true );
201  }
202 
203  bool fill( const std::vector<std::tuple<cond::Time_t,cond::Hash> >& iovs ){
204 
205  for( auto const & iov : iovs ) {
206 
207  std::shared_ptr<EcalPedestals> payload = Base::fetchPayload( std::get<1>(iov) );
208  if( payload.get() ){
209 
210  if (!payload->endcapItems().size()) return false;
211 
212  // looping over the EE channels
213  for(int iz = -1; iz < 2; iz = iz + 2) // -1 or +1
214  for(int iy = IY_MIN; iy < IY_MAX+IY_MIN; iy++)
215  for(int ix = IX_MIN; ix < IX_MAX+IX_MIN; ix++)
216  if(EEDetId::validDetId(ix, iy, iz)) {
217  EEDetId myEEId = EEDetId(ix, iy, iz, EEDetId::XYMODE);
218  uint32_t rawid = myEEId.rawId();
219  // check the existence of ECAL pedestal, for a given ECAL endcap channel
220  if (payload->find(rawid) == payload->end()) continue;
221  if (!(*payload)[rawid].mean_x6 && !(*payload)[rawid].rms_x6) continue;
222  fillWithValue( (*payload)[rawid].mean_x6);
223 
224  } // validDetId
225  } // payload
226  } // loop over iovs
227 
228  return true;
229  }// fill
230  };
231 
232  class EcalPedestalsEEMean1 : public cond::payloadInspector::Histogram1D<EcalPedestals> {
233 
234  public:
235  static const int IX_MIN =1;
236 
239  static const int IY_MIN =1;
240 
243  static const int IX_MAX =100;
244 
247  static const int IY_MAX =100;
248  EcalPedestalsEEMean1() : cond::payloadInspector::Histogram1D<EcalPedestals>("ECAL Endcap pedestal average gain1",
249  "ECAL Endcap pedestal average gain1", 200, 150, 250){
250  Base::setSingleIov( true );
251  }
252 
253  bool fill( const std::vector<std::tuple<cond::Time_t,cond::Hash> >& iovs ){
254  for( auto const & iov : iovs ) {
255  std::shared_ptr<EcalPedestals> payload = Base::fetchPayload( std::get<1>(iov) );
256  if( payload.get() ){
257  if (!payload->endcapItems().size()) return false;
258 
259  // looping over the EE channels
260  for(int iz = -1; iz < 2; iz = iz + 2) // -1 or +1
261  for(int iy = IY_MIN; iy < IY_MAX+IY_MIN; iy++)
262  for(int ix = IX_MIN; ix < IX_MAX+IX_MIN; ix++)
263  if(EEDetId::validDetId(ix, iy, iz)) {
264  EEDetId myEEId = EEDetId(ix, iy, iz, EEDetId::XYMODE);
265  uint32_t rawid = myEEId.rawId();
266  // check the existence of ECAL pedestal, for a given ECAL endcap channel
267  if (payload->find(rawid) == payload->end()) continue;
268  if (!(*payload)[rawid].mean_x1 && !(*payload)[rawid].rms_x1) continue;
269  fillWithValue( (*payload)[rawid].mean_x1);
270 
271  } // validDetId
272  } // payload
273  } // loop over iovs
274  return true;
275  }// fill
276  };
277 
278  class EcalPedestalsEBRMS12 : public cond::payloadInspector::Histogram1D<EcalPedestals> {
279 
280  public:
281  EcalPedestalsEBRMS12() : cond::payloadInspector::Histogram1D<EcalPedestals>( "ECAL Barrel noise average gain12",
282  "ECAL Barrel noise average gain12", 100, 0, 6){
283  Base::setSingleIov( true );
284  }
285 
286  bool fill( const std::vector<std::tuple<cond::Time_t,cond::Hash> >& iovs ){
287  for( auto const & iov : iovs ) {
288  std::shared_ptr<EcalPedestals> payload = Base::fetchPayload( std::get<1>(iov) );
289  if( payload.get() ){
290 
291  if (!payload->barrelItems().size()) return false;
292 
293  // looping over the EB channels, via the dense-index, mapped into EBDetId's
294  for(int cellid = EBDetId::MIN_HASH;
295  cellid < EBDetId::kSizeForDenseIndexing;
296  ++cellid) {
297  uint32_t rawid = EBDetId::unhashIndex(cellid);
298 
299  // check the existence of ECAL pedestal, for a given ECAL barrel channel
300  if (payload->find(rawid) == payload->end()) continue;
301  if (!(*payload)[rawid].mean_x12 && !(*payload)[rawid].rms_x12) continue;
302 
303  // to be used to fill the histogram
304  fillWithValue( (*payload)[rawid].rms_x12 );
305 
306  }// loop over EB cells
307  }// payload
308  }// iovs
309 
310  return true;
311  }// fill
312  };
313 
314  class EcalPedestalsEBRMS6 : public cond::payloadInspector::Histogram1D<EcalPedestals> {
315 
316  public:
317  EcalPedestalsEBRMS6() : cond::payloadInspector::Histogram1D<EcalPedestals>( "ECAL Barrel noise average gain6",
318  "ECAL Barrel noise average gain6", 100, 0, 3){
319  Base::setSingleIov( true );
320  }
321 
322  bool fill( const std::vector<std::tuple<cond::Time_t,cond::Hash> >& iovs ){
323 
324  for( auto const & iov : iovs ) {
325 
326  std::shared_ptr<EcalPedestals> payload = Base::fetchPayload( std::get<1>(iov) );
327  if( payload.get() ){
328 
329  if (!payload->barrelItems().size()) return false;
330 
331  // looping over the EB channels, via the dense-index, mapped into EBDetId's
332  for(int cellid = EBDetId::MIN_HASH;
333  cellid < EBDetId::kSizeForDenseIndexing;
334  ++cellid) {
335  uint32_t rawid = EBDetId::unhashIndex(cellid);
336 
337  // check the existence of ECAL pedestal, for a given ECAL barrel channel
338  if (payload->find(rawid) == payload->end()) continue;
339  if (!(*payload)[rawid].mean_x6 && !(*payload)[rawid].rms_x6) continue;
340 
341  // to be used to fill the histogram
342  fillWithValue( (*payload)[rawid].rms_x6);
343 
344  }// loop over EB cells
345  }// payload
346  }// iovs
347 
348  return true;
349  }// fill
350  };
351 
352  class EcalPedestalsEBRMS1 : public cond::payloadInspector::Histogram1D<EcalPedestals> {
353 
354  public:
355  EcalPedestalsEBRMS1() : cond::payloadInspector::Histogram1D<EcalPedestals>("ECAL Barrel noise average gain1",
356  "ECAL Barrel noise average gain1", 100, 0, 2){
357  Base::setSingleIov( true );
358  }
359 
360  bool fill( const std::vector<std::tuple<cond::Time_t,cond::Hash> >& iovs ){
361  for( auto const & iov : iovs ) {
362  std::shared_ptr<EcalPedestals> payload = Base::fetchPayload( std::get<1>(iov) );
363  if( payload.get() ){
364  if (!payload->barrelItems().size()) return false;
365  // looping over the EB channels, via the dense-index, mapped into EBDetId's
366  for(int cellid = EBDetId::MIN_HASH;
367  cellid < EBDetId::kSizeForDenseIndexing;
368  ++cellid) {
369  uint32_t rawid = EBDetId::unhashIndex(cellid);
370 
371  // check the existence of ECAL pedestal, for a given ECAL barrel channel
372  if (payload->find(rawid) == payload->end()) continue;
373  if (!(*payload)[rawid].mean_x1 && !(*payload)[rawid].rms_x1) continue;
374 
375  // to be used to fill the histogram
376  fillWithValue( (*payload)[rawid].rms_x1);
377 
378  }// loop over EB cells
379  }// payload
380  }// iovs
381  return true;
382  }// fill
383  };
384 
385  class EcalPedestalsEERMS12 : public cond::payloadInspector::Histogram1D<EcalPedestals> {
386 
387  public:
388  static const int IX_MIN =1;
389 
392  static const int IY_MIN =1;
393 
396  static const int IX_MAX =100;
397 
400  static const int IY_MAX =100;
401  EcalPedestalsEERMS12() : cond::payloadInspector::Histogram1D<EcalPedestals>( "ECAL Endcap noise average gain12",
402  "ECAL Endcap noise average gain12", 100, 0, 8){
403  Base::setSingleIov( true );
404  }
405 
406  bool fill( const std::vector<std::tuple<cond::Time_t,cond::Hash> >& iovs ){
407  for( auto const & iov : iovs ) {
408  std::shared_ptr<EcalPedestals> payload = Base::fetchPayload( std::get<1>(iov) );
409  if( payload.get() ){
410 
411  if (!payload->endcapItems().size()) return false;
412 
413  // looping over the EE channels
414  for(int iz = -1; iz < 2; iz = iz + 2) // -1 or +1
415  for(int iy = IY_MIN; iy < IY_MAX+IY_MIN; iy++)
416  for(int ix = IX_MIN; ix < IX_MAX+IX_MIN; ix++)
417  if(EEDetId::validDetId(ix, iy, iz)) {
418  EEDetId myEEId = EEDetId(ix, iy, iz, EEDetId::XYMODE);
419  uint32_t rawid = myEEId.rawId();
420  // check the existence of ECAL pedestal, for a given ECAL endcap channel
421  if (payload->find(rawid) == payload->end()) continue;
422  if (!(*payload)[rawid].mean_x12 && !(*payload)[rawid].rms_x12) continue;
423  fillWithValue( (*payload)[rawid].rms_x12 );
424 
425  } // validDetId
426  } // payload
427  } // loop over iovs
428 
429  return true;
430  }// fill
431  };
432 
433  class EcalPedestalsEERMS6 : public cond::payloadInspector::Histogram1D<EcalPedestals> {
434 
435  public:
436  static const int IX_MIN =1;
437 
440  static const int IY_MIN =1;
441 
444  static const int IX_MAX =100;
445 
448  static const int IY_MAX =100;
449  EcalPedestalsEERMS6() : cond::payloadInspector::Histogram1D<EcalPedestals>( "ECAL Endcap noise average gain6",
450  "ECAL Endcap noise average gain6", 100, 0, 4){
451  Base::setSingleIov( true );
452  }
453 
454  bool fill( const std::vector<std::tuple<cond::Time_t,cond::Hash> >& iovs ){
455 
456  for( auto const & iov : iovs ) {
457 
458  std::shared_ptr<EcalPedestals> payload = Base::fetchPayload( std::get<1>(iov) );
459  if( payload.get() ){
460 
461  if (!payload->endcapItems().size()) return false;
462 
463  // looping over the EE channels
464  for(int iz = -1; iz < 2; iz = iz + 2) // -1 or +1
465  for(int iy = IY_MIN; iy < IY_MAX+IY_MIN; iy++)
466  for(int ix = IX_MIN; ix < IX_MAX+IX_MIN; ix++)
467  if(EEDetId::validDetId(ix, iy, iz)) {
468  EEDetId myEEId = EEDetId(ix, iy, iz, EEDetId::XYMODE);
469  uint32_t rawid = myEEId.rawId();
470  // check the existence of ECAL pedestal, for a given ECAL endcap channel
471  if (payload->find(rawid) == payload->end()) continue;
472  if (!(*payload)[rawid].mean_x6 && !(*payload)[rawid].rms_x6) continue;
473  fillWithValue( (*payload)[rawid].rms_x6);
474 
475  } // validDetId
476  } // payload
477  } // loop over iovs
478 
479  return true;
480  }// fill
481  };
482 
483  class EcalPedestalsEERMS1 : public cond::payloadInspector::Histogram1D<EcalPedestals> {
484 
485  public:
486  static const int IX_MIN =1;
487 
490  static const int IY_MIN =1;
491 
494  static const int IX_MAX =100;
495 
498  static const int IY_MAX =100;
499  EcalPedestalsEERMS1() : cond::payloadInspector::Histogram1D<EcalPedestals>("ECAL Endcap noise average gain1",
500  "ECAL Endcap noise average gain1", 100, 0, 3){
501  Base::setSingleIov( true );
502  }
503 
504  bool fill( const std::vector<std::tuple<cond::Time_t,cond::Hash> >& iovs ){
505  for( auto const & iov : iovs ) {
506  std::shared_ptr<EcalPedestals> payload = Base::fetchPayload( std::get<1>(iov) );
507  if( payload.get() ){
508  if (!payload->endcapItems().size()) return false;
509 
510  // looping over the EE channels
511  for(int iz = -1; iz < 2; iz = iz + 2) // -1 or +1
512  for(int iy = IY_MIN; iy < IY_MAX+IY_MIN; iy++)
513  for(int ix = IX_MIN; ix < IX_MAX+IX_MIN; ix++)
514  if(EEDetId::validDetId(ix, iy, iz)) {
515  EEDetId myEEId = EEDetId(ix, iy, iz, EEDetId::XYMODE);
516  uint32_t rawid = myEEId.rawId();
517  // check the existence of ECAL pedestal, for a given ECAL endcap channel
518  if (payload->find(rawid) == payload->end()) continue;
519  if (!(*payload)[rawid].mean_x1 && !(*payload)[rawid].rms_x1) continue;
520  fillWithValue( (*payload)[rawid].rms_x1);
521 
522  } // validDetId
523  } // payload
524  } // loop over iovs
525  return true;
526  }// fill
527  };
528 
529  /*************************************************
530 
531  2d histogram of ECAL barrel pedestal of 1 IOV
532 
533  *************************************************/
534 
535 
536  // inherit from one of the predefined plot class: Histogram2D
537  class EcalPedestalsEBMean12Map : public cond::payloadInspector::Histogram2D<EcalPedestals> {
538 
539  public:
540  static const int MIN_IETA = 1;
541  static const int MIN_IPHI = 1;
542  static const int MAX_IETA = 85;
543  static const int MAX_IPHI = 360;
544 
545  EcalPedestalsEBMean12Map() : cond::payloadInspector::Histogram2D<EcalPedestals>( "ECAL Barrel pedestal gain12 - map",
546  "iphi", MAX_IPHI, MIN_IPHI, MAX_IPHI+MIN_IPHI, "ieta", 2*MAX_IETA+1, -1*MAX_IETA, MAX_IETA+1) {
547  Base::setSingleIov( true );
548  }
549 
550  // Histogram2D::fill (virtual) needs be overridden - the implementation should use fillWithValue
551  bool fill( const std::vector<std::tuple<cond::Time_t,cond::Hash> >& iovs ){
552 
553  for( auto const & iov : iovs ) {
554  std::shared_ptr<EcalPedestals> payload = Base::fetchPayload( std::get<1>(iov) );
555  if( payload.get() ){
556  // looping over the EB channels, via the dense-index, mapped into EBDetId's
557  if (!payload->barrelItems().size()) return false;
558  for(int cellid = EBDetId::MIN_HASH;
559  cellid < EBDetId::kSizeForDenseIndexing;
560  ++cellid) {
561  uint32_t rawid = EBDetId::unhashIndex(cellid);
562 
563  // check the existence of ECAL pedestal, for a given ECAL barrel channel
564  if (payload->find(rawid) == payload->end()) continue;
565  if (!(*payload)[rawid].mean_x12 && !(*payload)[rawid].rms_x12) continue;
566 
567  // there's no ieta==0 in the EB numbering
568  // int delta = (EBDetId(rawid)).ieta() > 0 ? -1 : 0 ;
569  // fill the Histogram2D here
570  // fillWithValue( (EBDetId(rawid)).iphi() , (EBDetId(rawid)).ieta()+0.5+delta, (*payload)[rawid].mean_x12 );
571  // set min and max on 2d plots
572  float valped = (*payload)[rawid].mean_x12;
573  if(valped > 250.) valped = 250.;
574  // if(valped < 150.) valped = 150.;
575  fillWithValue( (EBDetId(rawid)).iphi(), (EBDetId(rawid)).ieta(), valped);
576  }// loop over cellid
577  }// if payload.get()
578  }// loop over IOV's (1 in this case)
579  return true;
580  }// fill method
581  };
582 
583  class EcalPedestalsEBMean6Map : public cond::payloadInspector::Histogram2D<EcalPedestals> {
584 
585  public:
586  static const int MIN_IETA = 1;
587  static const int MIN_IPHI = 1;
588  static const int MAX_IETA = 85;
589  static const int MAX_IPHI = 360;
590  EcalPedestalsEBMean6Map() : cond::payloadInspector::Histogram2D<EcalPedestals>( "ECAL Barrel pedestal gain6 - map",
591  "iphi", MAX_IPHI, MIN_IPHI, MAX_IPHI+MIN_IPHI, "ieta", 2*MAX_IETA+1, -1*MAX_IETA, MAX_IETA+1){
592  Base::setSingleIov( true );
593  }
594 
595  bool fill( const std::vector<std::tuple<cond::Time_t,cond::Hash> >& iovs ){
596  for( auto const & iov : iovs ) {
597  std::shared_ptr<EcalPedestals> payload = Base::fetchPayload( std::get<1>(iov) );
598  if( payload.get() ){
599  // looping over the EB channels, via the dense-index, mapped into EBDetId's
600  if (!payload->barrelItems().size()) return false;
601  for(int cellid = EBDetId::MIN_HASH;
602  cellid < EBDetId::kSizeForDenseIndexing;
603  ++cellid) {
604  uint32_t rawid = EBDetId::unhashIndex(cellid);
605 
606  // check the existence of ECAL pedestal, for a given ECAL barrel channel
607  if (payload->find(rawid) == payload->end()) continue;
608  if (!(*payload)[rawid].mean_x6 && !(*payload)[rawid].rms_x6) continue;
609 
610  // set min and max on 2d plots
611  float valped = (*payload)[rawid].mean_x6;
612  if(valped > 250.) valped = 250.;
613  // if(valped < 150.) valped = 150.;
614  fillWithValue( (EBDetId(rawid)).iphi(), (EBDetId(rawid)).ieta(), valped);
615  } // loop over cellid
616  } // if payload.get()
617  } // loop over IOV's (1 in this case)
618  return true;
619  } // fill method
620  };
621 
622  class EcalPedestalsEBMean1Map : public cond::payloadInspector::Histogram2D<EcalPedestals> {
623 
624  public:
625  static const int MIN_IETA = 1;
626  static const int MIN_IPHI = 1;
627  static const int MAX_IETA = 85;
628  static const int MAX_IPHI = 360;
629  EcalPedestalsEBMean1Map() : cond::payloadInspector::Histogram2D<EcalPedestals>( "ECAL Barrel pedestal gain1 - map",
630  "iphi", MAX_IPHI, MIN_IPHI, MAX_IPHI+MIN_IPHI, "ieta", 2*MAX_IETA+1, -1*MAX_IETA, MAX_IETA+1) {
631  Base::setSingleIov( true );
632  }
633 
634  bool fill( const std::vector<std::tuple<cond::Time_t,cond::Hash> >& iovs ){
635  for( auto const & iov : iovs ) {
636  std::shared_ptr<EcalPedestals> payload = Base::fetchPayload( std::get<1>(iov) );
637  if( payload.get() ){
638  // looping over the EB channels, via the dense-index, mapped into EBDetId's
639  if (!payload->barrelItems().size()) return false;
640  for(int cellid = EBDetId::MIN_HASH;
641  cellid < EBDetId::kSizeForDenseIndexing;
642  ++cellid) {
643  uint32_t rawid = EBDetId::unhashIndex(cellid);
644 
645  // check the existence of ECAL pedestal, for a given ECAL barrel channel
646  if (payload->find(rawid) == payload->end()) continue;
647  if (!(*payload)[rawid].mean_x1 && !(*payload)[rawid].rms_x1) continue;
648 
649  // set min and max on 2d plots
650  float valped = (*payload)[rawid].mean_x1;
651  if(valped > 250.) valped = 250.;
652  // if(valped < 150.) valped = 150.;
653  fillWithValue( (EBDetId(rawid)).iphi(), (EBDetId(rawid)).ieta(), valped);
654  } // loop over cellid
655  } // if payload.get()
656  } // loop over IOV's (1 in this case)
657  return true;
658  } // fill method
659  };
660 
661  class EcalPedestalsEEMean12Map : public cond::payloadInspector::Histogram2D<EcalPedestals> {
662 
663  public:
664  static const int IX_MIN =1;
665 
668  static const int IY_MIN =1;
669 
672  static const int IX_MAX =100;
673 
676  static const int IY_MAX =100;
677  EcalPedestalsEEMean12Map() : cond::payloadInspector::Histogram2D<EcalPedestals>( "ECAL Endcap pedestal gain12 - map",
678  "ix", 2.2*IX_MAX, IX_MIN, 2.2*IX_MAX+1, "iy", IY_MAX, IY_MIN, IY_MAX+IY_MIN) {
679  Base::setSingleIov( true );
680  }
681 
682  // Histogram2D::fill (virtual) needs be overridden - the implementation should use fillWithValue
683  bool fill( const std::vector<std::tuple<cond::Time_t,cond::Hash> >& iovs ){
684 
685  for( auto const & iov : iovs ) {
686  std::shared_ptr<EcalPedestals> payload = Base::fetchPayload( std::get<1>(iov) );
687  if( payload.get() ){
688  if (!payload->endcapItems().size()) return false;
689 
690  // looping over the EE channels
691  for(int iz = -1; iz < 2; iz = iz + 2) // -1 or +1
692  for(int iy = IY_MIN; iy < IY_MAX+IY_MIN; iy++)
693  for(int ix = IX_MIN; ix < IX_MAX+IX_MIN; ix++)
694  if(EEDetId::validDetId(ix, iy, iz)) {
695  EEDetId myEEId = EEDetId(ix, iy, iz, EEDetId::XYMODE);
696  uint32_t rawid = myEEId.rawId();
697  // check the existence of ECAL pedestal, for a given ECAL endcap channel
698  if (payload->find(rawid) == payload->end()) continue;
699  if (!(*payload)[rawid].mean_x12 && !(*payload)[rawid].rms_x12) continue;
700  // set min and max on 2d plots
701  float valped = (*payload)[rawid].mean_x12;
702  if(valped > 250.) valped = 250.;
703  // if(valped < 150.) valped = 150.;
704  if(iz == -1)
705  fillWithValue(ix, iy, valped);
706  else
707  fillWithValue(ix + IX_MAX + 20, iy, valped);
708 
709  } // validDetId
710  } // payload
711  }// loop over IOV's (1 in this case)
712  return true;
713  }// fill method
714  };
715 
716  class EcalPedestalsEEMean6Map : public cond::payloadInspector::Histogram2D<EcalPedestals> {
717 
718  public:
719  static const int IX_MIN =1;
720 
723  static const int IY_MIN =1;
724 
727  static const int IX_MAX =100;
728 
731  static const int IY_MAX =100;
732  EcalPedestalsEEMean6Map() : cond::payloadInspector::Histogram2D<EcalPedestals>( "ECAL Endcap pedestal gain6 - map",
733 "ix", 2.2*IX_MAX, IX_MIN, 2.2*IX_MAX+1, "iy", IY_MAX, IY_MIN, IY_MAX+IY_MIN) {
734  Base::setSingleIov( true );
735  }
736 
737  bool fill( const std::vector<std::tuple<cond::Time_t,cond::Hash> >& iovs ){
738  for( auto const & iov : iovs ) {
739  std::shared_ptr<EcalPedestals> payload = Base::fetchPayload( std::get<1>(iov) );
740  if( payload.get() ){
741  if (!payload->endcapItems().size()) return false;
742 
743  // looping over the EE channels
744  for(int iz = -1; iz < 2; iz = iz + 2) // -1 or +1
745  for(int iy = IY_MIN; iy < IY_MAX+IY_MIN; iy++)
746  for(int ix = IX_MIN; ix < IX_MAX+IX_MIN; ix++)
747  if(EEDetId::validDetId(ix, iy, iz)) {
748  EEDetId myEEId = EEDetId(ix, iy, iz, EEDetId::XYMODE);
749  uint32_t rawid = myEEId.rawId();
750  // check the existence of ECAL pedestal, for a given ECAL endcap channel
751  if (payload->find(rawid) == payload->end()) continue;
752  if (!(*payload)[rawid].mean_x6 && !(*payload)[rawid].rms_x6) continue;
753  // set min and max on 2d plots
754  float valped = (*payload)[rawid].mean_x6;
755  if(valped > 250.) valped = 250.;
756  // if(valped < 150.) valped = 150.;
757  if(iz == -1)
758  fillWithValue(ix, iy, valped);
759  else
760  fillWithValue(ix + IX_MAX + 20, iy, valped);
761  } // validDetId
762  } // payload
763  } // loop over IOV's (1 in this case)
764  return true;
765  } // fill method
766  };
767 
768  class EcalPedestalsEEMean1Map : public cond::payloadInspector::Histogram2D<EcalPedestals> {
769 
770  public:
771  static const int IX_MIN =1;
772 
775  static const int IY_MIN =1;
776 
779  static const int IX_MAX =100;
780 
783  static const int IY_MAX =100;
784  EcalPedestalsEEMean1Map() : cond::payloadInspector::Histogram2D<EcalPedestals>( "ECAL Endcap pedestal gain1 - map",
785 "ix", 2.2*IX_MAX, IX_MIN, 2.2*IX_MAX+1, "iy", IY_MAX, IY_MIN, IY_MAX+IY_MIN) { Base::setSingleIov( true );
786  }
787 
788  bool fill( const std::vector<std::tuple<cond::Time_t,cond::Hash> >& iovs ){
789  for( auto const & iov : iovs ) {
790  std::shared_ptr<EcalPedestals> payload = Base::fetchPayload( std::get<1>(iov) );
791  if( payload.get() ){
792  if (!payload->endcapItems().size()) return false;
793 
794  // looping over the EE channels
795  for(int iz = -1; iz < 2; iz = iz + 2) // -1 or +1
796  for(int iy = IY_MIN; iy < IY_MAX+IY_MIN; iy++)
797  for(int ix = IX_MIN; ix < IX_MAX+IX_MIN; ix++)
798  if(EEDetId::validDetId(ix, iy, iz)) {
799  EEDetId myEEId = EEDetId(ix, iy, iz, EEDetId::XYMODE);
800  uint32_t rawid = myEEId.rawId();
801  // check the existence of ECAL pedestal, for a given ECAL endcap channel
802  if (payload->find(rawid) == payload->end()) continue;
803  if (!(*payload)[rawid].mean_x1 && !(*payload)[rawid].rms_x12) continue;
804  // set min and max on 2d plots
805  float valped = (*payload)[rawid].mean_x1;
806  if(valped > 250.) valped = 250.;
807  // if(valped < 150.) valped = 150.;
808  if(iz == -1)
809  fillWithValue(ix, iy, valped);
810  else
811  fillWithValue(ix + IX_MAX + 20, iy, valped);
812  } // validDetId
813  } // if payload.get()
814  } // loop over IOV's (1 in this case)
815  return true;
816  } // fill method
817  };
818 
819  // inherit from one of the predefined plot class: Histogram2D
820  class EcalPedestalsEBRMS12Map : public cond::payloadInspector::Histogram2D<EcalPedestals> {
821 
822  public:
823  static const int MIN_IETA = 1;
824  static const int MIN_IPHI = 1;
825  static const int MAX_IETA = 85;
826  static const int MAX_IPHI = 360;
827  EcalPedestalsEBRMS12Map() : cond::payloadInspector::Histogram2D<EcalPedestals>( "ECAL Barrel noise gain12 - map",
828  "iphi", MAX_IPHI, MIN_IPHI, MAX_IPHI+MIN_IPHI, "ieta", 2*MAX_IETA+1, -1*MAX_IETA, MAX_IETA+1) { Base::setSingleIov( true );
829  }
830 
831  // Histogram2D::fill (virtual) needs be overridden - the implementation should use fillWithValue
832  bool fill( const std::vector<std::tuple<cond::Time_t,cond::Hash> >& iovs ){
833 
834  for( auto const & iov : iovs ) {
835  std::shared_ptr<EcalPedestals> payload = Base::fetchPayload( std::get<1>(iov) );
836  if( payload.get() ){
837  // looping over the EB channels, via the dense-index, mapped into EBDetId's
838  if (!payload->barrelItems().size()) return false;
839  for(int cellid = EBDetId::MIN_HASH;
840  cellid < EBDetId::kSizeForDenseIndexing;
841  ++cellid) {
842  uint32_t rawid = EBDetId::unhashIndex(cellid);
843 
844  // check the existence of ECAL pedestal, for a given ECAL barrel channel
845  if (payload->find(rawid) == payload->end()) continue;
846  if (!(*payload)[rawid].mean_x12 && !(*payload)[rawid].rms_x12) continue;
847 
848  // there's no ieta==0 in the EB numbering
849  // int delta = (EBDetId(rawid)).ieta() > 0 ? -1 : 0 ;
850  // fill the Histogram2D here
851  // fillWithValue( (EBDetId(rawid)).iphi() , (EBDetId(rawid)).ieta()+0.5+delta, (*payload)[rawid].mean_x12 );
852  // set max on noise 2d plots
853  float valrms = (*payload)[rawid].rms_x12;
854  if(valrms > 2.2) valrms = 2.2;
855  fillWithValue( (EBDetId(rawid)).iphi(), (EBDetId(rawid)).ieta(), valrms);
856  }// loop over cellid
857  }// if payload.get()
858  }// loop over IOV's (1 in this case)
859  return true;
860  }// fill method
861  };
862 
863  class EcalPedestalsEBRMS6Map : public cond::payloadInspector::Histogram2D<EcalPedestals> {
864 
865  public:
866  static const int MIN_IETA = 1;
867  static const int MIN_IPHI = 1;
868  static const int MAX_IETA = 85;
869  static const int MAX_IPHI = 360;
870  EcalPedestalsEBRMS6Map() : cond::payloadInspector::Histogram2D<EcalPedestals>( "ECAL Barrel noise gain6 - map",
871  "iphi", MAX_IPHI, MIN_IPHI, MAX_IPHI+MIN_IPHI, "ieta", 2*MAX_IETA+1, -1*MAX_IETA, MAX_IETA+1) { Base::setSingleIov( true );
872  }
873 
874  bool fill( const std::vector<std::tuple<cond::Time_t,cond::Hash> >& iovs ){
875  for( auto const & iov : iovs ) {
876  std::shared_ptr<EcalPedestals> payload = Base::fetchPayload( std::get<1>(iov) );
877  if( payload.get() ){
878  // looping over the EB channels, via the dense-index, mapped into EBDetId's
879  if (!payload->barrelItems().size()) return false;
880  for(int cellid = EBDetId::MIN_HASH;
881  cellid < EBDetId::kSizeForDenseIndexing;
882  ++cellid) {
883  uint32_t rawid = EBDetId::unhashIndex(cellid);
884 
885  // check the existence of ECAL pedestal, for a given ECAL barrel channel
886  if (payload->find(rawid) == payload->end()) continue;
887  if (!(*payload)[rawid].mean_x6 && !(*payload)[rawid].rms_x6) continue;
888 
889  // set max on noise 2d plots
890  float valrms = (*payload)[rawid].rms_x6;
891  if(valrms > 1.5) valrms = 1.5;
892  fillWithValue( (EBDetId(rawid)).iphi(), (EBDetId(rawid)).ieta(), valrms);
893  } // loop over cellid
894  } // if payload.get()
895  } // loop over IOV's (1 in this case)
896  return true;
897  } // fill method
898  };
899 
900  class EcalPedestalsEBRMS1Map : public cond::payloadInspector::Histogram2D<EcalPedestals> {
901 
902  public:
903  static const int MIN_IETA = 1;
904  static const int MIN_IPHI = 1;
905  static const int MAX_IETA = 85;
906  static const int MAX_IPHI = 360;
907  EcalPedestalsEBRMS1Map() : cond::payloadInspector::Histogram2D<EcalPedestals>( "ECAL Barrel noise gain1 - map",
908  "iphi", MAX_IPHI, MIN_IPHI, MAX_IPHI+MIN_IPHI, "ieta", 2*MAX_IETA+1, -1*MAX_IETA, MAX_IETA+1) { Base::setSingleIov( true );
909  }
910 
911  bool fill( const std::vector<std::tuple<cond::Time_t,cond::Hash> >& iovs ){
912  for( auto const & iov : iovs ) {
913  std::shared_ptr<EcalPedestals> payload = Base::fetchPayload( std::get<1>(iov) );
914  if( payload.get() ){
915  // looping over the EB channels, via the dense-index, mapped into EBDetId's
916  if (!payload->barrelItems().size()) return false;
917  for(int cellid = EBDetId::MIN_HASH;
918  cellid < EBDetId::kSizeForDenseIndexing;
919  ++cellid) {
920  uint32_t rawid = EBDetId::unhashIndex(cellid);
921 
922  // check the existence of ECAL pedestal, for a given ECAL barrel channel
923  if (payload->find(rawid) == payload->end()) continue;
924  if (!(*payload)[rawid].mean_x1 && !(*payload)[rawid].rms_x1) continue;
925 
926  // set max on noise 2d plots
927  float valrms = (*payload)[rawid].rms_x1;
928  if(valrms > 1.0) valrms = 1.0;
929  fillWithValue( (EBDetId(rawid)).iphi(), (EBDetId(rawid)).ieta(), valrms);
930  } // loop over cellid
931  } // if payload.get()
932  } // loop over IOV's (1 in this case)
933  return true;
934  } // fill method
935  };
936  class EcalPedestalsEERMS12Map : public cond::payloadInspector::Histogram2D<EcalPedestals> {
937 
938  public:
939  static const int IX_MIN =1;
940 
943  static const int IY_MIN =1;
944 
947  static const int IX_MAX =100;
948 
951  static const int IY_MAX =100;
952  EcalPedestalsEERMS12Map() : cond::payloadInspector::Histogram2D<EcalPedestals>( "ECAL Endcap noise gain12 - map",
953 "ix", 2.2*IX_MAX, IX_MIN, 2.2*IX_MAX+1, "iy", IY_MAX, IY_MIN, IY_MAX+IY_MIN) {
954  Base::setSingleIov( true );
955  }
956 
957  // Histogram2D::fill (virtual) needs be overridden - the implementation should use fillWithValue
958  bool fill( const std::vector<std::tuple<cond::Time_t,cond::Hash> >& iovs ){
959 
960  for( auto const & iov : iovs ) {
961  std::shared_ptr<EcalPedestals> payload = Base::fetchPayload( std::get<1>(iov) );
962  if( payload.get() ){
963  if (!payload->endcapItems().size()) return false;
964 
965  // looping over the EE channels
966  for(int iz = -1; iz < 2; iz = iz + 2) // -1 or +1
967  for(int iy = IY_MIN; iy < IY_MAX+IY_MIN; iy++)
968  for(int ix = IX_MIN; ix < IX_MAX+IX_MIN; ix++)
969  if(EEDetId::validDetId(ix, iy, iz)) {
970  EEDetId myEEId = EEDetId(ix, iy, iz, EEDetId::XYMODE);
971  uint32_t rawid = myEEId.rawId();
972  // check the existence of ECAL pedestal, for a given ECAL endcap channel
973  if (payload->find(rawid) == payload->end()) continue;
974  if (!(*payload)[rawid].mean_x12 && !(*payload)[rawid].rms_x12) continue;
975  // set max on noise 2d plots
976  float valrms = (*payload)[rawid].rms_x12;
977  if(valrms > 3.5) valrms = 3.5;
978  if(iz == -1)
979  fillWithValue(ix, iy, valrms);
980  else
981  fillWithValue(ix + IX_MAX + 20, iy, valrms);
982 
983  } // validDetId
984  } // payload
985  }// loop over IOV's (1 in this case)
986  return true;
987  }// fill method
988  };
989 
990  class EcalPedestalsEERMS6Map : public cond::payloadInspector::Histogram2D<EcalPedestals> {
991 
992  public:
993  static const int IX_MIN =1;
994 
997  static const int IY_MIN =1;
998 
1001  static const int IX_MAX =100;
1002 
1005  static const int IY_MAX =100;
1006  EcalPedestalsEERMS6Map() : cond::payloadInspector::Histogram2D<EcalPedestals>( "ECAL Endcap noise gain6 - map",
1007 "ix", 2.2*IX_MAX, IX_MIN, 2.2*IX_MAX+1, "iy", IY_MAX, IY_MIN, IY_MAX+IY_MIN) {
1008  Base::setSingleIov( true );
1009  }
1010 
1011  bool fill( const std::vector<std::tuple<cond::Time_t,cond::Hash> >& iovs ){
1012  for( auto const & iov : iovs ) {
1013  std::shared_ptr<EcalPedestals> payload = Base::fetchPayload( std::get<1>(iov) );
1014  if( payload.get() ){
1015  if (!payload->endcapItems().size()) return false;
1016 
1017  // looping over the EE channels
1018  for(int iz = -1; iz < 2; iz = iz + 2) // -1 or +1
1019  for(int iy = IY_MIN; iy < IY_MAX+IY_MIN; iy++)
1020  for(int ix = IX_MIN; ix < IX_MAX+IX_MIN; ix++)
1021  if(EEDetId::validDetId(ix, iy, iz)) {
1022  EEDetId myEEId = EEDetId(ix, iy, iz, EEDetId::XYMODE);
1023  uint32_t rawid = myEEId.rawId();
1024  // check the existence of ECAL pedestal, for a given ECAL endcap channel
1025  if (payload->find(rawid) == payload->end()) continue;
1026  if (!(*payload)[rawid].mean_x6 && !(*payload)[rawid].rms_x6) continue;
1027  // set max on noise 2d plots
1028  float valrms = (*payload)[rawid].rms_x6;
1029  if(valrms > 2.0) valrms = 2.0;
1030  if(iz == -1)
1031  fillWithValue( ix, iy, valrms);
1032  else
1033  fillWithValue( ix + IX_MAX + 20, iy, valrms);
1034  } // validDetId
1035  } // payload
1036  } // loop over IOV's (1 in this case)
1037  return true;
1038  } // fill method
1039  };
1040 
1041  class EcalPedestalsEERMS1Map : public cond::payloadInspector::Histogram2D<EcalPedestals> {
1042 
1043  public:
1044  static const int IX_MIN =1;
1045 
1048  static const int IY_MIN =1;
1049 
1052  static const int IX_MAX =100;
1053 
1056  static const int IY_MAX =100;
1057  EcalPedestalsEERMS1Map() : cond::payloadInspector::Histogram2D<EcalPedestals>( "ECAL Endcap noise gain1 - map",
1058 "ix", 2.2*IX_MAX, IX_MIN, 2.2*IX_MAX+1, "iy", IY_MAX, IY_MIN, IY_MAX+IY_MIN) {
1059  Base::setSingleIov( true );
1060  }
1061 
1062  bool fill( const std::vector<std::tuple<cond::Time_t,cond::Hash> >& iovs ){
1063  for( auto const & iov : iovs ) {
1064  std::shared_ptr<EcalPedestals> payload = Base::fetchPayload( std::get<1>(iov) );
1065  if( payload.get() ){
1066  if (!payload->endcapItems().size()) return false;
1067 
1068  // looping over the EE channels
1069  for(int iz = -1; iz < 2; iz = iz + 2) // -1 or +1
1070  for(int iy = IY_MIN; iy < IY_MAX+IY_MIN; iy++)
1071  for(int ix = IX_MIN; ix < IX_MAX+IX_MIN; ix++)
1072  if(EEDetId::validDetId(ix, iy, iz)) {
1073  EEDetId myEEId = EEDetId(ix, iy, iz, EEDetId::XYMODE);
1074  uint32_t rawid = myEEId.rawId();
1075  // check the existence of ECAL pedestal, for a given ECAL endcap channel
1076  if (payload->find(rawid) == payload->end()) continue;
1077  if (!(*payload)[rawid].mean_x1 && !(*payload)[rawid].rms_x12) continue;
1078  // set max on noise 2d plots
1079  float valrms = (*payload)[rawid].rms_x1;
1080  if(valrms > 1.5) valrms = 1.5;
1081  if(iz == -1)
1082  fillWithValue( ix, iy, valrms);
1083  else
1084  fillWithValue( ix + IX_MAX + 20, iy, valrms);
1085  } // validDetId
1086  } // if payload.get()
1087  } // loop over IOV's (1 in this case)
1088  return true;
1089  } // fill method
1090  };
1091 
1092 } // close namespace
1093 
1094 // Register the classes as boost python plugin
1095 PAYLOAD_INSPECTOR_MODULE( EcalPedestals){
1096  PAYLOAD_INSPECTOR_CLASS( EcalPedestalsEBMean12);
1097  PAYLOAD_INSPECTOR_CLASS( EcalPedestalsEBMean6 );
1098  PAYLOAD_INSPECTOR_CLASS( EcalPedestalsEBMean1 );
1099  PAYLOAD_INSPECTOR_CLASS( EcalPedestalsEEMean12);
1100  PAYLOAD_INSPECTOR_CLASS( EcalPedestalsEEMean6 );
1101  PAYLOAD_INSPECTOR_CLASS( EcalPedestalsEEMean1 );
1102  PAYLOAD_INSPECTOR_CLASS( EcalPedestalsEBRMS12);
1103  PAYLOAD_INSPECTOR_CLASS( EcalPedestalsEBRMS6 );
1104  PAYLOAD_INSPECTOR_CLASS( EcalPedestalsEBRMS1 );
1105  PAYLOAD_INSPECTOR_CLASS( EcalPedestalsEERMS12);
1106  PAYLOAD_INSPECTOR_CLASS( EcalPedestalsEERMS6 );
1107  PAYLOAD_INSPECTOR_CLASS( EcalPedestalsEERMS1 );
1108  PAYLOAD_INSPECTOR_CLASS( EcalPedestalsEBMean12Map);
1109  PAYLOAD_INSPECTOR_CLASS( EcalPedestalsEBMean6Map );
1110  PAYLOAD_INSPECTOR_CLASS( EcalPedestalsEBMean1Map );
1111  PAYLOAD_INSPECTOR_CLASS( EcalPedestalsEEMean12Map);
1112  PAYLOAD_INSPECTOR_CLASS( EcalPedestalsEEMean6Map );
1113  PAYLOAD_INSPECTOR_CLASS( EcalPedestalsEEMean1Map );
1114  PAYLOAD_INSPECTOR_CLASS( EcalPedestalsEBRMS12Map);
1115  PAYLOAD_INSPECTOR_CLASS( EcalPedestalsEBRMS6Map );
1116  PAYLOAD_INSPECTOR_CLASS( EcalPedestalsEBRMS1Map );
1117  PAYLOAD_INSPECTOR_CLASS( EcalPedestalsEERMS12Map);
1118  PAYLOAD_INSPECTOR_CLASS( EcalPedestalsEERMS6Map );
1119  PAYLOAD_INSPECTOR_CLASS( EcalPedestalsEERMS1Map );
1120 }
EEDetId::XYMODE
static const int XYMODE
Definition: EEDetId.h:339
DetId::rawId
uint32_t rawId() const
get the raw id
Definition: DetId.h:43
PAYLOAD_INSPECTOR_CLASS
#define PAYLOAD_INSPECTOR_CLASS(CLASS_NAME)
Definition: PayloadInspectorModule.h:11
jetCorrFactors_cfi.payload
payload
payload postfix for testing
Definition: jetCorrFactors_cfi.py:10
EBDetId::MIN_HASH
static const int MIN_HASH
Definition: EBDetId.h:156
cond::payloadInspector::Histogram1D::fillWithValue
void fillWithValue(float value, float weight=1)
Definition: PayloadInspector.h:430
cond::payloadInspector::Histogram1D::fill
virtual bool fill(const std::vector< std::tuple< cond::Time_t, cond::Hash > > &iovs) override
Definition: PayloadInspector.h:446
PAYLOAD_INSPECTOR_MODULE
#define PAYLOAD_INSPECTOR_MODULE(PAYLOAD_TYPENAME)
Definition: PayloadInspectorModule.h:8
cond::payloadInspector::Plot2D< PayloadType, float, float >::fetchPayload
std::shared_ptr< PayloadType > fetchPayload(const cond::Hash &payloadHash)
Definition: PayloadInspector.h:198
EEDetId::validDetId
static bool validDetId(int crystal_ix, int crystal_iy, int iz)
Definition: EEDetId.h:248
EBDetId::unhashIndex
static EBDetId unhashIndex(int hi)
get a DetId from a compact index for arrays
Definition: EBDetId.h:114
cond
Definition: plugin.cc:24
Generated for CMSSW Reference Manual by doxygen 1.8.11