test
CMS 3D CMS Logo

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
DigiRunSummary.cc
Go to the documentation of this file.
2 
3 namespace hcaldqm
4 {
6  std::string const& taskname, edm::ParameterSet const& ps) :
7  DQClient(name, taskname, ps), _booked(false)
8  {
9  _thresh_unihf = ps.getUntrackedParameter<double>("thresh_unihf",
10  0.2);
11  }
12 
13  /* virtual */ void DigiRunSummary::beginRun(edm::Run const& r,
14  edm::EventSetup const& es)
15  {
16  DQClient::beginRun(r,es);
17 
18  if (_ptype!=fOffline)
19  return;
20 
21  // INITIALIZE WHAT NEEDS TO BE INITIALIZE ONLY ONCE!
26  FIBER_uTCA_MIN1, FIBERCH_MIN, false).rawId());
28  _vhashVME); // filter out VME
30  _vhashuTCA); // filter out uTCA
32  FIBER_uTCA_MIN1, FIBERCH_MIN, false).rawId());
34  FIBER_uTCA_MIN1, FIBERCH_MIN, false).rawId());
36  FIBER_uTCA_MIN1, FIBERCH_MIN, false).rawId());
38  _vhashFEDHF); // preserve only HF FEDs
39 
44 
50 
51  _cOccupancy_depth.initialize(_name, "Occupancy",
56 
57  // GET THE NOMINAL NUMBER OF CHANNELS PER FED
58  std::vector<HcalGenericDetId> gids = _emap->allPrecisionId();
59  for (std::vector<HcalGenericDetId>::const_iterator it=gids.begin();
60  it!=gids.end(); ++it)
61  {
62  if (!it->isHcalDetId())
63  continue;
64  HcalDetId did(it->rawId());
66  _xNChsNominal.get(eid)++;
67  }
68  }
69 
70  /*
71  * END LUMI. EVALUATE LUMI BASED FLAGS
72  */
75  edm::EventSetup const& es)
76  {
77  DQClient::endLuminosityBlock(ib, ig, lb, es);
78 
79  if (_ptype!=fOffline)
80  return;
81 
82  LSSummary lssum;
83  lssum._LS=_currentLS;
84 
86 
87  // INITIALIZE LUMI BASED HISTOGRAMS
88  Container2D cDigiSize_FED, cOccupancy_depth;
89  cDigiSize_FED.initialize(_taskname, "DigiSize",
93  cOccupancy_depth.initialize(_taskname, "Occupancy",
98 
99  // LOAD LUMI BASED HISTOGRAMS
100  cOccupancy_depth.load(ig, _emap, _subsystem);
101  cDigiSize_FED.load(ig, _emap, _subsystem);
102  MonitorElement *meNumEvents = ig.get(_subsystem+
103  "/RunInfo/NumberOfEvents");
104  int numEvents = meNumEvents->getBinContent(1);
105  bool unknownIdsPresent = ig.get(_subsystem+"/"
106  +_taskname+"/UnknownIds")->getBinContent(1)>0;
107 
108  // book the Numer of Events - set axis extendable
109  if (!_booked)
110  {
112  _meNumEvents = ib.book1D("NumberOfEvents", "NumberOfEvents",
113  1000, 1, 1001); // 1000 to start with
114  _meNumEvents->getTH1()->SetCanExtend(TH1::kXaxis);
115 
117  _booked=true;
118  }
120 
121  // ANALYZE THIS LS for LS BASED FLAGS
122  std::vector<HcalGenericDetId> gids = _emap->allPrecisionId();
123  for (std::vector<HcalGenericDetId>::const_iterator it=gids.begin();
124  it!=gids.end(); ++it)
125  {
126  if (!it->isHcalDetId())
127  continue;
128 
129  HcalDetId did = HcalDetId(it->rawId());
131 
132  cOccupancy_depth.getBinContent(did)>0?_xNChs.get(eid)++:
133  _xNChs.get(eid)+=0;
134  _cOccupancy_depth.fill(did, cOccupancy_depth.getBinContent(did));
135  // digi size
136  cDigiSize_FED.getMean(eid)!=
137  constants::DIGISIZE[did.subdet()-1]?
138  _xDigiSize.get(eid)++:_xDigiSize.get(eid)+=0;
139  cDigiSize_FED.getRMS(eid)!=0?
140  _xDigiSize.get(eid)++:_xDigiSize.get(eid)+=0;
141  }
142 
143  // GENERATE SUMMARY AND STORE IT
144  std::vector<flag::Flag> vtmpflags;
145  vtmpflags.resize(nLSFlags);
146  vtmpflags[fDigiSize]=flag::Flag("DigiSize");
147  vtmpflags[fNChsHF]=flag::Flag("NChsHF");
148  vtmpflags[fUnknownIds]=flag::Flag("UnknownIds");
149  for (std::vector<uint32_t>::const_iterator it=_vhashFEDs.begin();
150  it!=_vhashFEDs.end(); ++it)
151  {
152  HcalElectronicsId eid(*it);
153 
154  // reset all the tmp flags to fNA
155  // MUST DO IT NOW! AS NCDAQ MIGHT OVERWRITE IT!
156  for (std::vector<flag::Flag>::iterator ft=vtmpflags.begin();
157  ft!=vtmpflags.end(); ++ft)
158  ft->reset();
159 
160  std::vector<uint32_t>::const_iterator cit=std::find(
161  _vcdaqEids.begin(), _vcdaqEids.end(), *it);
162  if (cit==_vcdaqEids.end())
163  {
164  // was not @cDAQ, set all the flags for this FED as fNCDAQ
165  for (std::vector<flag::Flag>::iterator ft=vtmpflags.begin();
166  ft!=vtmpflags.end(); ++ft)
167  ft->_state = flag::fNCDAQ;
168 
169  // push all the flags for this FED
170  // IMPORTANT!!!
171  lssum._vflags.push_back(vtmpflags);
172  continue;
173  }
174 
175  if (utilities::isFEDHBHE(eid) || utilities::isFEDHF(eid) ||
176  utilities::isFEDHO(eid))
177  {
178  if (_xDigiSize.get(eid)>0)
179  vtmpflags[fDigiSize]._state = flag::fBAD;
180  else
181  vtmpflags[fDigiSize]._state = flag::fGOOD;
182  if (utilities::isFEDHF(eid))
183  {
184  if (_xNChs.get(eid)!=_xNChsNominal.get(eid))
185  vtmpflags[fNChsHF]._state = flag::fBAD;
186  else
187  vtmpflags[fNChsHF]._state = flag::fGOOD;
188  }
189  }
190  if (unknownIdsPresent)
191  vtmpflags[fUnknownIds]._state = flag::fBAD;
192  else
193  vtmpflags[fUnknownIds]._state = flag::fGOOD;
194 
195  // push all the flags for this FED
196  lssum._vflags.push_back(vtmpflags);
197  }
198 
199  // push all the flags for all FEDs for this LS
200  _vflagsLS.push_back(lssum);
201  }
202 
203  /*
204  * End Job
205  */
206  /* virtual */ std::vector<flag::Flag> DigiRunSummary::endJob(
208  {
209  if (_ptype!=fOffline)
210  return std::vector<flag::Flag>();
211 
213 
214  // PREPARE LS AND RUN BASED FLAGS TO USE IT FOR BOOKING
215  std::vector<flag::Flag> vflagsPerLS;
216  std::vector<flag::Flag> vflagsPerRun;
217  vflagsPerLS.resize(nLSFlags);
218  vflagsPerRun.resize(nDigiFlag-nLSFlags+1);
219  vflagsPerLS[fDigiSize]=flag::Flag("DigiSize");
220  vflagsPerLS[fNChsHF]=flag::Flag("NChsHF");
221  vflagsPerRun[fDigiSize]=flag::Flag("DigiSize");
222  vflagsPerRun[fNChsHF]=flag::Flag("NChsHF");
223  vflagsPerRun[fUniHF-nLSFlags+1]=flag::Flag("UniSlotHF");
224  vflagsPerRun[fDead-nLSFlags+1]=flag::Flag("Dead");
225 
226  // INITIALIZE SUMMARY CONTAINERS
227  ContainerSingle2D cSummaryvsLS;
228  Container2D cSummaryvsLS_FED;
229  cSummaryvsLS.initialize(_name, "SummaryvsLS",
233  cSummaryvsLS_FED.initialize(_name, "SummaryvsLS",
236  new quantity::FlagQuantity(vflagsPerLS),
238  cSummaryvsLS_FED.book(ib, _emap, _subsystem);
239  cSummaryvsLS.book(ib, _subsystem);
240 
241  // INITIALIZE CONTAINERS WE NEED TO LOAD or BOOK
242  Container2D cOccupancyCut_depth;
243  Container2D cDead_depth, cDead_FEDVME, cDead_FEDuTCA;
244  cOccupancyCut_depth.initialize(_taskname, "OccupancyCut",
249  cDead_depth.initialize(_name, "Dead",
254  cDead_FEDVME.initialize(_name, "Dead",
259  cDead_FEDuTCA.initialize(_name, "Dead",
264 
265  // LOAD
266  cOccupancyCut_depth.load(ig, _emap, _subsystem);
267  cDead_depth.book(ib, _emap, _subsystem);
268  cDead_FEDVME.book(ib, _emap, _filter_uTCA, _subsystem);
269  cDead_FEDuTCA.book(ib, _emap, _filter_VME, _subsystem);
270 
271  // ANALYZE RUN BASED QUANTITIES
272  std::vector<HcalGenericDetId> gids = _emap->allPrecisionId();
273  for (std::vector<HcalGenericDetId>::const_iterator it=gids.begin();
274  it!=gids.end(); ++it)
275  {
276  if (!it->isHcalDetId())
277  continue;
278 
279  HcalDetId did = HcalDetId(it->rawId());
281 
282  if (_cOccupancy_depth.getBinContent(did)<1)
283  {
284  _xDead.get(eid)++;
285  cDead_depth.fill(did);
286  eid.isVMEid()?cDead_FEDVME.fill(eid):cDead_FEDuTCA.fill(eid);
287  }
288  if (did.subdet()==HcalForward)
289  _xUniHF.get(eid)+=cOccupancyCut_depth.getBinContent(did);
290  }
291  // ANALYZE FOR HF SLOT UNIFORMITY
292  for (uintCompactMap::const_iterator it=_xUniHF.begin();
293  it!=_xUniHF.end(); ++it)
294  {
295  uint32_t hash1 = it->first;
296  HcalElectronicsId eid1(hash1);
297  double x1 = it->second;
298 
299  for (uintCompactMap::const_iterator jt=_xUniHF.begin();
300  jt!=_xUniHF.end(); ++jt)
301  {
302  if (jt==it)
303  continue;
304 
305  double x2 = jt->second;
306  if (x2==0)
307  continue;
308  if (x1/x2<_thresh_unihf)
309  _xUni.get(eid1)++;
310  }
311  }
312 
313  /*
314  * Iterate over each FED
315  * Iterate over each LS Summary
316  * Iterate over all flags
317  * set...
318  */
319  // iterate over all FEDs
320  std::vector<flag::Flag> sumflags;
321  int ifed=0;
322  for (std::vector<uint32_t>::const_iterator it=_vhashFEDs.begin();
323  it!=_vhashFEDs.end(); ++it)
324  {
325  flag::Flag fSumRun("DIGI"); // summary flag for this FED
326  flag::Flag ffDead("Dead");
327  flag::Flag ffUniSlotHF("UniSlotHF");
328  HcalElectronicsId eid(*it);
329 
330  // ITERATE OVER EACH LS
331  for (std::vector<LSSummary>::const_iterator itls=_vflagsLS.begin();
332  itls!=_vflagsLS.end(); ++itls)
333  {
334  int iflag=0;
335  flag::Flag fSumLS("DIGI");
336  for (std::vector<flag::Flag>::const_iterator ft=
337  itls->_vflags[ifed].begin(); ft!=itls->_vflags[ifed].end();
338  ++ft)
339  {
340  cSummaryvsLS_FED.setBinContent(eid, itls->_LS, int(iflag),
341  ft->_state);
342  fSumLS+=(*ft);
343  iflag++;
344  }
345  cSummaryvsLS.setBinContent(eid, itls->_LS, fSumLS._state);
346  fSumRun+=fSumLS;
347  }
348 
349  // EVALUATE RUN BASED FLAGS
350  // NOTE, THAT IF THE FED IS NOT @cDAQ fSumRun state will be fNCDAQ
351  if (utilities::isFEDHBHE(eid) || utilities::isFEDHF(eid) ||
352  utilities::isFEDHO(eid))
353  {
354  if (_xDead.get(eid)>0)
355  ffDead._state = flag::fBAD;
356  else
357  ffDead._state = flag::fGOOD;
358  if (utilities::isFEDHF(eid))
359  {
360  if (_xUni.get(eid)>0)
361  ffUniSlotHF._state = flag::fBAD;
362  else
363  ffUniSlotHF._state = flag::fGOOD;
364  }
365  }
366  fSumRun+=ffDead+ffUniSlotHF;
367 
368  // push the summary flag for this FED for the Whole Run
369  sumflags.push_back(fSumRun);
370 
371  // increment fed
372  ifed++;
373  }
374 
375  return sumflags;
376  }
377 }
std::vector< uint32_t > _vcdaqEids
Definition: DQClient.h:64
T getUntrackedParameter(std::string const &, T const &) const
std::vector< LSSummary > _vflagsLS
MonitorElement * _meNumEvents
void setBinContent(int binx, double content)
set content of bin (1-D)
ContainerXXX< uint32_t > _xDigiSize
virtual void setBinContent(HcalDetId const &, int)
Definition: Container2D.cc:235
int const CRATE_VME_MIN
Definition: Constants.h:60
int ib
Definition: cuy.py:660
HcalSubdetector subdet() const
get the subdetector
Definition: HcalDetId.h:49
ContainerXXX< uint32_t > _xUni
virtual double getRMS(HcalDetId const &, int axix=1)
Definition: Container1D.cc:237
void initialize(HcalElectronicsMap const *, ElectronicsMapType etype=fHcalElectronicsMap)
MonitorElement * get(const std::string &path)
Definition: DQMStore.cc:304
std::vector< uint32_t > _vhashFEDs
Definition: DQClient.h:58
virtual void beginRun(edm::Run const &, edm::EventSetup const &)
Definition: DQClient.cc:15
virtual CompactMap::const_iterator begin()
Definition: ContainerXXX.h:75
State _state
Definition: Flag.h:79
std::string _taskname
Definition: DQClient.h:47
int const SPIGOT_MIN
Definition: Constants.h:85
HcalElectronicsMap const * _emap
Definition: DQClient.h:54
virtual void reset()
Definition: ContainerXXX.h:366
filter::HashFilter _filter_FEDHF
void find(edm::Handle< EcalRecHitCollection > &hits, DetId thisDet, std::vector< EcalRecHitCollection::const_iterator > &hit, bool debug=false)
Definition: FindCaloHit.cc:7
int const FIBER_VME_MIN
Definition: Constants.h:90
int const FIBERCH_MIN
Definition: Constants.h:100
virtual void book(DQMStore::IBooker &, std::string subsystem="Hcal", std::string aux="")
virtual CompactMap::const_iterator end()
Definition: ContainerXXX.h:77
virtual void fill(HcalDetId const &)
Definition: Container2D.cc:59
ProcessingType _ptype
Definition: DQModule.h:59
std::vector< uint32_t > _vhashuTCA
filter::HashFilter _filter_uTCA
virtual void setBinContent(int, int, int)
Container2D _cOccupancy_depth
virtual void endLuminosityBlock(DQMStore::IBooker &, DQMStore::IGetter &, edm::LuminosityBlock const &, edm::EventSetup const &)
Definition: DQClient.cc:99
MonitorElement * book1D(Args &&...args)
Definition: DQMStore.h:115
virtual void initialize(std::string const &folder, hashfunctions::HashType, Quantity *, Quantity *, Quantity *qz=new ValueQuantity(quantity::fN), int debug=0)
Definition: Container2D.cc:32
int const FIBER_uTCA_MIN1
Definition: Constants.h:93
ContainerXXX< uint32_t > _xNChsNominal
TH1 * getTH1(void) const
virtual void beginRun(edm::Run const &, edm::EventSetup const &)
virtual void endLuminosityBlock(DQMStore::IBooker &, DQMStore::IGetter &, edm::LuminosityBlock const &, edm::EventSetup const &)
std::vector< HcalGenericDetId > allPrecisionId() const
std::string _name
Definition: DQModule.h:57
std::vector< uint32_t > _vhashFEDHF
std::vector< std::vector< flag::Flag > > _vflags
Definition: DQClient.h:43
virtual double getMean(HcalDetId const &, int axis=1)
Definition: Container1D.cc:232
int const CRATE_uTCA_MIN
Definition: Constants.h:65
std::vector< uint32_t > _vhashVME
DigiRunSummary(std::string const &, std::string const &, edm::ParameterSet const &)
virtual std::vector< flag::Flag > endJob(DQMStore::IBooker &, DQMStore::IGetter &)
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:276
bool isFEDHBHE(HcalElectronicsId const &)
Definition: Utilities.cc:124
virtual void book(DQMStore::IBooker &, HcalElectronicsMap const *, std::string subsystem="Hcal", std::string aux="")
Definition: Container2D.cc:895
virtual void book(HcalElectronicsMap const *)
Definition: ContainerXXX.h:99
virtual void initialize(std::string const &folder, Quantity *, Quantity *, Quantity *qz=new ValueQuantity(quantity::fN), int debug=0)
std::vector< int > _vFEDs
Definition: DQClient.h:57
virtual void load(DQMStore *, HcalElectronicsMap const *, std::string const &subsystem="Hcal", std::string const &aux="", std::string const &prepend="", DQMStore::OpenRunDirs mode=DQMStore::StripRunDirs)
Definition: Container1D.cc:596
int const DIGISIZE[SUBDET_NUM]
Definition: Constants.h:132
ContainerXXX< uint32_t > _xNChs
double getBinContent(int binx) const
get content of bin (1-D)
virtual STDTYPE & get(HcalDetId const &)
Definition: ContainerXXX.h:249
if(dp >Float(M_PI)) dp-
electronicsmap::ElectronicsMap _ehashmap
std::string _subsystem
Definition: DQModule.h:64
bool isFEDHO(HcalElectronicsId const &)
Definition: Utilities.cc:171
volatile std::atomic< bool > shutdown_flag false
virtual void initialize(hashfunctions::HashType, int debug=0)
Definition: ContainerXXX.h:91
virtual void initialize(FilterType ftype, HashType htype, std::vector< uint32_t > const &)
Definition: HashFilter.cc:26
filter::HashFilter _filter_VME
Readout chain identification for Hcal.
bool isFEDHF(HcalElectronicsId const &)
Definition: Utilities.cc:146
ContainerXXX< uint32_t > _xUniHF
int const SLOT_uTCA_MIN
Definition: Constants.h:72
Definition: Run.h:43
virtual double getBinContent(HcalDetId const &)
Definition: Container2D.cc:184
ContainerXXX< uint32_t > _xDead