CMS 3D CMS Logo
EcalTPGLinearizationConst_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 #include "DataFormats/EcalDetId/interface/EBDetId.h"
5 #include "DataFormats/EcalDetId/interface/EEDetId.h"
6 #include "CondCore/EcalPlugins/plugins/EcalDrawUtils.h"
7 
8 // the data format of the condition to be inspected
9 #include "CondFormats/EcalObjects/interface/EcalTPGLinearizationConst.h"
10 
11 #include "TH2F.h"
12 #include "TCanvas.h"
13 #include "TLine.h"
14 #include "TStyle.h"
15 #include "TLatex.h"
16 #include "TPave.h"
17 #include "TPaveStats.h"
18 #include <string>
19 #include <fstream>
20 
21 namespace {
22  enum { kEBChannels = 61200, kEEChannels = 14648, kGains = 3, kSides = 2 };
23  enum { MIN_IETA = 1, MIN_IPHI = 1, MAX_IETA = 85, MAX_IPHI = 360 }; // barrel lower and upper bounds on eta and phi
24  enum { IX_MIN = 1, IY_MIN = 1, IX_MAX = 100, IY_MAX = 100 }; // endcaps lower and upper bounds on x and y
25  int gainValues[kGains] = {12, 6, 1};
26 
27  /**************************************************
28  2d plot of ECAL TPGLinearizationConst of 1 IOV
29  **************************************************/
30  class EcalTPGLinearizationConstPlot : public cond::payloadInspector::PlotImage<EcalTPGLinearizationConst> {
31  public:
32  EcalTPGLinearizationConstPlot()
33  : cond::payloadInspector::PlotImage<EcalTPGLinearizationConst>("ECAL Gain Ratios - map ") {
34  setSingleIov(true);
35  }
36 
37  bool fill(const std::vector<std::tuple<cond::Time_t, cond::Hash> >& iovs) override {
38  TH2F** barrel_m = new TH2F*[kGains];
39  TH2F** endc_p_m = new TH2F*[kGains];
40  TH2F** endc_m_m = new TH2F*[kGains];
41  TH2F** barrel_r = new TH2F*[kGains];
42  TH2F** endc_p_r = new TH2F*[kGains];
43  TH2F** endc_m_r = new TH2F*[kGains];
44  float mEBmin[kGains], mEEmin[kGains], mEBmax[kGains], mEEmax[kGains], rEBmin[kGains], rEEmin[kGains],
45  rEBmax[kGains], rEEmax[kGains];
46  for (int gainId = 0; gainId < kGains; gainId++) {
47  barrel_m[gainId] = new TH2F(Form("EBm%i", gainId),
48  Form("EB mult_x%i ", gainValues[gainId]),
49  MAX_IPHI,
50  0,
51  MAX_IPHI,
52  2 * MAX_IETA,
53  -MAX_IETA,
54  MAX_IETA);
55  endc_p_m[gainId] = new TH2F(Form("EE+m%i", gainId),
56  Form("EE+ mult_x%i", gainValues[gainId]),
57  IX_MAX,
58  IX_MIN,
59  IX_MAX + 1,
60  IY_MAX,
61  IY_MIN,
62  IY_MAX + 1);
63  endc_m_m[gainId] = new TH2F(Form("EE-m%i", gainId),
64  Form("EE- mult_x%i", gainValues[gainId]),
65  IX_MAX,
66  IX_MIN,
67  IX_MAX + 1,
68  IY_MAX,
69  IY_MIN,
70  IY_MAX + 1);
71  barrel_r[gainId] = new TH2F(Form("EBr%i", gainId),
72  Form("EB shift_x%i", gainValues[gainId]),
73  MAX_IPHI,
74  0,
75  MAX_IPHI,
76  2 * MAX_IETA,
77  -MAX_IETA,
78  MAX_IETA);
79  endc_p_r[gainId] = new TH2F(Form("EE+r%i", gainId),
80  Form("EE+ shift_x%i", gainValues[gainId]),
81  IX_MAX,
82  IX_MIN,
83  IX_MAX + 1,
84  IY_MAX,
85  IY_MIN,
86  IY_MAX + 1);
87  endc_m_r[gainId] = new TH2F(Form("EE-r%i", gainId),
88  Form("EE- shift_x%i", gainValues[gainId]),
89  IX_MAX,
90  IX_MIN,
91  IX_MAX + 1,
92  IY_MAX,
93  IY_MIN,
94  IY_MAX + 1);
95  mEBmin[gainId] = 10.;
96  mEEmin[gainId] = 10.;
97  mEBmax[gainId] = -10.;
98  mEEmax[gainId] = -10.;
99  rEBmin[gainId] = 10.;
100  rEEmin[gainId] = 10.;
101  rEBmax[gainId] = -10.;
102  rEEmax[gainId] = -10.;
103  }
104 
105  // std::ofstream fout;
106  // fout.open("./bid.txt");
107  auto iov = iovs.front();
108  std::shared_ptr<EcalTPGLinearizationConst> payload = fetchPayload(std::get<1>(iov));
109  unsigned int run = std::get<0>(iov);
110  if (payload.get()) {
111  for (int sign = 0; sign < kSides; sign++) {
112  int thesign = sign == 1 ? 1 : -1;
113 
114  for (int ieta = 0; ieta < MAX_IETA; ieta++) {
115  for (int iphi = 0; iphi < MAX_IPHI; iphi++) {
116  EBDetId id((ieta + 1) * thesign, iphi + 1);
117  float y = -1 - ieta;
118  if (sign == 1)
119  y = ieta;
120  float val = (*payload)[id.rawId()].mult_x12;
121  barrel_m[0]->Fill(iphi, y, val);
122  if (val < mEBmin[0])
123  mEBmin[0] = val;
124  if (val > mEBmax[0])
125  mEBmax[0] = val;
126  val = (*payload)[id.rawId()].shift_x12;
127  barrel_r[0]->Fill(iphi, y, val);
128  if (val < rEBmin[0])
129  rEBmin[0] = val;
130  if (val > rEBmax[0])
131  rEBmax[0] = val;
132  val = (*payload)[id.rawId()].mult_x6;
133  barrel_m[1]->Fill(iphi, y, val);
134  if (val < mEBmin[1])
135  mEBmin[1] = val;
136  if (val > mEBmax[1])
137  mEBmax[1] = val;
138  val = (*payload)[id.rawId()].shift_x6;
139  barrel_r[1]->Fill(iphi, y, val);
140  if (val < rEBmin[1])
141  rEBmin[1] = val;
142  if (val > rEBmax[1])
143  rEBmax[1] = val;
144  val = (*payload)[id.rawId()].mult_x1;
145  barrel_m[2]->Fill(iphi, y, val);
146  if (val < mEBmin[2])
147  mEBmin[2] = val;
148  if (val > mEBmax[2])
149  mEBmax[2] = val;
150  val = (*payload)[id.rawId()].shift_x1;
151  barrel_r[2]->Fill(iphi, y, val);
152  if (val < rEBmin[2])
153  rEBmin[2] = val;
154  if (val > rEBmax[2])
155  rEBmax[2] = val;
156  } // iphi
157  } // ieta
158 
159  for (int ix = 0; ix < IX_MAX; ix++) {
160  for (int iy = 0; iy < IY_MAX; iy++) {
161  if (!EEDetId::validDetId(ix + 1, iy + 1, thesign))
162  continue;
163  EEDetId id(ix + 1, iy + 1, thesign);
164  float val = (*payload)[id.rawId()].mult_x12;
165  if (thesign == 1)
166  endc_p_m[0]->Fill(ix + 1, iy + 1, val);
167  else
168  endc_m_m[0]->Fill(ix + 1, iy + 1, val);
169  if (val < mEEmin[0])
170  mEEmin[0] = val;
171  if (val > mEEmax[0])
172  mEEmax[0] = val;
173  val = (*payload)[id.rawId()].shift_x12;
174  if (thesign == 1)
175  endc_p_r[0]->Fill(ix + 1, iy + 1, val);
176  else
177  endc_m_r[0]->Fill(ix + 1, iy + 1, val);
178  if (val < rEEmin[0])
179  rEEmin[0] = val;
180  if (val > rEEmax[0])
181  rEEmax[0] = val;
182  val = (*payload)[id.rawId()].mult_x6;
183  if (thesign == 1)
184  endc_p_m[1]->Fill(ix + 1, iy + 1, val);
185  else
186  endc_m_m[1]->Fill(ix + 1, iy + 1, val);
187  if (val < mEEmin[1])
188  mEEmin[1] = val;
189  if (val > mEEmax[1])
190  mEEmax[1] = val;
191  val = (*payload)[id.rawId()].shift_x6;
192  if (thesign == 1)
193  endc_p_r[1]->Fill(ix + 1, iy + 1, val);
194  else
195  endc_m_r[1]->Fill(ix + 1, iy + 1, val);
196  if (val < rEEmin[1])
197  rEEmin[1] = val;
198  if (val > rEEmax[1])
199  rEEmax[1] = val;
200  val = (*payload)[id.rawId()].mult_x1;
201  if (thesign == 1)
202  endc_p_m[2]->Fill(ix + 1, iy + 1, val);
203  else
204  endc_m_m[2]->Fill(ix + 1, iy + 1, val);
205  if (val < mEEmin[2])
206  mEEmin[2] = val;
207  if (val > mEEmax[2])
208  mEEmax[2] = val;
209  val = (*payload)[id.rawId()].shift_x1;
210  if (thesign == 1)
211  endc_p_r[2]->Fill(ix + 1, iy + 1, val);
212  else
213  endc_m_r[2]->Fill(ix + 1, iy + 1, val);
214  if (val < rEEmin[2])
215  rEEmin[2] = val;
216  if (val > rEEmax[2])
217  rEEmax[2] = val;
218  // fout << " x " << ix << " y " << " val " << val << std::endl;
219  } // iy
220  } // ix
221  } // side
222  } // if payload.get()
223  else
224  return false;
225  // std::cout << " min " << rEEmin[2] << " max " << rEEmax[2] << std::endl;
226  // fout.close();
227 
228  gStyle->SetPalette(1);
229  gStyle->SetOptStat(0);
230  TCanvas canvas("CC map", "CC map", 1200, 1800);
231  TLatex t1;
232  t1.SetNDC();
233  t1.SetTextAlign(26);
234  t1.SetTextSize(0.05);
235  t1.DrawLatex(0.5, 0.96, Form("Ecal Gain TPGLinearizationConst, IOV %i", run));
236 
237  float xmi[3] = {0.0, 0.22, 0.78};
238  float xma[3] = {0.22, 0.78, 1.00};
239  TPad*** pad = new TPad**[6];
240  for (int gId = 0; gId < 6; gId++) {
241  pad[gId] = new TPad*[3];
242  for (int obj = 0; obj < 3; obj++) {
243  float yma = 0.94 - (0.16 * gId);
244  float ymi = yma - 0.14;
245  pad[gId][obj] = new TPad(Form("p_%i_%i", obj, gId), Form("p_%i_%i", obj, gId), xmi[obj], ymi, xma[obj], yma);
246  pad[gId][obj]->Draw();
247  }
248  }
249 
250  for (int gId = 0; gId < kGains; gId++) {
251  pad[gId][0]->cd();
252  DrawEE(endc_m_m[gId], mEEmin[gId], mEEmax[gId]);
253  pad[gId + 3][0]->cd();
254  DrawEE(endc_m_r[gId], rEEmin[gId], rEEmax[gId]);
255  pad[gId][1]->cd();
256  DrawEB(barrel_m[gId], mEBmin[gId], mEBmax[gId]);
257  pad[gId + 3][1]->cd();
258  DrawEB(barrel_r[gId], rEBmin[gId], rEBmax[gId]);
259  pad[gId][2]->cd();
260  DrawEE(endc_p_m[gId], mEEmin[gId], mEEmax[gId]);
261  pad[gId + 3][2]->cd();
262  DrawEE(endc_p_r[gId], rEEmin[gId], rEEmax[gId]);
263  }
264 
265  std::string ImageName(m_imageFileName);
266  canvas.SaveAs(ImageName.c_str());
267  return true;
268  } // fill method
269  };
270 
271  /******************************************************************
272  2d plot of ECAL TPGLinearizationConst difference between 2 IOVs
273  ******************************************************************/
274  class EcalTPGLinearizationConstDiff : public cond::payloadInspector::PlotImage<EcalTPGLinearizationConst> {
275  public:
276  EcalTPGLinearizationConstDiff()
277  : cond::payloadInspector::PlotImage<EcalTPGLinearizationConst>("ECAL Gain Ratios difference") {
278  setSingleIov(false);
279  }
280 
281  bool fill(const std::vector<std::tuple<cond::Time_t, cond::Hash> >& iovs) override {
282  TH2F** barrel_m = new TH2F*[kGains];
283  TH2F** endc_p_m = new TH2F*[kGains];
284  TH2F** endc_m_m = new TH2F*[kGains];
285  TH2F** barrel_r = new TH2F*[kGains];
286  TH2F** endc_p_r = new TH2F*[kGains];
287  TH2F** endc_m_r = new TH2F*[kGains];
288  float mEBmin[kGains], mEEmin[kGains], mEBmax[kGains], mEEmax[kGains], rEBmin[kGains], rEEmin[kGains],
289  rEBmax[kGains], rEEmax[kGains];
290  float mEB[kGains][kEBChannels], mEE[kGains][kEEChannels], rEB[kGains][kEBChannels], rEE[kGains][kEEChannels];
291  for (int gainId = 0; gainId < kGains; gainId++) {
292  barrel_m[gainId] = new TH2F(Form("EBm%i", gainId),
293  Form("EB mult_x%i ", gainValues[gainId]),
294  MAX_IPHI,
295  0,
296  MAX_IPHI,
297  2 * MAX_IETA,
298  -MAX_IETA,
299  MAX_IETA);
300  endc_p_m[gainId] = new TH2F(Form("EE+m%i", gainId),
301  Form("EE+ mult_x%i", gainValues[gainId]),
302  IX_MAX,
303  IX_MIN,
304  IX_MAX + 1,
305  IY_MAX,
306  IY_MIN,
307  IY_MAX + 1);
308  endc_m_m[gainId] = new TH2F(Form("EE-m%i", gainId),
309  Form("EE- mult_x%i", gainValues[gainId]),
310  IX_MAX,
311  IX_MIN,
312  IX_MAX + 1,
313  IY_MAX,
314  IY_MIN,
315  IY_MAX + 1);
316  barrel_r[gainId] = new TH2F(Form("EBr%i", gainId),
317  Form("EB shift_x%i", gainValues[gainId]),
318  MAX_IPHI,
319  0,
320  MAX_IPHI,
321  2 * MAX_IETA,
322  -MAX_IETA,
323  MAX_IETA);
324  endc_p_r[gainId] = new TH2F(Form("EE+r%i", gainId),
325  Form("EE+ shift_x%i", gainValues[gainId]),
326  IX_MAX,
327  IX_MIN,
328  IX_MAX + 1,
329  IY_MAX,
330  IY_MIN,
331  IY_MAX + 1);
332  endc_m_r[gainId] = new TH2F(Form("EE-r%i", gainId),
333  Form("EE- shift_x%i", gainValues[gainId]),
334  IX_MAX,
335  IX_MIN,
336  IX_MAX + 1,
337  IY_MAX,
338  IY_MIN,
339  IY_MAX + 1);
340  mEBmin[gainId] = 10.;
341  mEEmin[gainId] = 10.;
342  mEBmax[gainId] = -10.;
343  mEEmax[gainId] = -10.;
344  rEBmin[gainId] = 10.;
345  rEEmin[gainId] = 10.;
346  rEBmax[gainId] = -10.;
347  rEEmax[gainId] = -10.;
348  }
349 
350  unsigned int run[2], irun = 0;
351  //float gEB[3][kEBChannels], gEE[3][kEEChannels];
352  for (auto const& iov : iovs) {
353  std::shared_ptr<EcalTPGLinearizationConst> payload = fetchPayload(std::get<1>(iov));
354  run[irun] = std::get<0>(iov);
355  if (payload.get()) {
356  for (int sign = 0; sign < kSides; sign++) {
357  int thesign = sign == 1 ? 1 : -1;
358 
359  for (int ieta = 0; ieta < MAX_IETA; ieta++) {
360  for (int iphi = 0; iphi < MAX_IPHI; iphi++) {
361  EBDetId id((ieta + 1) * thesign, iphi + 1);
362  int hashindex = id.hashedIndex();
363  float y = -1 - ieta;
364  if (sign == 1)
365  y = ieta;
366  float val = (*payload)[id.rawId()].mult_x12;
367  if (irun == 0) {
368  mEB[0][hashindex] = val;
369  } else {
370  float diff = val - mEB[0][hashindex];
371  barrel_m[0]->Fill(iphi, y, diff);
372  if (diff < mEBmin[0])
373  mEBmin[0] = diff;
374  if (diff > mEBmax[0])
375  mEBmax[0] = diff;
376  }
377  val = (*payload)[id.rawId()].shift_x12;
378  if (irun == 0) {
379  rEB[0][hashindex] = val;
380  } else {
381  float diff = val - rEB[0][hashindex];
382  barrel_r[0]->Fill(iphi, y, diff);
383  if (diff < rEBmin[0])
384  rEBmin[0] = diff;
385  if (diff > rEBmax[0])
386  rEBmax[0] = diff;
387  }
388  val = (*payload)[id.rawId()].mult_x6;
389  if (irun == 0) {
390  mEB[1][hashindex] = val;
391  } else {
392  float diff = val - mEB[1][hashindex];
393  barrel_m[1]->Fill(iphi, y, diff);
394  if (diff < mEBmin[1])
395  mEBmin[1] = diff;
396  if (diff > mEBmax[1])
397  mEBmax[1] = diff;
398  }
399  val = (*payload)[id.rawId()].shift_x6;
400  if (irun == 0) {
401  rEB[1][hashindex] = val;
402  } else {
403  float diff = val - rEB[1][hashindex];
404  barrel_r[1]->Fill(iphi, y, diff);
405  if (diff < rEBmin[1])
406  rEBmin[1] = diff;
407  if (diff > rEBmax[1])
408  rEBmax[1] = diff;
409  }
410  val = (*payload)[id.rawId()].mult_x1;
411  if (irun == 0) {
412  mEB[2][hashindex] = val;
413  } else {
414  float diff = val - mEB[2][hashindex];
415  barrel_m[2]->Fill(iphi, y, diff);
416  if (diff < mEBmin[2])
417  mEBmin[2] = diff;
418  if (diff > mEBmax[2])
419  mEBmax[2] = diff;
420  }
421  val = (*payload)[id.rawId()].shift_x1;
422  if (irun == 0) {
423  rEB[2][hashindex] = val;
424  } else {
425  float diff = val - rEB[2][hashindex];
426  barrel_r[2]->Fill(iphi, y, diff);
427  if (diff < rEBmin[2])
428  rEBmin[2] = diff;
429  if (diff > rEBmax[2])
430  rEBmax[2] = diff;
431  }
432  } // iphi
433  } // ieta
434 
435  for (int ix = 0; ix < IX_MAX; ix++) {
436  for (int iy = 0; iy < IY_MAX; iy++) {
437  if (!EEDetId::validDetId(ix + 1, iy + 1, thesign))
438  continue;
439  EEDetId id(ix + 1, iy + 1, thesign);
440  int hashindex = id.hashedIndex();
441  float val = (*payload)[id.rawId()].mult_x12;
442  if (irun == 0) {
443  mEE[0][hashindex] = val;
444  } else {
445  float diff = val - mEE[0][hashindex];
446  if (thesign == 1)
447  endc_p_m[0]->Fill(ix + 1, iy + 1, diff);
448  else
449  endc_m_m[0]->Fill(ix + 1, iy + 1, diff);
450  if (diff < mEEmin[0])
451  mEEmin[0] = diff;
452  if (diff > mEEmax[0])
453  mEEmax[0] = diff;
454  }
455  val = (*payload)[id.rawId()].shift_x12;
456  if (irun == 0) {
457  rEE[0][hashindex] = val;
458  } else {
459  float diff = val - rEE[0][hashindex];
460  if (thesign == 1)
461  endc_p_r[0]->Fill(ix + 1, iy + 1, diff);
462  else
463  endc_m_r[0]->Fill(ix + 1, iy + 1, diff);
464  if (diff < rEEmin[0])
465  rEEmin[0] = diff;
466  if (diff > rEEmax[0])
467  rEEmax[0] = diff;
468  }
469  val = (*payload)[id.rawId()].mult_x6;
470  if (irun == 0) {
471  mEE[1][hashindex] = val;
472  } else {
473  float diff = val - mEE[1][hashindex];
474  if (thesign == 1)
475  endc_p_m[1]->Fill(ix + 1, iy + 1, diff);
476  else
477  endc_m_m[1]->Fill(ix + 1, iy + 1, diff);
478  if (diff < mEEmin[1])
479  mEEmin[1] = diff;
480  if (diff > mEEmax[1])
481  mEEmax[1] = diff;
482  }
483  val = (*payload)[id.rawId()].shift_x6;
484  if (irun == 0) {
485  rEE[1][hashindex] = val;
486  } else {
487  float diff = val - rEE[1][hashindex];
488  if (thesign == 1)
489  endc_p_r[1]->Fill(ix + 1, iy + 1, diff);
490  else
491  endc_m_r[1]->Fill(ix + 1, iy + 1, diff);
492  if (diff < rEEmin[1])
493  rEEmin[1] = diff;
494  if (diff > rEEmax[1])
495  rEEmax[1] = diff;
496  }
497  val = (*payload)[id.rawId()].mult_x1;
498  if (irun == 0) {
499  mEE[2][hashindex] = val;
500  } else {
501  float diff = val - mEE[2][hashindex];
502  if (thesign == 1)
503  endc_p_m[2]->Fill(ix + 1, iy + 1, diff);
504  else
505  endc_m_m[2]->Fill(ix + 1, iy + 1, diff);
506  if (diff < mEEmin[2])
507  mEEmin[2] = diff;
508  if (diff > mEEmax[2])
509  mEEmax[2] = diff;
510  }
511  val = (*payload)[id.rawId()].shift_x1;
512  if (irun == 0) {
513  rEE[2][hashindex] = val;
514  } else {
515  float diff = val - rEE[2][hashindex];
516  if (thesign == 1)
517  endc_p_r[2]->Fill(ix + 1, iy + 1, diff);
518  else
519  endc_m_r[2]->Fill(ix + 1, iy + 1, diff);
520  if (diff < rEEmin[2])
521  rEEmin[2] = diff;
522  if (diff > rEEmax[2])
523  rEEmax[2] = diff;
524  }
525  // fout << " x " << ix << " y " << " diff " << diff << std::endl;
526  } // iy
527  } // ix
528  } // side
529  } // if payload.get()
530  else
531  return false;
532  irun++;
533  } // loop over IOVs
534 
535  gStyle->SetPalette(1);
536  gStyle->SetOptStat(0);
537  TCanvas canvas("CC map", "CC map", 1200, 1800);
538  TLatex t1;
539  t1.SetNDC();
540  t1.SetTextAlign(26);
541  t1.SetTextSize(0.05);
542  t1.DrawLatex(0.5, 0.96, Form("Ecal TPGLinearizationConst, IOV %i - %i", run[1], run[0]));
543 
544  float xmi[3] = {0.0, 0.22, 0.78};
545  float xma[3] = {0.22, 0.78, 1.00};
546  TPad*** pad = new TPad**[6];
547  for (int gId = 0; gId < 6; gId++) {
548  pad[gId] = new TPad*[3];
549  for (int obj = 0; obj < 3; obj++) {
550  float yma = 0.94 - (0.16 * gId);
551  float ymi = yma - 0.14;
552  pad[gId][obj] = new TPad(Form("p_%i_%i", obj, gId), Form("p_%i_%i", obj, gId), xmi[obj], ymi, xma[obj], yma);
553  pad[gId][obj]->Draw();
554  }
555  }
556 
557  for (int gId = 0; gId < kGains; gId++) {
558  pad[gId][0]->cd();
559  DrawEE(endc_m_m[gId], mEEmin[gId], mEEmax[gId]);
560  pad[gId + 3][0]->cd();
561  DrawEE(endc_m_r[gId], rEEmin[gId], rEEmax[gId]);
562  pad[gId][1]->cd();
563  DrawEB(barrel_m[gId], mEBmin[gId], mEBmax[gId]);
564  pad[gId + 3][1]->cd();
565  DrawEB(barrel_r[gId], rEBmin[gId], rEBmax[gId]);
566  pad[gId][2]->cd();
567  DrawEE(endc_p_m[gId], mEEmin[gId], mEEmax[gId]);
568  pad[gId + 3][2]->cd();
569  DrawEE(endc_p_r[gId], rEEmin[gId], rEEmax[gId]);
570  }
571 
572  std::string ImageName(m_imageFileName);
573  canvas.SaveAs(ImageName.c_str());
574  return true;
575  } // fill method
576  };
577 
578 } // namespace
579 
580 // Register the classes as boost python plugin
581 PAYLOAD_INSPECTOR_MODULE(EcalTPGLinearizationConst) {
582  PAYLOAD_INSPECTOR_CLASS(EcalTPGLinearizationConstPlot);
583  PAYLOAD_INSPECTOR_CLASS(EcalTPGLinearizationConstDiff);
584 }
change_name.diff
diff
Definition: change_name.py:13
svgfig.canvas
def canvas(*sub, **attr)
Definition: svgfig.py:482
DDAxes::y
kEEChannels
Definition: EcalFloatCondObjectContainerUtils.h:9
MAX_IPHI
Definition: EcalFloatCondObjectContainerUtils.h:14
IX_MAX
Definition: EcalFloatCondObjectContainerUtils.h:20
IY_MAX
Definition: EcalFloatCondObjectContainerUtils.h:21
EBDetId
Definition: EBDetId.h:17
PayloadInspector.h
EBDetId.h
EEDetId.h
Validation_hcalonly_cfi.sign
sign
Definition: Validation_hcalonly_cfi.py:32
PAYLOAD_INSPECTOR_CLASS
#define PAYLOAD_INSPECTOR_CLASS(CLASS_NAME)
Definition: PayloadInspectorModule.h:10
EcalCondObjectContainer< EcalTPGLinearizationConstant >
PayloadInspectorModule.h
DrawEE
void DrawEE(TH2F *endc, float min, float max)
Definition: EcalDrawUtils.h:29
LEDCalibrationChannels.iphi
iphi
Definition: LEDCalibrationChannels.py:64
RandomServiceHelper.t1
t1
Definition: RandomServiceHelper.py:256
DrawEB
void DrawEB(TH2F *ebmap, float min, float max)
Definition: EcalDrawUtils.h:4
MIN_IETA
Definition: EcalFloatCondObjectContainerUtils.h:11
jets_cff.payload
payload
Definition: jets_cff.py:34
PAYLOAD_INSPECTOR_MODULE
#define PAYLOAD_INSPECTOR_MODULE(PAYLOAD_TYPENAME)
Definition: PayloadInspectorModule.h:8
getGTfromDQMFile.obj
obj
Definition: getGTfromDQMFile.py:32
EEDetId
Definition: EEDetId.h:14
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
cond
Definition: plugin.cc:23
LEDCalibrationChannels.ieta
ieta
Definition: LEDCalibrationChannels.py:63
Time.h
EcalTPGLinearizationConst.h
IY_MIN
Definition: EcalFloatCondObjectContainerUtils.h:19
cond::payloadInspector::PlotImage::fetchPayload
std::shared_ptr< PayloadType > fetchPayload(const cond::Hash &payloadHash)
Definition: PayloadInspector.h:840
MIN_IPHI
Definition: EcalFloatCondObjectContainerUtils.h:12
EcalDrawUtils.h
kSides
static const int kSides
Definition: EcalGeomPhiSymHelper.h:9
heppy_batch.val
val
Definition: heppy_batch.py:351
writedatasetfile.run
run
Definition: writedatasetfile.py:27
gainValues
const Int_t gainValues[kGains]
Definition: EcalPedestalsHandler.cc:15
kGains
const Int_t kGains
Definition: EcalPedestalsHandler.cc:13
triggerObjects_cff.id
id
Definition: triggerObjects_cff.py:31
cond::payloadInspector::PlotImpl::fill
virtual bool fill()=0
cond::payloadInspector::PlotImage
Definition: PayloadInspector.h:829
EEDetId::validDetId
static bool validDetId(int crystal_ix, int crystal_iy, int iz)
Definition: EEDetId.h:248
ecalMGPA::gainId
constexpr int gainId(sample_type sample)
get the gainId (2 bits)
Definition: EcalMGPASample.h:13
kEBChannels
Definition: EcalFloatCondObjectContainerUtils.h:9
IX_MIN
Definition: EcalFloatCondObjectContainerUtils.h:18
MAX_IETA
Definition: EcalFloatCondObjectContainerUtils.h:13
Generated for CMSSW Reference Manual by doxygen 1.8.16