CMS 3D CMS Logo
BeamMonitor.cc
Go to the documentation of this file.
1 /*
2  * \file BeamMonitor.cc
3  * \author Geng-yuan Jeng/UC Riverside
4  * Francisco Yumiceva/FNAL
5  */
6 
7 /*
8 The code has been modified for running average
9 mode, and it gives results for the last NLS which is
10 configurable.
11 Sushil S. Chauhan /UCDavis
12 Evan Friis /UCDavis
13 The last tag for working versions without this change is
14 V00-03-25
15 */
16 
17 #include "DQM/BeamMonitor/plugins/BeamMonitor.h"
18 #include "DQMServices/Core/interface/DQMStore.h"
19 #include "FWCore/ServiceRegistry/interface/Service.h"
20 #include "DataFormats/TrackCandidate/interface/TrackCandidate.h"
21 #include "DataFormats/TrackCandidate/interface/TrackCandidateCollection.h"
22 #include "DataFormats/Common/interface/View.h"
23 #include "RecoVertex/BeamSpotProducer/interface/BSFitter.h"
24 #include "FWCore/Framework/interface/MakerMacros.h"
25 #include "FWCore/Framework/interface/LuminosityBlock.h"
26 #include "FWCore/Framework/interface/Run.h"
27 #include "FWCore/Framework/interface/ConsumesCollector.h"
28 #include "FWCore/MessageLogger/interface/MessageLogger.h"
29 #include "FWCore/Common/interface/TriggerNames.h"
30 #include "DataFormats/HLTReco/interface/TriggerEvent.h"
31 #include "CondFormats/BeamSpotObjects/interface/BeamSpotOnlineObjects.h"
32 #include "CondCore/DBOutputService/interface/OnlineDBOutputService.h"
33 #include <numeric>
34 #include <cmath>
35 #include <memory>
36 #include <TMath.h>
37 #include <iostream>
38 #include <TStyle.h>
39 #include <ctime>
40 
41 using namespace std;
42 using namespace edm;
43 
44 void BeamMonitor::formatFitTime(char* ts, const time_t& t) {
45  //constexpr int CET(+1);
46  constexpr int CEST(+2);
47 
48  //tm * ptm;
49  //ptm = gmtime ( &t );
50  //int year = ptm->tm_year;
51 
52  //get correct year from ctime
53  time_t currentTime;
54  struct tm* localTime;
55  time(&currentTime); // Get the current time
56  localTime = localtime(&currentTime); // Convert the current time to the local time
57  int year = localTime->tm_year + 1900;
58 
59  tm* ptm;
60  ptm = gmtime(&t);
61 
62  //check if year is ok
63  if (year <= 37)
64  year += 2000;
65  if (year >= 70 && year <= 137)
66  year += 1900;
67 
68  if (year < 1995) {
69  edm::LogError("BadTimeStamp") << "year reported is " << year << " !!" << std::endl;
70  //year = 2015; //overwritten later by BeamFitter.cc for fits but needed here for TH1
71  //edm::LogError("BadTimeStamp") << "Resetting to " <<year<<std::endl;
72  }
73  sprintf(ts,
74  "%4d-%02d-%02d %02d:%02d:%02d",
75  year,
76  ptm->tm_mon + 1,
77  ptm->tm_mday,
78  (ptm->tm_hour + CEST) % 24,
79  ptm->tm_min,
80  ptm->tm_sec);
81 
82 #ifdef STRIP_TRAILING_BLANKS_IN_TIMEZONE
83  unsigned int b = strlen(ts);
84  while (ts[--b] == ' ') {
85  ts[b] = 0;
86  }
87 #endif
88 }
89 
90 static constexpr int buffTime = 23;
91 
92 //
93 // constructors and destructor
94 //
95 BeamMonitor::BeamMonitor(const ParameterSet& ps)
96  : dxBin_(ps.getParameter<int>("dxBin")),
97  dxMin_(ps.getParameter<double>("dxMin")),
98  dxMax_(ps.getParameter<double>("dxMax")),
99 
100  vxBin_(ps.getParameter<int>("vxBin")),
101  vxMin_(ps.getParameter<double>("vxMin")),
102  vxMax_(ps.getParameter<double>("vxMax")),
103 
104  phiBin_(ps.getParameter<int>("phiBin")),
105  phiMin_(ps.getParameter<double>("phiMin")),
106  phiMax_(ps.getParameter<double>("phiMax")),
107 
108  dzBin_(ps.getParameter<int>("dzBin")),
109  dzMin_(ps.getParameter<double>("dzMin")),
110  dzMax_(ps.getParameter<double>("dzMax")),
111 
112  countEvt_(0),
113  countLumi_(0),
114  nthBSTrk_(0),
115  nFitElements_(3),
116  resetHistos_(false),
117  StartAverage_(false),
118  firstAverageFit_(0),
119  countGapLumi_(0) {
120  monitorName_ = ps.getUntrackedParameter<string>("monitorName", "YourSubsystemName");
121  recordName_ = ps.getUntrackedParameter<string>("recordName");
122  bsSrc_ = consumes<reco::BeamSpot>(ps.getUntrackedParameter<InputTag>("beamSpot"));
123  tracksLabel_ = consumes<reco::TrackCollection>(
124  ps.getParameter<ParameterSet>("BeamFitter").getUntrackedParameter<InputTag>("TrackCollection"));
125  pvSrc_ = consumes<reco::VertexCollection>(ps.getUntrackedParameter<InputTag>("primaryVertex"));
126  hltSrc_ = consumes<TriggerResults>(ps.getParameter<InputTag>("hltResults"));
127  intervalInSec_ = ps.getUntrackedParameter<int>("timeInterval", 920); //40 LS X 23"
128  fitNLumi_ = ps.getUntrackedParameter<int>("fitEveryNLumi", -1);
129  resetFitNLumi_ = ps.getUntrackedParameter<int>("resetEveryNLumi", -1);
130  fitPVNLumi_ = ps.getUntrackedParameter<int>("fitPVEveryNLumi", -1);
131  resetPVNLumi_ = ps.getUntrackedParameter<int>("resetPVEveryNLumi", -1);
132  deltaSigCut_ = ps.getUntrackedParameter<double>("deltaSignificanceCut", 15);
133  debug_ = ps.getUntrackedParameter<bool>("Debug");
134  onlineMode_ = ps.getUntrackedParameter<bool>("OnlineMode");
135  jetTrigger_ = ps.getUntrackedParameter<std::vector<std::string> >("jetTrigger");
136  min_Ntrks_ = ps.getParameter<ParameterSet>("BeamFitter").getUntrackedParameter<int>("MinimumInputTracks");
137  maxZ_ = ps.getParameter<ParameterSet>("BeamFitter").getUntrackedParameter<double>("MaximumZ");
138  minNrVertices_ = ps.getParameter<ParameterSet>("PVFitter").getUntrackedParameter<unsigned int>("minNrVerticesForFit");
139  minVtxNdf_ = ps.getParameter<ParameterSet>("PVFitter").getUntrackedParameter<double>("minVertexNdf");
140  minVtxWgt_ = ps.getParameter<ParameterSet>("PVFitter").getUntrackedParameter<double>("minVertexMeanWeight");
141 
142  if (!monitorName_.empty())
143  monitorName_ = monitorName_ + "/";
144 
145  theBeamFitter = std::make_unique<BeamFitter>(ps, consumesCollector());
146  theBeamFitter->resetTrkVector();
147  theBeamFitter->resetLSRange();
148  theBeamFitter->resetRefTime();
149  theBeamFitter->resetPVFitter();
150 
151  if (fitNLumi_ <= 0)
152  fitNLumi_ = 1;
153  nFits_ = beginLumiOfBSFit_ = endLumiOfBSFit_ = beginLumiOfPVFit_ = endLumiOfPVFit_ = 0;
154  refBStime[0] = refBStime[1] = refPVtime[0] = refPVtime[1] = 0;
155  maxZ_ = std::fabs(maxZ_);
156  lastlumi_ = 0;
157  nextlumi_ = 0;
158  processed_ = false;
159 }
160 
161 //--------------------------------------------------------
162 namespace {
163  /*The order of the enums is identical to the order in which
164  MonitorElements are added to hs
165  */
166  enum Hists {
167  k_x0_lumi,
168  k_x0_lumi_all,
169  k_y0_lumi,
170  k_y0_lumi_all,
171  k_z0_lumi,
172  k_z0_lumi_all,
173  k_sigmaX0_lumi,
174  k_sigmaX0_lumi_all,
175  k_sigmaY0_lumi,
176  k_sigmaY0_lumi_all,
177  k_sigmaZ0_lumi,
178  k_sigmaZ0_lumi_all,
179  k_x0_time,
180  k_x0_time_all,
181  k_y0_time,
182  k_y0_time_all,
183  k_z0_time,
184  k_z0_time_all,
185  k_sigmaX0_time,
186  k_sigmaX0_time_all,
187  k_sigmaY0_time,
188  k_sigmaY0_time_all,
189  k_sigmaZ0_time,
190  k_sigmaZ0_time_all,
191  k_PVx_lumi,
192  k_PVx_lumi_all,
193  k_PVy_lumi,
194  k_PVy_lumi_all,
195  k_PVz_lumi,
196  k_PVz_lumi_all,
197  k_PVx_time,
198  k_PVx_time_all,
199  k_PVy_time,
200  k_PVy_time_all,
201  k_PVz_time,
202  k_PVz_time_all,
203  kNumHists
204  };
205 } // namespace
206 
207 void BeamMonitor::bookHistograms(DQMStore::IBooker& iBooker, edm::Run const& iRun, edm::EventSetup const& iSetup) {
208  frun = iRun.run();
209  ftimestamp = iRun.beginTime().value();
210  tmpTime = ftimestamp >> 32;
211  startTime = refTime = tmpTime;
212  char eventTime[64];
213  formatFitTime(eventTime, tmpTime);
214  edm::LogInfo("BeamMonitor") << "TimeOffset = " << eventTime << std::endl;
215  TDatime da(eventTime);
216  if (debug_) {
217  edm::LogInfo("BeamMonitor") << "TimeOffset = ";
218  da.Print();
219  }
220  auto daTime = da.Convert(kTRUE);
221 
222  // book some histograms here
223 
224  // create and cd into new folder
225  iBooker.setCurrentFolder(monitorName_ + "Fit");
226 
227  h_nTrk_lumi = iBooker.book1D("nTrk_lumi", "Num. of selected tracks vs lumi (Fit)", 20, 0.5, 20.5);
228  h_nTrk_lumi->setAxisTitle("Lumisection", 1);
229  h_nTrk_lumi->setAxisTitle("Num of Tracks for Fit", 2);
230 
231  //store vtx vs lumi for monitoring why fits fail
232  h_nVtx_lumi = iBooker.book1D("nVtx_lumi", "Num. of selected Vtx vs lumi (Fit)", 20, 0.5, 20.5);
233  h_nVtx_lumi->setAxisTitle("Lumisection", 1);
234  h_nVtx_lumi->setAxisTitle("Num of Vtx for Fit", 2);
235 
236  h_nVtx_lumi_all = iBooker.book1D("nVtx_lumi_all", "Num. of selected Vtx vs lumi (Fit) all", 20, 0.5, 20.5);
237  h_nVtx_lumi_all->getTH1()->SetCanExtend(TH1::kAllAxes);
238  h_nVtx_lumi_all->setAxisTitle("Lumisection", 1);
239  h_nVtx_lumi_all->setAxisTitle("Num of Vtx for Fit", 2);
240 
241  h_d0_phi0 = iBooker.bookProfile(
242  "d0_phi0", "d_{0} vs. #phi_{0} (Selected Tracks)", phiBin_, phiMin_, phiMax_, dxBin_, dxMin_, dxMax_, "");
243  h_d0_phi0->setAxisTitle("#phi_{0} (rad)", 1);
244  h_d0_phi0->setAxisTitle("d_{0} (cm)", 2);
245 
246  h_vx_vy = iBooker.book2D(
247  "trk_vx_vy", "Vertex (PCA) position of selected tracks", vxBin_, vxMin_, vxMax_, vxBin_, vxMin_, vxMax_);
248  h_vx_vy->setOption("COLZ");
249  // h_vx_vy->getTH1()->SetCanExtend(TH1::kAllAxes);
250  h_vx_vy->setAxisTitle("x coordinate of input track at PCA (cm)", 1);
251  h_vx_vy->setAxisTitle("y coordinate of input track at PCA (cm)", 2);
252 
253  {
254  TDatime* da = new TDatime();
255  gStyle->SetTimeOffset(da->Convert(kTRUE));
256  }
257 
258  const int nvar_ = 6;
259  string coord[nvar_] = {"x", "y", "z", "sigmaX", "sigmaY", "sigmaZ"};
260  string label[nvar_] = {
261  "x_{0} (cm)", "y_{0} (cm)", "z_{0} (cm)", "#sigma_{X_{0}} (cm)", "#sigma_{Y_{0}} (cm)", "#sigma_{Z_{0}} (cm)"};
262 
263  hs.reserve(kNumHists);
264  for (int i = 0; i < 4; i++) {
265  iBooker.setCurrentFolder(monitorName_ + "Fit");
266  for (int ic = 0; ic < nvar_; ++ic) {
267  TString histName(coord[ic]);
268  TString histTitle(coord[ic]);
269  string ytitle(label[ic]);
270  string xtitle("");
271  string options("E1");
272  bool createHisto = true;
273  switch (i) {
274  case 1: // BS vs time
275  histName += "0_time";
276  xtitle = "Time [UTC]";
277  if (ic < 3)
278  histTitle += " coordinate of beam spot vs time (Fit)";
279  else
280  histTitle = histTitle.Insert(5, " ") + " of beam spot vs time (Fit)";
281  break;
282  case 2: // PV vs lumi
283  if (ic < 3) {
284  iBooker.setCurrentFolder(monitorName_ + "PrimaryVertex");
285  histName.Insert(0, "PV");
286  histName += "_lumi";
287  histTitle.Insert(0, "Avg. ");
288  histTitle += " position of primary vtx vs lumi";
289  xtitle = "Lumisection";
290  ytitle.insert(0, "PV");
291  ytitle += " #pm #sigma_{PV";
292  ytitle += coord[ic];
293  ytitle += "} (cm)";
294  } else
295  createHisto = false;
296  break;
297  case 3: // PV vs time
298  if (ic < 3) {
299  iBooker.setCurrentFolder(monitorName_ + "PrimaryVertex");
300  histName.Insert(0, "PV");
301  histName += "_time";
302  histTitle.Insert(0, "Avg. ");
303  histTitle += " position of primary vtx vs time";
304  xtitle = "Time [UTC]";
305  ytitle.insert(0, "PV");
306  ytitle += " #pm #sigma_{PV";
307  ytitle += coord[ic];
308  ytitle += "} (cm)";
309  } else
310  createHisto = false;
311  break;
312  default: // BS vs lumi
313  histName += "0_lumi";
314  xtitle = "Lumisection";
315  if (ic < 3)
316  histTitle += " coordinate of beam spot vs lumi (Fit)";
317  else
318  histTitle = histTitle.Insert(5, " ") + " of beam spot vs lumi (Fit)";
319  break;
320  }
321  if (createHisto) {
322  edm::LogInfo("BeamMonitor") << "hitsName = " << histName << "; histTitle = " << histTitle << std::endl;
323  auto tmpHs = iBooker.book1D(histName, histTitle, 40, 0.5, 40.5);
324  hs.push_back(tmpHs);
325  tmpHs->setAxisTitle(xtitle, 1);
326  tmpHs->setAxisTitle(ytitle, 2);
327  tmpHs->getTH1()->SetOption("E1");
328  if (histName.Contains("time")) {
329  //int nbins = (intervalInSec_/23 > 0 ? intervalInSec_/23 : 40);
330  tmpHs->getTH1()->SetBins(intervalInSec_, 0.5, intervalInSec_ + 0.5);
331  tmpHs->setAxisTimeDisplay(1);
332  tmpHs->setAxisTimeFormat("%H:%M:%S", 1);
333  tmpHs->getTH1()->GetXaxis()->SetTimeOffset(daTime);
334  }
335  histName += "_all";
336  histTitle += " all";
337  tmpHs = iBooker.book1D(histName, histTitle, 40, 0.5, 40.5);
338  hs.push_back(tmpHs);
339  tmpHs->getTH1()->SetCanExtend(TH1::kAllAxes);
340  tmpHs->setAxisTitle(xtitle, 1);
341  tmpHs->setAxisTitle(ytitle, 2);
342  tmpHs->getTH1()->SetOption("E1");
343  if (histName.Contains("time")) {
344  //int nbins = (intervalInSec_/23 > 0 ? intervalInSec_/23 : 40);
345  tmpHs->getTH1()->SetBins(intervalInSec_, 0.5, intervalInSec_ + 0.5);
346  tmpHs->setAxisTimeDisplay(1);
347  tmpHs->setAxisTimeFormat("%H:%M:%S", 1);
348  tmpHs->getTH1()->GetXaxis()->SetTimeOffset(daTime);
349  }
350  }
351  }
352  }
353  assert(hs.size() == kNumHists);
354  assert(0 == strcmp(hs[k_sigmaY0_time]->getTH1()->GetName(), "sigmaY0_time"));
355  assert(0 == strcmp(hs[k_PVz_lumi_all]->getTH1()->GetName(), "PVz_lumi_all"));
356 
357  iBooker.setCurrentFolder(monitorName_ + "Fit");
358 
359  h_trk_z0 = iBooker.book1D("trk_z0", "z_{0} of selected tracks", dzBin_, dzMin_, dzMax_);
360  h_trk_z0->setAxisTitle("z_{0} of selected tracks (cm)", 1);
361 
362  h_vx_dz = iBooker.bookProfile(
363  "vx_dz", "v_{x} vs. dz of selected tracks", dzBin_, dzMin_, dzMax_, dxBin_, dxMin_, dxMax_, "");
364  h_vx_dz->setAxisTitle("dz (cm)", 1);
365  h_vx_dz->setAxisTitle("x coordinate of input track at PCA (cm)", 2);
366 
367  h_vy_dz = iBooker.bookProfile(
368  "vy_dz", "v_{y} vs. dz of selected tracks", dzBin_, dzMin_, dzMax_, dxBin_, dxMin_, dxMax_, "");
369  h_vy_dz->setAxisTitle("dz (cm)", 1);
370  h_vy_dz->setAxisTitle("y coordinate of input track at PCA (cm)", 2);
371 
372  h_x0 = iBooker.book1D("BeamMonitorFeedBack_x0", "x coordinate of beam spot (Fit)", 100, -0.01, 0.01);
373  h_x0->setAxisTitle("x_{0} (cm)", 1);
374  h_x0->getTH1()->SetCanExtend(TH1::kAllAxes);
375 
376  h_y0 = iBooker.book1D("BeamMonitorFeedBack_y0", "y coordinate of beam spot (Fit)", 100, -0.01, 0.01);
377  h_y0->setAxisTitle("y_{0} (cm)", 1);
378  h_y0->getTH1()->SetCanExtend(TH1::kAllAxes);
379 
380  h_z0 = iBooker.book1D("BeamMonitorFeedBack_z0", "z coordinate of beam spot (Fit)", dzBin_, dzMin_, dzMax_);
381  h_z0->setAxisTitle("z_{0} (cm)", 1);
382  h_z0->getTH1()->SetCanExtend(TH1::kAllAxes);
383 
384  h_sigmaX0 = iBooker.book1D("BeamMonitorFeedBack_sigmaX0", "sigma x0 of beam spot (Fit)", 100, 0, 0.05);
385  h_sigmaX0->setAxisTitle("#sigma_{X_{0}} (cm)", 1);
386  h_sigmaX0->getTH1()->SetCanExtend(TH1::kAllAxes);
387 
388  h_sigmaY0 = iBooker.book1D("BeamMonitorFeedBack_sigmaY0", "sigma y0 of beam spot (Fit)", 100, 0, 0.05);
389  h_sigmaY0->setAxisTitle("#sigma_{Y_{0}} (cm)", 1);
390  h_sigmaY0->getTH1()->SetCanExtend(TH1::kAllAxes);
391 
392  h_sigmaZ0 = iBooker.book1D("BeamMonitorFeedBack_sigmaZ0", "sigma z0 of beam spot (Fit)", 100, 0, 10);
393  h_sigmaZ0->setAxisTitle("#sigma_{Z_{0}} (cm)", 1);
394  h_sigmaZ0->getTH1()->SetCanExtend(TH1::kAllAxes);
395 
396  // Histograms of all reco tracks (without cuts):
397  h_trkPt = iBooker.book1D("trkPt", "p_{T} of all reco'd tracks (no selection)", 200, 0., 50.);
398  h_trkPt->setAxisTitle("p_{T} (GeV/c)", 1);
399 
400  h_trkVz = iBooker.book1D("trkVz", "Z coordinate of PCA of all reco'd tracks (no selection)", dzBin_, dzMin_, dzMax_);
401  h_trkVz->setAxisTitle("V_{Z} (cm)", 1);
402 
403  cutFlowTable = iBooker.book1D("cutFlowTable", "Cut flow table of track selection", 9, 0, 9);
404 
405  // Results of previous good fit:
406  fitResults = iBooker.book2D("fitResults", "Results of previous good beam fit", 2, 0, 2, 8, 0, 8);
407  fitResults->setAxisTitle("Fitted Beam Spot (cm)", 1);
408  fitResults->setBinLabel(8, "x_{0}", 2);
409  fitResults->setBinLabel(7, "y_{0}", 2);
410  fitResults->setBinLabel(6, "z_{0}", 2);
411  fitResults->setBinLabel(5, "#sigma_{Z}", 2);
412  fitResults->setBinLabel(4, "#frac{dx}{dz} (rad)", 2);
413  fitResults->setBinLabel(3, "#frac{dy}{dz} (rad)", 2);
414  fitResults->setBinLabel(2, "#sigma_{X}", 2);
415  fitResults->setBinLabel(1, "#sigma_{Y}", 2);
416  fitResults->setBinLabel(1, "Mean", 1);
417  fitResults->setBinLabel(2, "Stat. Error", 1);
418  fitResults->getTH1()->SetOption("text");
419 
420  // Histos of PrimaryVertices:
421  iBooker.setCurrentFolder(monitorName_ + "PrimaryVertex");
422 
423  h_nVtx = iBooker.book1D("vtxNbr", "Reconstructed Vertices(non-fake) in all Event", 60, -0.5, 59.5);
424  h_nVtx->setAxisTitle("Num. of reco. vertices", 1);
425 
426  //For one Trigger only
427  h_nVtx_st = iBooker.book1D("vtxNbr_SelectedTriggers", "Reconstructed Vertices(non-fake) in Events", 60, -0.5, 59.5);
428  //h_nVtx_st->setAxisTitle("Num. of reco. vertices for Un-Prescaled Jet Trigger",1);
429 
430  // Monitor only the PV with highest sum pt of assoc. trks:
431  h_PVx[0] = iBooker.book1D("PVX", "x coordinate of Primary Vtx", 50, -0.01, 0.01);
432  h_PVx[0]->setAxisTitle("PVx (cm)", 1);
433  h_PVx[0]->getTH1()->SetCanExtend(TH1::kAllAxes);
434 
435  h_PVy[0] = iBooker.book1D("PVY", "y coordinate of Primary Vtx", 50, -0.01, 0.01);
436  h_PVy[0]->setAxisTitle("PVy (cm)", 1);
437  h_PVy[0]->getTH1()->SetCanExtend(TH1::kAllAxes);
438 
439  h_PVz[0] = iBooker.book1D("PVZ", "z coordinate of Primary Vtx", dzBin_, dzMin_, dzMax_);
440  h_PVz[0]->setAxisTitle("PVz (cm)", 1);
441 
442  h_PVx[1] = iBooker.book1D("PVXFit", "x coordinate of Primary Vtx (Last Fit)", 50, -0.01, 0.01);
443  h_PVx[1]->setAxisTitle("PVx (cm)", 1);
444  h_PVx[1]->getTH1()->SetCanExtend(TH1::kAllAxes);
445 
446  h_PVy[1] = iBooker.book1D("PVYFit", "y coordinate of Primary Vtx (Last Fit)", 50, -0.01, 0.01);
447  h_PVy[1]->setAxisTitle("PVy (cm)", 1);
448  h_PVy[1]->getTH1()->SetCanExtend(TH1::kAllAxes);
449 
450  h_PVz[1] = iBooker.book1D("PVZFit", "z coordinate of Primary Vtx (Last Fit)", dzBin_, dzMin_, dzMax_);
451  h_PVz[1]->setAxisTitle("PVz (cm)", 1);
452 
453  h_PVxz = iBooker.bookProfile("PVxz", "PVx vs. PVz", dzBin_ / 2, dzMin_, dzMax_, dxBin_ / 2, dxMin_, dxMax_, "");
454  h_PVxz->setAxisTitle("PVz (cm)", 1);
455  h_PVxz->setAxisTitle("PVx (cm)", 2);
456 
457  h_PVyz = iBooker.bookProfile("PVyz", "PVy vs. PVz", dzBin_ / 2, dzMin_, dzMax_, dxBin_ / 2, dxMin_, dxMax_, "");
458  h_PVyz->setAxisTitle("PVz (cm)", 1);
459  h_PVyz->setAxisTitle("PVy (cm)", 2);
460 
461  // Results of previous good fit:
462  pvResults = iBooker.book2D("pvResults", "Results of fitting Primary Vertices", 2, 0, 2, 6, 0, 6);
463  pvResults->setAxisTitle("Fitted Primary Vertex (cm)", 1);
464  pvResults->setBinLabel(6, "PVx", 2);
465  pvResults->setBinLabel(5, "PVy", 2);
466  pvResults->setBinLabel(4, "PVz", 2);
467  pvResults->setBinLabel(3, "#sigma_{X}", 2);
468  pvResults->setBinLabel(2, "#sigma_{Y}", 2);
469  pvResults->setBinLabel(1, "#sigma_{Z}", 2);
470  pvResults->setBinLabel(1, "Mean", 1);
471  pvResults->setBinLabel(2, "Stat. Error", 1);
472  pvResults->getTH1()->SetOption("text");
473 
474  // Summary plots:
475  iBooker.setCurrentFolder(monitorName_ + "EventInfo");
476 
477  reportSummary = iBooker.bookFloat("reportSummary");
478  if (reportSummary)
479  reportSummary->Fill(std::numeric_limits<double>::quiet_NaN());
480 
481  char histo[20];
482  iBooker.setCurrentFolder(monitorName_ + "EventInfo/reportSummaryContents");
483  for (int n = 0; n < nFitElements_; n++) {
484  switch (n) {
485  case 0:
486  sprintf(histo, "x0_status");
487  break;
488  case 1:
489  sprintf(histo, "y0_status");
490  break;
491  case 2:
492  sprintf(histo, "z0_status");
493  break;
494  }
495  reportSummaryContents[n] = iBooker.bookFloat(histo);
496  }
497 
498  for (int i = 0; i < nFitElements_; i++) {
499  summaryContent_[i] = 0.;
500  reportSummaryContents[i]->Fill(std::numeric_limits<double>::quiet_NaN());
501  }
502 
503  iBooker.setCurrentFolder(monitorName_ + "EventInfo");
504 
505  reportSummaryMap = iBooker.book2D("reportSummaryMap", "Beam Spot Summary Map", 1, 0, 1, 3, 0, 3);
506  reportSummaryMap->setAxisTitle("", 1);
507  reportSummaryMap->setAxisTitle("Fitted Beam Spot", 2);
508  reportSummaryMap->setBinLabel(1, " ", 1);
509  reportSummaryMap->setBinLabel(1, "x_{0}", 2);
510  reportSummaryMap->setBinLabel(2, "y_{0}", 2);
511  reportSummaryMap->setBinLabel(3, "z_{0}", 2);
512  for (int i = 0; i < nFitElements_; i++) {
513  reportSummaryMap->setBinContent(1, i + 1, -1.);
514  }
515 }
516 
517 //--------------------------------------------------------
518 void BeamMonitor::beginLuminosityBlock(const LuminosityBlock& lumiSeg, const EventSetup& context) {
519  int nthlumi = lumiSeg.luminosityBlock();
520  const edm::TimeValue_t fbegintimestamp = lumiSeg.beginTime().value();
521  const std::time_t ftmptime = fbegintimestamp >> 32;
522 
523  if (countLumi_ == 0 && (!processed_)) {
524  beginLumiOfBSFit_ = beginLumiOfPVFit_ = nthlumi;
525  refBStime[0] = refPVtime[0] = ftmptime;
526  mapBeginBSLS[countLumi_] = nthlumi;
527  mapBeginPVLS[countLumi_] = nthlumi;
528  mapBeginBSTime[countLumi_] = ftmptime;
529  mapBeginPVTime[countLumi_] = ftmptime;
530  } //for the first record
531 
532  if (nthlumi > nextlumi_) {
533  if (processed_) {
534  countLumi_++;
535  //store here them will need when we remove the first one of Last N LS
536  mapBeginBSLS[countLumi_] = nthlumi;
537  mapBeginPVLS[countLumi_] = nthlumi;
538  mapBeginBSTime[countLumi_] = ftmptime;
539  mapBeginPVTime[countLumi_] = ftmptime;
540  } //processed passed but not the first lumi
541  if ((!processed_) && countLumi_ != 0) {
542  mapBeginBSLS[countLumi_] = nthlumi;
543  mapBeginPVLS[countLumi_] = nthlumi;
544  mapBeginBSTime[countLumi_] = ftmptime;
545  mapBeginPVTime[countLumi_] = ftmptime;
546  } //processed fails for last lumi
547  } //nthLumi > nextlumi
548 
549  if (StartAverage_) {
550  //Just Make sure it get rest
551  refBStime[0] = 0;
552  refPVtime[0] = 0;
553  beginLumiOfPVFit_ = 0;
554  beginLumiOfBSFit_ = 0;
555 
556  if (debug_)
557  edm::LogInfo("BeamMonitor") << " beginLuminosityBlock: Size of mapBeginBSLS before = " << mapBeginBSLS.size()
558  << endl;
559  if (nthlumi >
560  nextlumi_) { //this make sure that it does not take into account this lumi for fitting and only look forward for new lumi
561  //as countLumi also remains the same so map value get overwritten once return to normal running.
562  //even if few LS are misssing and DQM module do not sees them then it catchs up again
563  map<int, int>::iterator itbs = mapBeginBSLS.begin();
564  map<int, int>::iterator itpv = mapBeginPVLS.begin();
565  map<int, std::time_t>::iterator itbstime = mapBeginBSTime.begin();
566  map<int, std::time_t>::iterator itpvtime = mapBeginPVTime.begin();
567 
568  if (processed_) { // otherwise if false then LS range of fit get messed up because we don't remove trk/pvs but we remove LS begin value . This prevent it as it happened if LS is there but no event are processed for some reason
569  mapBeginBSLS.erase(itbs);
570  mapBeginPVLS.erase(itpv);
571  mapBeginBSTime.erase(itbstime);
572  mapBeginPVTime.erase(itpvtime);
573  }
574  /*//not sure if want this or not ??
575  map<int, int>::iterator itgapb=mapBeginBSLS.begin();
576  map<int, int>::iterator itgape=mapBeginBSLS.end(); itgape--;
577  countGapLumi_ = ( (itgape->second) - (itgapb->second) );
578  //if we see Gap more than then 2*resetNFitLumi !!!!!!!
579  //for example if 10-15 is fitted and if 16-25 are missing then we next fit will be for range 11-26 but BS can change in between
580  // so better start as fresh and reset everything like starting in the begining!
581  if(countGapLumi_ >= 2*resetFitNLumi_){RestartFitting(); mapBeginBSLS[countLumi_] = nthlumi;}
582  */
583  }
584 
585  if (debug_)
586  edm::LogInfo("BeamMonitor") << " beginLuminosityBlock:: Size of mapBeginBSLS After = " << mapBeginBSLS.size()
587  << endl;
588 
589  map<int, int>::iterator bbs = mapBeginBSLS.begin();
590  map<int, int>::iterator bpv = mapBeginPVLS.begin();
591  map<int, std::time_t>::iterator bbst = mapBeginBSTime.begin();
592  map<int, std::time_t>::iterator bpvt = mapBeginPVTime.begin();
593 
594  if (beginLumiOfPVFit_ == 0)
595  beginLumiOfPVFit_ = bpv->second; //new begin time after removing the LS
596  if (beginLumiOfBSFit_ == 0)
597  beginLumiOfBSFit_ = bbs->second;
598  if (refBStime[0] == 0)
599  refBStime[0] = bbst->second;
600  if (refPVtime[0] == 0)
601  refPVtime[0] = bpvt->second;
602 
603  } //same logic for average fit as above commented line
604 
605  map<int, std::time_t>::iterator nbbst = mapBeginBSTime.begin();
606  map<int, std::time_t>::iterator nbpvt = mapBeginPVTime.begin();
607 
608  if (onlineMode_ && (nthlumi < nextlumi_))
609  return;
610 
611  if (onlineMode_) {
612  if (nthlumi > nextlumi_) {
613  if (countLumi_ != 0 && processed_)
614  FitAndFill(lumiSeg, lastlumi_, nextlumi_, nthlumi);
615  nextlumi_ = nthlumi;
616  edm::LogInfo("BeamMonitor") << "beginLuminosityBlock:: Next Lumi to Fit: " << nextlumi_ << endl;
617  if ((StartAverage_) && refBStime[0] == 0)
618  refBStime[0] = nbbst->second;
619  if ((StartAverage_) && refPVtime[0] == 0)
620  refPVtime[0] = nbpvt->second;
621  }
622  } else {
623  if (processed_)
624  FitAndFill(lumiSeg, lastlumi_, nextlumi_, nthlumi);
625  nextlumi_ = nthlumi;
626  edm::LogInfo("BeamMonitor") << " beginLuminosityBlock:: Next Lumi to Fit: " << nextlumi_ << endl;
627  if ((StartAverage_) && refBStime[0] == 0)
628  refBStime[0] = nbbst->second;
629  if ((StartAverage_) && refPVtime[0] == 0)
630  refPVtime[0] = nbpvt->second;
631  }
632 
633  //countLumi_++;
634  if (processed_)
635  processed_ = false;
636  edm::LogInfo("BeamMonitor") << " beginLuminosityBlock:: Begin of Lumi: " << nthlumi << endl;
637 }
638 
639 // ----------------------------------------------------------
640 void BeamMonitor::analyze(const Event& iEvent, const EventSetup& iSetup) {
641  const int nthlumi = iEvent.luminosityBlock();
642  if (onlineMode_ && (nthlumi < nextlumi_)) {
643  edm::LogInfo("BeamMonitor") << "analyze:: Spilt event from previous lumi section!" << std::endl;
644  return;
645  }
646  if (onlineMode_ && (nthlumi > nextlumi_)) {
647  edm::LogInfo("BeamMonitor") << "analyze:: Spilt event from next lumi section!!!" << std::endl;
648  return;
649  }
650 
651  countEvt_++;
652  theBeamFitter->readEvent(
653  iEvent); //Remember when track fitter read the event in the same place the PVFitter read the events !!!!!!!!!
654 
655  Handle<reco::BeamSpot> recoBeamSpotHandle;
656  iEvent.getByToken(bsSrc_, recoBeamSpotHandle);
657  refBS = *recoBeamSpotHandle;
658 
659  //------Cut Flow Table filled every event!--------------------------------------
660  {
661  // Make a copy of the cut flow table from the beam fitter.
662  auto tmphisto = static_cast<TH1F*>(theBeamFitter->getCutFlow());
663  cutFlowTable->getTH1()->SetBins(
664  tmphisto->GetNbinsX(), tmphisto->GetXaxis()->GetXmin(), tmphisto->GetXaxis()->GetXmax());
665  // Update the bin labels
666  if (countEvt_ == 1) // SetLabel just once
667  for (int n = 0; n < tmphisto->GetNbinsX(); n++)
668  cutFlowTable->setBinLabel(n + 1, tmphisto->GetXaxis()->GetBinLabel(n + 1), 1);
669  cutFlowTable->Reset();
670  cutFlowTable->getTH1()->Add(tmphisto);
671  }
672 
673  //----Reco tracks -------------------------------------
674  Handle<reco::TrackCollection> TrackCollection;
675  iEvent.getByToken(tracksLabel_, TrackCollection);
676  const reco::TrackCollection* tracks = TrackCollection.product();
677  for (reco::TrackCollection::const_iterator track = tracks->begin(); track != tracks->end(); ++track) {
678  h_trkPt->Fill(track->pt()); //no need to change here for average bs
679  h_trkVz->Fill(track->vz());
680  }
681 
682  //-------HLT Trigger --------------------------------
683  edm::Handle<TriggerResults> triggerResults;
684  bool JetTrigPass = false;
685  if (iEvent.getByToken(hltSrc_, triggerResults)) {
686  const edm::TriggerNames& trigNames = iEvent.triggerNames(*triggerResults);
687  for (unsigned int i = 0; i < triggerResults->size(); i++) {
688  const std::string& trigName = trigNames.triggerName(i);
689 
690  if (JetTrigPass)
691  continue;
692 
693  for (size_t t = 0; t < jetTrigger_.size(); ++t) {
694  if (JetTrigPass)
695  continue;
696 
697  string string_search(jetTrigger_[t]);
698  size_t found = trigName.find(string_search);
699 
700  if (found != string::npos) {
701  int thisTrigger_ = trigNames.triggerIndex(trigName);
702  if (triggerResults->accept(thisTrigger_))
703  JetTrigPass = true;
704  } //if trigger found
705  } //for(t=0;..)
706  } //for(i=0; ..)
707  } //if trigger colleciton exist)
708 
709  //------ Primary Vertices-------
710  edm::Handle<reco::VertexCollection> PVCollection;
711 
712  if (iEvent.getByToken(pvSrc_, PVCollection)) {
713  int nPVcount = 0;
714  int nPVcount_ST = 0; //For Single Trigger(hence ST)
715 
716  for (reco::VertexCollection::const_iterator pv = PVCollection->begin(); pv != PVCollection->end(); ++pv) {
717  //--- vertex selection
718  if (pv->isFake() || pv->tracksSize() == 0)
719  continue;
720  nPVcount++; // count non fake pv:
721 
722  if (JetTrigPass)
723  nPVcount_ST++; //non-fake pv with a specific trigger
724 
725  if (pv->ndof() < minVtxNdf_ || (pv->ndof() + 3.) / pv->tracksSize() < 2 * minVtxWgt_)
726  continue;
727 
728  //Fill this map to store xyx for pv so that later we can remove the first one for run aver
729  mapPVx[countLumi_].push_back(pv->x());
730  mapPVy[countLumi_].push_back(pv->y());
731  mapPVz[countLumi_].push_back(pv->z());
732 
733  if (!StartAverage_) { //for first N LS
734  h_PVx[0]->Fill(pv->x());
735  h_PVy[0]->Fill(pv->y());
736  h_PVz[0]->Fill(pv->z());
737  h_PVxz->Fill(pv->z(), pv->x());
738  h_PVyz->Fill(pv->z(), pv->y());
739  } //for first N LiS
740  else {
741  h_PVxz->Fill(pv->z(), pv->x());
742  h_PVyz->Fill(pv->z(), pv->y());
743  }
744 
745  } //loop over pvs
746 
747  h_nVtx->Fill(nPVcount * 1.); //no need to change it for average BS
748 
749  mapNPV[countLumi_].push_back((nPVcount_ST));
750 
751  if (!StartAverage_) {
752  h_nVtx_st->Fill(nPVcount_ST * 1.);
753  }
754 
755  } //if pv collection is availaable
756 
757  if (StartAverage_) {
758  map<int, std::vector<float> >::iterator itpvx = mapPVx.begin();
759  map<int, std::vector<float> >::iterator itpvy = mapPVy.begin();
760  map<int, std::vector<float> >::iterator itpvz = mapPVz.begin();
761 
762  map<int, std::vector<int> >::iterator itbspvinfo = mapNPV.begin();
763 
764  if ((int)mapPVx.size() > resetFitNLumi_) { //sometimes the events is not there but LS is there!
765  mapPVx.erase(itpvx);
766  mapPVy.erase(itpvy);
767  mapPVz.erase(itpvz);
768  mapNPV.erase(itbspvinfo);
769  } //loop over Last N lumi collected
770 
771  } //StartAverage==true
772 
773  processed_ = true;
774 }
775 
776 //--------------------------------------------------------
777 void BeamMonitor::endLuminosityBlock(const LuminosityBlock& lumiSeg, const EventSetup& iSetup) {
778  int nthlumi = lumiSeg.id().luminosityBlock();
779  edm::LogInfo("BeamMonitor") << "endLuminosityBlock:: Lumi of the last event before endLuminosityBlock: " << nthlumi
780  << endl;
781 
782  if (onlineMode_ && nthlumi < nextlumi_)
783  return;
784  const edm::TimeValue_t fendtimestamp = lumiSeg.endTime().value();
785  const std::time_t fendtime = fendtimestamp >> 32;
786  tmpTime = refBStime[1] = refPVtime[1] = fendtime;
787 }
788 
789 //--------------------------------------------------------
790 void BeamMonitor::FitAndFill(const LuminosityBlock& lumiSeg, int& lastlumi, int& nextlumi, int& nthlumi) {
791  if (onlineMode_ && (nthlumi <= nextlumi))
792  return;
793 
794  //set the correct run number when no event in the LS for fake output
795  if ((processed_) && theBeamFitter->getRunNumber() != frun)
796  theBeamFitter->setRun(frun);
797 
798  int currentlumi = nextlumi;
799  edm::LogInfo("BeamMonitor") << "FitAndFill:: Lumi of the current fit: " << currentlumi << endl;
800  lastlumi = currentlumi;
801  endLumiOfBSFit_ = currentlumi;
802  endLumiOfPVFit_ = currentlumi;
803 
804  //---------Fix for Runninv average-------------
805  mapLSPVStoreSize[countLumi_] = theBeamFitter->getPVvectorSize();
806 
807  if (StartAverage_) {
808  std::map<int, std::size_t>::iterator rmLSPVi = mapLSPVStoreSize.begin();
809  size_t SizeToRemovePV = rmLSPVi->second;
810  for (std::map<int, std::size_t>::iterator rmLSPVe = mapLSPVStoreSize.end(); ++rmLSPVi != rmLSPVe;)
811  rmLSPVi->second -= SizeToRemovePV;
812 
813  theBeamFitter->resizePVvector(SizeToRemovePV);
814 
815  map<int, std::size_t>::iterator tmpItpv = mapLSPVStoreSize.begin();
816  mapLSPVStoreSize.erase(tmpItpv);
817  }
818  if (debug_)
819  edm::LogInfo("BeamMonitor") << "FitAndFill:: Size of thePVvector After removing the PVs = "
820  << theBeamFitter->getPVvectorSize() << endl;
821 
822  //lets filt the PV for GUI here: It was in analyzer in preivous versiton but moved here due to absence of event in some lumis, works OK
823  bool resetHistoFlag_ = false;
824  if ((int)mapPVx.size() >= resetFitNLumi_ && (StartAverage_)) {
825  h_PVx[0]->Reset();
826  h_PVy[0]->Reset();
827  h_PVz[0]->Reset();
828  h_nVtx_st->Reset();
829  resetHistoFlag_ = true;
830  }
831 
832  int MaxPVs = 0;
833  int countEvtLastNLS_ = 0;
834  int countTotPV_ = 0;
835 
836  std::map<int, std::vector<int> >::iterator mnpv = mapNPV.begin();
837  std::map<int, std::vector<float> >::iterator mpv2 = mapPVy.begin();
838  std::map<int, std::vector<float> >::iterator mpv3 = mapPVz.begin();
839 
840  for (std::map<int, std::vector<float> >::iterator mpv1 = mapPVx.begin(); mpv1 != mapPVx.end();
841  ++mpv1, ++mpv2, ++mpv3, ++mnpv) {
842  std::vector<float>::iterator mpvs2 = (mpv2->second).begin();
843  std::vector<float>::iterator mpvs3 = (mpv3->second).begin();
844  for (std::vector<float>::iterator mpvs1 = (mpv1->second).begin(); mpvs1 != (mpv1->second).end();
845  ++mpvs1, ++mpvs2, ++mpvs3) {
846  if (resetHistoFlag_) {
847  h_PVx[0]->Fill(*mpvs1); //these histogram are reset after StartAverage_ flag is ON
848  h_PVy[0]->Fill(*mpvs2);
849  h_PVz[0]->Fill(*mpvs3);
850  }
851  } //loop over second
852 
853  //Do the same here for nPV distr.
854  for (std::vector<int>::iterator mnpvs = (mnpv->second).begin(); mnpvs != (mnpv->second).end(); ++mnpvs) {
855  if ((*mnpvs > 0) && (resetHistoFlag_))
856  h_nVtx_st->Fill((*mnpvs) * (1.0));
857  countEvtLastNLS_++;
858  countTotPV_ += (*mnpvs);
859  if ((*mnpvs) > MaxPVs)
860  MaxPVs = (*mnpvs);
861  } //loop over second of mapNPV
862 
863  } //loop over last N lumis
864 
865  char tmpTitlePV[100];
866  sprintf(tmpTitlePV, "%s %i %s %i", "Num. of reco. vertices for LS: ", beginLumiOfPVFit_, " to ", endLumiOfPVFit_);
867  h_nVtx_st->setAxisTitle(tmpTitlePV, 1);
868 
869  std::vector<float> DipPVInfo_;
870  DipPVInfo_.clear();
871 
872  if (countTotPV_ != 0) {
873  DipPVInfo_.push_back((float)countEvtLastNLS_);
874  DipPVInfo_.push_back(h_nVtx_st->getMean());
875  DipPVInfo_.push_back(h_nVtx_st->getMeanError());
876  DipPVInfo_.push_back(h_nVtx_st->getRMS());
877  DipPVInfo_.push_back(h_nVtx_st->getRMSError());
878  DipPVInfo_.push_back((float)MaxPVs);
879  DipPVInfo_.push_back((float)countTotPV_);
880  MaxPVs = 0;
881  } else {
882  for (size_t i = 0; i < 7; i++) {
883  if (i > 0) {
884  DipPVInfo_.push_back(0.);
885  } else {
886  DipPVInfo_.push_back((float)countEvtLastNLS_);
887  }
888  }
889  }
890  theBeamFitter->SetPVInfo(DipPVInfo_);
891  countEvtLastNLS_ = 0;
892 
893  if (onlineMode_) { // filling LS gap
894  // FIXME: need to add protection for the case if the gap is at the resetting LS!
895  const int countLS_bs = hs[k_x0_lumi]->getTH1()->GetEntries();
896  const int countLS_pv = hs[k_PVx_lumi]->getTH1()->GetEntries();
897  edm::LogInfo("BeamMonitor") << "FitAndFill:: countLS_bs = " << countLS_bs << " ; countLS_pv = " << countLS_pv
898  << std::endl;
899  int LSgap_bs = currentlumi / fitNLumi_ - countLS_bs;
900  int LSgap_pv = currentlumi / fitPVNLumi_ - countLS_pv;
901  if (currentlumi % fitNLumi_ == 0)
902  LSgap_bs--;
903  if (currentlumi % fitPVNLumi_ == 0)
904  LSgap_pv--;
905  edm::LogInfo("BeamMonitor") << "FitAndFill:: LSgap_bs = " << LSgap_bs << " ; LSgap_pv = " << LSgap_pv << std::endl;
906  // filling previous fits if LS gap ever exists
907  for (int ig = 0; ig < LSgap_bs; ig++) {
908  hs[k_x0_lumi]->ShiftFillLast(0., 0., fitNLumi_); //x0 , x0err, fitNLumi_; see DQMCore....
909  hs[k_y0_lumi]->ShiftFillLast(0., 0., fitNLumi_);
910  hs[k_z0_lumi]->ShiftFillLast(0., 0., fitNLumi_);
911  hs[k_sigmaX0_lumi]->ShiftFillLast(0., 0., fitNLumi_);
912  hs[k_sigmaY0_lumi]->ShiftFillLast(0., 0., fitNLumi_);
913  hs[k_sigmaZ0_lumi]->ShiftFillLast(0., 0., fitNLumi_);
914  h_nVtx_lumi->ShiftFillLast(0., 0., fitNLumi_);
915  }
916  for (int ig = 0; ig < LSgap_pv; ig++) {
917  hs[k_PVx_lumi]->ShiftFillLast(0., 0., fitPVNLumi_);
918  hs[k_PVy_lumi]->ShiftFillLast(0., 0., fitPVNLumi_);
919  hs[k_PVz_lumi]->ShiftFillLast(0., 0., fitPVNLumi_);
920  }
921  const int previousLS = h_nTrk_lumi->getTH1()->GetEntries();
922  for (int i = 1; i < (currentlumi - previousLS);
923  i++) //if (current-previoius)= 1 then never go inside the for loop!!!!!!!!!!!
924  h_nTrk_lumi->ShiftFillLast(nthBSTrk_);
925  }
926 
927  edm::LogInfo("BeamMonitor") << "FitAndFill:: Time lapsed since last scroll = " << tmpTime - refTime << std::endl;
928 
929  if (testScroll(tmpTime, refTime)) {
930  scrollTH1(hs[k_x0_time]->getTH1(), refTime);
931  scrollTH1(hs[k_y0_time]->getTH1(), refTime);
932  scrollTH1(hs[k_z0_time]->getTH1(), refTime);
933  scrollTH1(hs[k_sigmaX0_time]->getTH1(), refTime);
934  scrollTH1(hs[k_sigmaY0_time]->getTH1(), refTime);
935  scrollTH1(hs[k_sigmaZ0_time]->getTH1(), refTime);
936  scrollTH1(hs[k_PVx_time]->getTH1(), refTime);
937  scrollTH1(hs[k_PVy_time]->getTH1(), refTime);
938  scrollTH1(hs[k_PVz_time]->getTH1(), refTime);
939  }
940 
941  bool doPVFit = false;
942 
943  if (fitPVNLumi_ > 0) {
944  if (onlineMode_) {
945  if (currentlumi % fitPVNLumi_ == 0)
946  doPVFit = true;
947  } else if (countLumi_ % fitPVNLumi_ == 0)
948  doPVFit = true;
949  } else
950  doPVFit = true;
951 
952  if (doPVFit) {
953  edm::LogInfo("BeamMonitor") << "FitAndFill:: Do PV Fitting for LS = " << beginLumiOfPVFit_ << " to "
954  << endLumiOfPVFit_ << std::endl;
955  // Primary Vertex Fit:
956  if (h_PVx[0]->getTH1()->GetEntries() > minNrVertices_) {
957  pvResults->Reset();
958  char tmpTitle[50];
959  sprintf(
960  tmpTitle, "%s %i %s %i", "Fitted Primary Vertex (cm) of LS: ", beginLumiOfPVFit_, " to ", endLumiOfPVFit_);
961  pvResults->setAxisTitle(tmpTitle, 1);
962 
963  std::unique_ptr<TF1> fgaus{new TF1("fgaus", "gaus")};
964  double mean, width, meanErr, widthErr;
965  fgaus->SetLineColor(4);
966  h_PVx[0]->getTH1()->Fit(fgaus.get(), "QLM0");
967  mean = fgaus->GetParameter(1);
968  width = fgaus->GetParameter(2);
969  meanErr = fgaus->GetParError(1);
970  widthErr = fgaus->GetParError(2);
971 
972  hs[k_PVx_lumi]->ShiftFillLast(mean, width, fitPVNLumi_);
973  hs[k_PVx_lumi_all]->setBinContent(currentlumi, mean);
974  hs[k_PVx_lumi_all]->setBinError(currentlumi, width);
975  int nthBin = tmpTime - refTime;
976  if (nthBin < 0)
977  edm::LogInfo("BeamMonitor") << "FitAndFill:: Event time outside current range of time histograms!"
978  << std::endl;
979  if (nthBin > 0) {
980  hs[k_PVx_time]->setBinContent(nthBin, mean);
981  hs[k_PVx_time]->setBinError(nthBin, width);
982  }
983  int jthBin = tmpTime - startTime;
984  if (jthBin > 0) {
985  hs[k_PVx_time_all]->setBinContent(jthBin, mean);
986  hs[k_PVx_time_all]->setBinError(jthBin, width);
987  }
988  pvResults->setBinContent(1, 6, mean);
989  pvResults->setBinContent(1, 3, width);
990  pvResults->setBinContent(2, 6, meanErr);
991  pvResults->setBinContent(2, 3, widthErr);
992 
993  {
994  // snap shot of the fit
995  auto tmphisto = h_PVx[0]->getTH1F();
996  h_PVx[1]->getTH1()->SetBins(
997  tmphisto->GetNbinsX(), tmphisto->GetXaxis()->GetXmin(), tmphisto->GetXaxis()->GetXmax());
998  h_PVx[1]->Reset();
999  h_PVx[1]->getTH1()->Add(tmphisto);
1000  h_PVx[1]->getTH1()->Fit(fgaus.get(), "QLM");
1001  }
1002 
1003  h_PVy[0]->getTH1()->Fit(fgaus.get(), "QLM0");
1004  mean = fgaus->GetParameter(1);
1005  width = fgaus->GetParameter(2);
1006  meanErr = fgaus->GetParError(1);
1007  widthErr = fgaus->GetParError(2);
1008  hs[k_PVy_lumi]->ShiftFillLast(mean, width, fitPVNLumi_);
1009  hs[k_PVy_lumi_all]->setBinContent(currentlumi, mean);
1010  hs[k_PVy_lumi_all]->setBinError(currentlumi, width);
1011  if (nthBin > 0) {
1012  hs[k_PVy_time]->setBinContent(nthBin, mean);
1013  hs[k_PVy_time]->setBinError(nthBin, width);
1014  }
1015  if (jthBin > 0) {
1016  hs[k_PVy_time_all]->setBinContent(jthBin, mean);
1017  hs[k_PVy_time_all]->setBinError(jthBin, width);
1018  }
1019  pvResults->setBinContent(1, 5, mean);
1020  pvResults->setBinContent(1, 2, width);
1021  pvResults->setBinContent(2, 5, meanErr);
1022  pvResults->setBinContent(2, 2, widthErr);
1023  // snap shot of the fit
1024  {
1025  auto tmphisto = h_PVy[0]->getTH1F();
1026  h_PVy[1]->getTH1()->SetBins(
1027  tmphisto->GetNbinsX(), tmphisto->GetXaxis()->GetXmin(), tmphisto->GetXaxis()->GetXmax());
1028  h_PVy[1]->Reset();
1029  h_PVy[1]->getTH1()->Add(tmphisto);
1030  h_PVy[1]->getTH1()->Fit(fgaus.get(), "QLM");
1031  }
1032 
1033  h_PVz[0]->getTH1()->Fit(fgaus.get(), "QLM0");
1034  mean = fgaus->GetParameter(1);
1035  width = fgaus->GetParameter(2);
1036  meanErr = fgaus->GetParError(1);
1037  widthErr = fgaus->GetParError(2);
1038  hs[k_PVz_lumi]->ShiftFillLast(mean, width, fitPVNLumi_);
1039  hs[k_PVz_lumi_all]->setBinContent(currentlumi, mean);
1040  hs[k_PVz_lumi_all]->setBinError(currentlumi, width);
1041  if (nthBin > 0) {
1042  hs[k_PVz_time]->setBinContent(nthBin, mean);
1043  hs[k_PVz_time]->setBinError(nthBin, width);
1044  }
1045  if (jthBin > 0) {
1046  hs[k_PVz_time_all]->setBinContent(jthBin, mean);
1047  hs[k_PVz_time_all]->setBinError(jthBin, width);
1048  }
1049  pvResults->setBinContent(1, 4, mean);
1050  pvResults->setBinContent(1, 1, width);
1051  pvResults->setBinContent(2, 4, meanErr);
1052  pvResults->setBinContent(2, 1, widthErr);
1053  {
1054  // snap shot of the fit
1055  auto tmphisto = h_PVz[0]->getTH1F();
1056  h_PVz[1]->getTH1()->SetBins(
1057  tmphisto->GetNbinsX(), tmphisto->GetXaxis()->GetXmin(), tmphisto->GetXaxis()->GetXmax());
1058  h_PVz[1]->Reset();
1059  h_PVz[1]->getTH1()->Add(tmphisto);
1060  h_PVz[1]->getTH1()->Fit(fgaus.get(), "QLM");
1061  }
1062  } //check if found min Vertices
1063  } //do PVfit
1064 
1065  if ((resetPVNLumi_ > 0 && countLumi_ == resetPVNLumi_) || StartAverage_) {
1066  beginLumiOfPVFit_ = 0;
1067  refPVtime[0] = 0;
1068  }
1069 
1070  //---------Readjustment of theBSvector, RefTime, beginLSofFit---------
1071  vector<BSTrkParameters> theBSvector1 = theBeamFitter->getBSvector();
1072  mapLSBSTrkSize[countLumi_] = (theBSvector1.size());
1073  size_t PreviousRecords = 0; //needed to fill nth record of tracks in GUI
1074 
1075  if (StartAverage_) {
1076  size_t SizeToRemove = 0;
1077  std::map<int, std::size_t>::iterator rmls = mapLSBSTrkSize.begin();
1078  SizeToRemove = rmls->second;
1079  if (debug_)
1080  edm::LogInfo("BeamMonitor") << " The size to remove is = " << SizeToRemove << endl;
1081  int changedAfterThis = 0;
1082  for (std::map<int, std::size_t>::iterator rmLS = mapLSBSTrkSize.begin(); rmLS != mapLSBSTrkSize.end();
1083  ++rmLS, ++changedAfterThis) {
1084  if (changedAfterThis > 0) {
1085  (rmLS->second) = (rmLS->second) - SizeToRemove;
1086  if ((mapLSBSTrkSize.size() - (size_t)changedAfterThis) == 2)
1087  PreviousRecords = (rmLS->second);
1088  }
1089  }
1090 
1091  theBeamFitter->resizeBSvector(SizeToRemove);
1092 
1093  map<int, std::size_t>::iterator tmpIt = mapLSBSTrkSize.begin();
1094  mapLSBSTrkSize.erase(tmpIt);
1095 
1096  std::pair<int, int> checkfitLS = theBeamFitter->getFitLSRange();
1097  std::pair<time_t, time_t> checkfitTime = theBeamFitter->getRefTime();
1098  theBeamFitter->setFitLSRange(beginLumiOfBSFit_, checkfitLS.second);
1099  theBeamFitter->setRefTime(refBStime[0], checkfitTime.second);
1100  }
1101 
1102  //Fill the track for this fit
1103  vector<BSTrkParameters> theBSvector = theBeamFitter->getBSvector();
1104  h_nTrk_lumi->ShiftFillLast(theBSvector.size());
1105 
1106  if (debug_)
1107  edm::LogInfo("BeamMonitor") << "FitAndFill:: Size of theBSViector.size() After =" << theBSvector.size() << endl;
1108 
1109  bool countFitting = false;
1110  if (theBSvector.size() >= PreviousRecords && theBSvector.size() >= min_Ntrks_) {
1111  countFitting = true;
1112  }
1113 
1114  //---Fix for Cut Flow Table for Running average in a same way//the previous code has problem for resetting!!!
1115  mapLSCF[countLumi_] = *theBeamFitter->getCutFlow();
1116  if (StartAverage_ && !mapLSCF.empty()) {
1117  const TH1F& cutFlowToSubtract = mapLSCF.begin()->second;
1118  // Subtract the last cut flow from all of the others.
1119  std::map<int, TH1F>::iterator cf = mapLSCF.begin();
1120  // Start on second entry
1121  for (; cf != mapLSCF.end(); ++cf) {
1122  cf->second.Add(&cutFlowToSubtract, -1);
1123  }
1124  theBeamFitter->subtractFromCutFlow(&cutFlowToSubtract);
1125  // Remove the obsolete lumi section
1126  mapLSCF.erase(mapLSCF.begin());
1127  }
1128 
1129  if (resetHistos_) {
1130  h_d0_phi0->Reset();
1131  h_vx_vy->Reset();
1132  h_vx_dz->Reset();
1133  h_vy_dz->Reset();
1134  h_trk_z0->Reset();
1135  resetHistos_ = false;
1136  }
1137 
1138  if (StartAverage_)
1139  nthBSTrk_ = PreviousRecords; //after average proccess is ON//for 2-6 LS fit PreviousRecords is size from 2-5 LS
1140 
1141  edm::LogInfo("BeamMonitor") << " The Previous Recored for this fit is =" << nthBSTrk_ << endl;
1142 
1143  unsigned int itrk = 0;
1144  for (vector<BSTrkParameters>::const_iterator BSTrk = theBSvector.begin(); BSTrk != theBSvector.end();
1145  ++BSTrk, ++itrk) {
1146  if (itrk >= nthBSTrk_) { //fill for this record only !!
1147  h_d0_phi0->Fill(BSTrk->phi0(), BSTrk->d0());
1148  double vx = BSTrk->vx();
1149  double vy = BSTrk->vy();
1150  double z0 = BSTrk->z0();
1151  h_vx_vy->Fill(vx, vy);
1152  h_vx_dz->Fill(z0, vx);
1153  h_vy_dz->Fill(z0, vy);
1154  h_trk_z0->Fill(z0);
1155  }
1156  }
1157 
1158  nthBSTrk_ = theBSvector.size(); // keep track of num of tracks filled so far
1159 
1160  edm::LogInfo("BeamMonitor") << " The Current Recored for this fit is =" << nthBSTrk_ << endl;
1161 
1162  if (countFitting)
1163  edm::LogInfo("BeamMonitor") << "FitAndFill:: Num of tracks collected = " << nthBSTrk_ << endl;
1164 
1165  if (fitNLumi_ > 0) {
1166  if (onlineMode_) {
1167  if (currentlumi % fitNLumi_ != 0) {
1168  // for (std::map<TString,MonitorElement*>::iterator itAll = hs.begin();
1169  // itAll != hs.end(); ++itAll) {
1170  // if ((*itAll).first.Contains("all")) {
1171  // (*itAll).second->setBinContent(currentlumi,0.);
1172  // (*itAll).second->setBinError(currentlumi,0.);
1173  // }
1174  // }
1175  return;
1176  }
1177  } else if (countLumi_ % fitNLumi_ != 0)
1178  return;
1179  }
1180 
1181  edm::LogInfo("BeamMonitor") << "FitAndFill:: [DebugTime] refBStime[0] = " << refBStime[0]
1182  << "; address = " << &refBStime[0] << std::endl;
1183  edm::LogInfo("BeamMonitor") << "FitAndFill:: [DebugTime] refBStime[1] = " << refBStime[1]
1184  << "; address = " << &refBStime[1] << std::endl;
1185 
1186  //Fill for all LS even if fit fails
1187  h_nVtx_lumi->ShiftFillLast((theBeamFitter->getPVvectorSize()), 0., fitNLumi_);
1188  h_nVtx_lumi_all->setBinContent(currentlumi, (theBeamFitter->getPVvectorSize()));
1189 
1190  if (countFitting) {
1191  nFits_++;
1192  std::pair<int, int> fitLS = theBeamFitter->getFitLSRange();
1193  edm::LogInfo("BeamMonitor") << "FitAndFill:: [BeamFitter] Do BeamSpot Fit for LS = " << fitLS.first << " to "
1194  << fitLS.second << std::endl;
1195  edm::LogInfo("BeamMonitor") << "FitAndFill:: [BeamMonitor] Do BeamSpot Fit for LS = " << beginLumiOfBSFit_
1196  << " to " << endLumiOfBSFit_ << std::endl;
1197 
1198  //Now Run the PV and Track Fitter over the collected tracks and pvs
1199  if (theBeamFitter->runPVandTrkFitter()) {
1200  reco::BeamSpot bs = theBeamFitter->getBeamSpot();
1201  if (bs.type() > 0) // with good beamwidth fit
1202  preBS = bs; // cache good fit results
1203 
1204  edm::LogInfo("BeamMonitor") << "\n RESULTS OF DEFAULT FIT:" << endl;
1205  edm::LogInfo("BeamMonitor") << bs << endl;
1206  edm::LogInfo("BeamMonitor") << "[BeamFitter] fitting done \n" << endl;
1207 
1208  hs[k_x0_lumi]->ShiftFillLast(bs.x0(), bs.x0Error(), fitNLumi_);
1209  hs[k_y0_lumi]->ShiftFillLast(bs.y0(), bs.y0Error(), fitNLumi_);
1210  hs[k_z0_lumi]->ShiftFillLast(bs.z0(), bs.z0Error(), fitNLumi_);
1211  hs[k_sigmaX0_lumi]->ShiftFillLast(bs.BeamWidthX(), bs.BeamWidthXError(), fitNLumi_);
1212  hs[k_sigmaY0_lumi]->ShiftFillLast(bs.BeamWidthY(), bs.BeamWidthYError(), fitNLumi_);
1213  hs[k_sigmaZ0_lumi]->ShiftFillLast(bs.sigmaZ(), bs.sigmaZ0Error(), fitNLumi_);
1214  hs[k_x0_lumi_all]->setBinContent(currentlumi, bs.x0());
1215  hs[k_x0_lumi_all]->setBinError(currentlumi, bs.x0Error());
1216  hs[k_y0_lumi_all]->setBinContent(currentlumi, bs.y0());
1217  hs[k_y0_lumi_all]->setBinError(currentlumi, bs.y0Error());
1218  hs[k_z0_lumi_all]->setBinContent(currentlumi, bs.z0());
1219  hs[k_z0_lumi_all]->setBinError(currentlumi, bs.z0Error());
1220  hs[k_sigmaX0_lumi_all]->setBinContent(currentlumi, bs.BeamWidthX());
1221  hs[k_sigmaX0_lumi_all]->setBinError(currentlumi, bs.BeamWidthXError());
1222  hs[k_sigmaY0_lumi_all]->setBinContent(currentlumi, bs.BeamWidthY());
1223  hs[k_sigmaY0_lumi_all]->setBinError(currentlumi, bs.BeamWidthYError());
1224  hs[k_sigmaZ0_lumi_all]->setBinContent(currentlumi, bs.sigmaZ());
1225  hs[k_sigmaZ0_lumi_all]->setBinError(currentlumi, bs.sigmaZ0Error());
1226 
1227  int nthBin = tmpTime - refTime;
1228  if (nthBin > 0) {
1229  hs[k_x0_time]->setBinContent(nthBin, bs.x0());
1230  hs[k_y0_time]->setBinContent(nthBin, bs.y0());
1231  hs[k_z0_time]->setBinContent(nthBin, bs.z0());
1232  hs[k_sigmaX0_time]->setBinContent(nthBin, bs.BeamWidthX());
1233  hs[k_sigmaY0_time]->setBinContent(nthBin, bs.BeamWidthY());
1234  hs[k_sigmaZ0_time]->setBinContent(nthBin, bs.sigmaZ());
1235  hs[k_x0_time]->setBinError(nthBin, bs.x0Error());
1236  hs[k_y0_time]->setBinError(nthBin, bs.y0Error());
1237  hs[k_z0_time]->setBinError(nthBin, bs.z0Error());
1238  hs[k_sigmaX0_time]->setBinError(nthBin, bs.BeamWidthXError());
1239  hs[k_sigmaY0_time]->setBinError(nthBin, bs.BeamWidthYError());
1240  hs[k_sigmaZ0_time]->setBinError(nthBin, bs.sigmaZ0Error());
1241  }
1242 
1243  int jthBin = tmpTime - startTime;
1244  if (jthBin > 0) {
1245  hs[k_x0_time_all]->setBinContent(jthBin, bs.x0());
1246  hs[k_y0_time_all]->setBinContent(jthBin, bs.y0());
1247  hs[k_z0_time_all]->setBinContent(jthBin, bs.z0());
1248  hs[k_sigmaX0_time_all]->setBinContent(jthBin, bs.BeamWidthX());
1249  hs[k_sigmaY0_time_all]->setBinContent(jthBin, bs.BeamWidthY());
1250  hs[k_sigmaZ0_time_all]->setBinContent(jthBin, bs.sigmaZ());
1251  hs[k_x0_time_all]->setBinError(jthBin, bs.x0Error());
1252  hs[k_y0_time_all]->setBinError(jthBin, bs.y0Error());
1253  hs[k_z0_time_all]->setBinError(jthBin, bs.z0Error());
1254  hs[k_sigmaX0_time_all]->setBinError(jthBin, bs.BeamWidthXError());
1255  hs[k_sigmaY0_time_all]->setBinError(jthBin, bs.BeamWidthYError());
1256  hs[k_sigmaZ0_time_all]->setBinError(jthBin, bs.sigmaZ0Error());
1257  }
1258 
1259  h_x0->Fill(bs.x0());
1260  h_y0->Fill(bs.y0());
1261  h_z0->Fill(bs.z0());
1262  if (bs.type() > 0) { // with good beamwidth fit
1263  h_sigmaX0->Fill(bs.BeamWidthX());
1264  h_sigmaY0->Fill(bs.BeamWidthY());
1265  }
1266  h_sigmaZ0->Fill(bs.sigmaZ());
1267 
1268  if (nthBSTrk_ >= 2 * min_Ntrks_) {
1269  double amp = std::sqrt(bs.x0() * bs.x0() + bs.y0() * bs.y0());
1270  double alpha = std::atan2(bs.y0(), bs.x0());
1271  std::unique_ptr<TF1> f1{new TF1("f1", "[0]*sin(x-[1])", -3.14, 3.14)};
1272  f1->SetParameters(amp, alpha);
1273  f1->SetParLimits(0, amp - 0.1, amp + 0.1);
1274  f1->SetParLimits(1, alpha - 0.577, alpha + 0.577);
1275  f1->SetLineColor(4);
1276  h_d0_phi0->getTProfile()->Fit(f1.get(), "QR");
1277 
1278  double mean = bs.z0();
1279  double width = bs.sigmaZ();
1280  std::unique_ptr<TF1> fgaus{new TF1("fgaus", "gaus")};
1281  fgaus->SetParameters(mean, width);
1282  fgaus->SetLineColor(4);
1283  h_trk_z0->getTH1()->Fit(fgaus.get(), "QLRM", "", mean - 3 * width, mean + 3 * width);
1284  }
1285 
1286  fitResults->Reset();
1287  std::pair<int, int> LSRange = theBeamFitter->getFitLSRange();
1288  char tmpTitle[50];
1289  sprintf(tmpTitle, "%s %i %s %i", "Fitted Beam Spot (cm) of LS: ", LSRange.first, " to ", LSRange.second);
1290  fitResults->setAxisTitle(tmpTitle, 1);
1291  fitResults->setBinContent(1, 8, bs.x0());
1292  fitResults->setBinContent(1, 7, bs.y0());
1293  fitResults->setBinContent(1, 6, bs.z0());
1294  fitResults->setBinContent(1, 5, bs.sigmaZ());
1295  fitResults->setBinContent(1, 4, bs.dxdz());
1296  fitResults->setBinContent(1, 3, bs.dydz());
1297  if (bs.type() > 0) { // with good beamwidth fit
1298  fitResults->setBinContent(1, 2, bs.BeamWidthX());
1299  fitResults->setBinContent(1, 1, bs.BeamWidthY());
1300  } else { // fill cached widths
1301  fitResults->setBinContent(1, 2, preBS.BeamWidthX());
1302  fitResults->setBinContent(1, 1, preBS.BeamWidthY());
1303  }
1304 
1305  fitResults->setBinContent(2, 8, bs.x0Error());
1306  fitResults->setBinContent(2, 7, bs.y0Error());
1307  fitResults->setBinContent(2, 6, bs.z0Error());
1308  fitResults->setBinContent(2, 5, bs.sigmaZ0Error());
1309  fitResults->setBinContent(2, 4, bs.dxdzError());
1310  fitResults->setBinContent(2, 3, bs.dydzError());
1311  if (bs.type() > 0) { // with good beamwidth fit
1312  fitResults->setBinContent(2, 2, bs.BeamWidthXError());
1313  fitResults->setBinContent(2, 1, bs.BeamWidthYError());
1314  } else { // fill cached width errors
1315  fitResults->setBinContent(2, 2, preBS.BeamWidthXError());
1316  fitResults->setBinContent(2, 1, preBS.BeamWidthYError());
1317  }
1318 
1319  // count good fit
1320  // if (std::fabs(refBS.x0()-bs.x0())/bs.x0Error() < deltaSigCut_) { // disabled temporarily
1321  summaryContent_[0] += 1.;
1322  // }
1323  // if (std::fabs(refBS.y0()-bs.y0())/bs.y0Error() < deltaSigCut_) { // disabled temporarily
1324  summaryContent_[1] += 1.;
1325  // }
1326  // if (std::fabs(refBS.z0()-bs.z0())/bs.z0Error() < deltaSigCut_) { // disabled temporarily
1327  summaryContent_[2] += 1.;
1328  // }
1329 
1330  // Create the BeamSpotOnlineObjects object
1331  BeamSpotOnlineObjects* BSOnline = new BeamSpotOnlineObjects();
1332  BSOnline->SetLastAnalyzedLumi(fitLS.second);
1333  BSOnline->SetLastAnalyzedRun(theBeamFitter->getRunNumber());
1334  BSOnline->SetLastAnalyzedFill(0); // To be updated with correct LHC Fill number
1335  BSOnline->SetPosition(bs.x0(), bs.y0(), bs.z0());
1336  BSOnline->SetSigmaZ(bs.sigmaZ());
1337  BSOnline->SetBeamWidthX(bs.BeamWidthX());
1338  BSOnline->SetBeamWidthY(bs.BeamWidthY());
1339  BSOnline->SetBeamWidthXError(bs.BeamWidthXError());
1340  BSOnline->SetBeamWidthYError(bs.BeamWidthYError());
1341  BSOnline->Setdxdz(bs.dxdz());
1342  BSOnline->Setdydz(bs.dydz());
1343  BSOnline->SetType(bs.type());
1344  BSOnline->SetEmittanceX(bs.emittanceX());
1345  BSOnline->SetEmittanceY(bs.emittanceY());
1346  BSOnline->SetBetaStar(bs.betaStar());
1347  for (int i = 0; i < 7; ++i) {
1348  for (int j = 0; j < 7; ++j) {
1349  BSOnline->SetCovariance(i, j, bs.covariance(i, j));
1350  }
1351  }
1352  BSOnline->SetNumTracks(theBeamFitter->getNTracks());
1353  BSOnline->SetNumPVs(theBeamFitter->getNPVs());
1354 
1355  edm::LogInfo("BeamMonitor") << "FitAndFill::[PayloadCreation] BeamSpotOnline object created: \n" << std::endl;
1356  edm::LogInfo("BeamMonitor") << *BSOnline << std::endl;
1357 
1358  // Create the payload for BeamSpotOnlineObjects object
1359  edm::Service<cond::service::OnlineDBOutputService> onlineDbService;
1360  if (onlineDbService.isAvailable()) {
1361  edm::LogInfo("BeamMonitor") << "FitAndFill::[PayloadCreation] onlineDbService available \n" << std::endl;
1362  BSOnline->SetCreationTime(onlineDbService->currentTime());
1363  onlineDbService->writeForNextLumisection(BSOnline, recordName_);
1364  }
1365  edm::LogInfo("BeamMonitor") << "FitAndFill::[PayloadCreation] BeamSpotOnline payload created \n" << std::endl;
1366 
1367  } //if (theBeamFitter->runPVandTrkFitter())
1368  else { // beam fit fails
1369  reco::BeamSpot bs = theBeamFitter->getBeamSpot();
1370  edm::LogInfo("BeamMonitor") << "FitAndFill:: [BeamMonitor] Beam fit fails!!! \n" << endl;
1371  edm::LogInfo("BeamMonitor") << "FitAndFill:: [BeamMonitor] Output beam spot for DIP \n" << endl;
1372  edm::LogInfo("BeamMonitor") << bs << endl;
1373 
1374  hs[k_sigmaX0_lumi]->ShiftFillLast(bs.BeamWidthX(), bs.BeamWidthXError(), fitNLumi_);
1375  hs[k_sigmaY0_lumi]->ShiftFillLast(bs.BeamWidthY(), bs.BeamWidthYError(), fitNLumi_);
1376  hs[k_sigmaZ0_lumi]->ShiftFillLast(bs.sigmaZ(), bs.sigmaZ0Error(), fitNLumi_);
1377  hs[k_x0_lumi]->ShiftFillLast(bs.x0(), bs.x0Error(), fitNLumi_);
1378  hs[k_y0_lumi]->ShiftFillLast(bs.y0(), bs.y0Error(), fitNLumi_);
1379  hs[k_z0_lumi]->ShiftFillLast(bs.z0(), bs.z0Error(), fitNLumi_);
1380  } // end of beam fit fails
1381 
1382  } //-------- end of countFitting------------------------------------------
1383  else { // no fit
1384  // Overwrite Fit LS and fit time when no event processed or no track selected
1385  theBeamFitter->setFitLSRange(beginLumiOfBSFit_, endLumiOfBSFit_);
1386  theBeamFitter->setRefTime(refBStime[0], refBStime[1]);
1387  if (theBeamFitter->runPVandTrkFitter()) {
1388  } // Dump fake beam spot for DIP
1389  reco::BeamSpot bs = theBeamFitter->getBeamSpot();
1390  edm::LogInfo("BeamMonitor") << "FitAndFill:: [BeamMonitor] No fitting \n" << endl;
1391  edm::LogInfo("BeamMonitor") << "FitAndFill:: [BeamMonitor] Output fake beam spot for DIP \n" << endl;
1392  edm::LogInfo("BeamMonitor") << bs << endl;
1393 
1394  hs[k_sigmaX0_lumi]->ShiftFillLast(bs.BeamWidthX(), bs.BeamWidthXError(), fitNLumi_);
1395  hs[k_sigmaY0_lumi]->ShiftFillLast(bs.BeamWidthY(), bs.BeamWidthYError(), fitNLumi_);
1396  hs[k_sigmaZ0_lumi]->ShiftFillLast(bs.sigmaZ(), bs.sigmaZ0Error(), fitNLumi_);
1397  hs[k_x0_lumi]->ShiftFillLast(bs.x0(), bs.x0Error(), fitNLumi_);
1398  hs[k_y0_lumi]->ShiftFillLast(bs.y0(), bs.y0Error(), fitNLumi_);
1399  hs[k_z0_lumi]->ShiftFillLast(bs.z0(), bs.z0Error(), fitNLumi_);
1400  }
1401 
1402  // Fill summary report
1403  if (countFitting) {
1404  for (int n = 0; n < nFitElements_; n++) {
1405  reportSummaryContents[n]->Fill(summaryContent_[n] / (float)nFits_);
1406  }
1407 
1408  summarySum_ = 0;
1409  for (int ii = 0; ii < nFitElements_; ii++) {
1410  summarySum_ += summaryContent_[ii];
1411  }
1412  reportSummary_ = summarySum_ / (nFitElements_ * nFits_);
1413  if (reportSummary)
1414  reportSummary->Fill(reportSummary_);
1415 
1416  for (int bi = 0; bi < nFitElements_; bi++) {
1417  reportSummaryMap->setBinContent(1, bi + 1, summaryContent_[bi] / (float)nFits_);
1418  }
1419  }
1420 
1421  if ((resetFitNLumi_ > 0 &&
1422  ((onlineMode_ &&
1423  countLumi_ == resetFitNLumi_) || //OR it should be currentLumi_ (if in sequence then does not mattar)
1424  (!onlineMode_ && countLumi_ == resetFitNLumi_))) ||
1425  (StartAverage_)) {
1426  edm::LogInfo("BeamMonitor") << "FitAndFill:: The flag is ON for running average Beam Spot fit" << endl;
1427  StartAverage_ = true;
1428  firstAverageFit_++;
1429  resetHistos_ = true;
1430  nthBSTrk_ = 0;
1431  beginLumiOfBSFit_ = 0;
1432  refBStime[0] = 0;
1433  }
1434 }
1435 
1436 //--------------------------------------------------------
1437 void BeamMonitor::RestartFitting() {
1438  if (debug_)
1439  edm::LogInfo("BeamMonitor")
1440  << " RestartingFitting:: Restart Beami everything to a fresh start !!! because Gap is > 10 LS" << endl;
1441  //track based fit reset here
1442  resetHistos_ = true;
1443  nthBSTrk_ = 0;
1444  theBeamFitter->resetTrkVector();
1445  theBeamFitter->resetLSRange();
1446  theBeamFitter->resetRefTime();
1447  theBeamFitter->resetPVFitter();
1448  theBeamFitter->resetCutFlow();
1449  beginLumiOfBSFit_ = 0;
1450  refBStime[0] = 0;
1451  //pv based fit iis reset here
1452  h_PVx[0]->Reset();
1453  h_PVy[0]->Reset();
1454  h_PVz[0]->Reset();
1455  beginLumiOfPVFit_ = 0;
1456  refPVtime[0] = 0;
1457  //Clear all the Maps here
1458  mapPVx.clear();
1459  mapPVy.clear();
1460  mapPVz.clear();
1461  mapNPV.clear();
1462  mapBeginBSLS.clear();
1463  mapBeginPVLS.clear();
1464  mapBeginBSTime.clear();
1465  mapBeginPVTime.clear();
1466  mapLSBSTrkSize.clear();
1467  mapLSPVStoreSize.clear();
1468  mapLSCF.clear();
1469  countGapLumi_ = 0;
1470  countLumi_ = 0;
1471  StartAverage_ = false;
1472 }
1473 
1474 //-------------------------------------------------------
1475 void BeamMonitor::dqmEndRun(const Run& r, const EventSetup& context) {
1476  if (debug_)
1477  edm::LogInfo("BeamMonitor") << "dqmEndRun:: Clearing all the Maps " << endl;
1478  //Clear all the Maps here
1479  mapPVx.clear();
1480  mapPVy.clear();
1481  mapPVz.clear();
1482  mapNPV.clear();
1483  mapBeginBSLS.clear();
1484  mapBeginPVLS.clear();
1485  mapBeginBSTime.clear();
1486  mapBeginPVTime.clear();
1487  mapLSBSTrkSize.clear();
1488  mapLSPVStoreSize.clear();
1489  mapLSCF.clear();
1490 }
1491 
1492 //--------------------------------------------------------
1493 void BeamMonitor::scrollTH1(TH1* h, time_t ref) {
1494  char offsetTime[64];
1495  formatFitTime(offsetTime, ref);
1496  TDatime da(offsetTime);
1497  if (lastNZbin > 0) {
1498  double val = h->GetBinContent(lastNZbin);
1499  double valErr = h->GetBinError(lastNZbin);
1500  h->Reset();
1501  h->GetXaxis()->SetTimeOffset(da.Convert(kTRUE));
1502  int bin = (lastNZbin > buffTime ? buffTime : 1);
1503  h->SetBinContent(bin, val);
1504  h->SetBinError(bin, valErr);
1505  } else {
1506  h->Reset();
1507  h->GetXaxis()->SetTimeOffset(da.Convert(kTRUE));
1508  }
1509 }
1510 
1511 //--------------------------------------------------------
1512 // Method to check whether to chane histogram time offset (forward only)
1513 bool BeamMonitor::testScroll(time_t& tmpTime_, time_t& refTime_) {
1514  bool scroll_ = false;
1515  if (tmpTime_ - refTime_ >= intervalInSec_) {
1516  scroll_ = true;
1517  edm::LogInfo("BeamMonitor") << "testScroll:: Reset Time Offset" << std::endl;
1518  lastNZbin = intervalInSec_;
1519  for (int bin = intervalInSec_; bin >= 1; bin--) {
1520  if (hs[k_x0_time]->getBinContent(bin) > 0) {
1521  lastNZbin = bin;
1522  break;
1523  }
1524  }
1525  edm::LogInfo("BeamMonitor") << "testScroll:: Last non zero bin = " << lastNZbin << std::endl;
1526  if (tmpTime_ - refTime_ >= intervalInSec_ + lastNZbin) {
1527  edm::LogInfo("BeamMonitor") << "testScroll:: Time difference too large since last readout" << std::endl;
1528  lastNZbin = 0;
1529  refTime_ = tmpTime_ - buffTime;
1530  } else {
1531  edm::LogInfo("BeamMonitor") << "testScroll:: Offset to last record" << std::endl;
1532  int offset = ((lastNZbin > buffTime) ? (lastNZbin - buffTime) : (lastNZbin - 1));
1533  refTime_ += offset;
1534  }
1535  }
1536  return scroll_;
1537 }
1538 
1539 DEFINE_FWK_MODULE(BeamMonitor);
1540 
1541 // Local Variables:
1542 // show-trailing-whitespace: t
1543 // truncate-lines: t
1544 // End:
BeamMonitor::recordName_
std::string recordName_
Definition: BeamMonitor.h:71
buffTime
static constexpr int buffTime
Definition: BeamMonitor.cc:90
BeamMonitor::h_vx_vy
MonitorElement * h_vx_vy
Definition: BeamMonitor.h:127
BeamMonitor::refBStime
std::time_t refBStime[2]
Definition: BeamMonitor.h:96
BeamMonitor::lastNZbin
int lastNZbin
Definition: BeamMonitor.h:178
ApeEstimator_cff.width
width
Definition: ApeEstimator_cff.py:24
BeamMonitor::phiMin_
const double phiMin_
Definition: BeamMonitor.h:64
PDWG_EXOHSCP_cff.tracks
tracks
Definition: PDWG_EXOHSCP_cff.py:28
BeamMonitor::tmpTime
std::time_t tmpTime
Definition: BeamMonitor.h:172
mps_fire.i
i
Definition: mps_fire.py:355
BeamMonitor::ftimestamp
edm::TimeValue_t ftimestamp
Definition: BeamMonitor.h:175
MessageLogger.h
BeamMonitor::firstAverageFit_
int firstAverageFit_
Definition: BeamMonitor.h:110
SiStripPI::mean
Definition: SiStripPayloadInspectorHelper.h:169
reco::BeamSpot::BeamWidthXError
double BeamWidthXError() const
error on beam width X, assume error in X = Y
Definition: BeamSpot.h:99
funct::false
false
Definition: Factorize.h:34
dqmiodumpmetadata.n
n
Definition: dqmiodumpmetadata.py:28
BeamMonitor::dzMin_
const double dzMin_
Definition: BeamMonitor.h:68
BeamSpotObjects::SetBetaStar
void SetBetaStar(double val)
set beta star
Definition: BeamSpotObjects.h:64
BeamMonitor::monitorName_
std::string monitorName_
Definition: BeamMonitor.h:70
cond::service::OnlineDBOutputService::writeForNextLumisection
bool writeForNextLumisection(const PayloadType *payload, const std::string &recordName)
Definition: OnlineDBOutputService.h:45
trigNames
static const char *const trigNames[]
Definition: EcalDumpRaw.cc:57
TrackCandidateCollection.h
BeamMonitor::hs
std::vector< MonitorElement * > hs
Definition: BeamMonitor.h:147
BeamMonitor::beginLumiOfBSFit_
int beginLumiOfBSFit_
Definition: BeamMonitor.h:90
BeamMonitor::minNrVertices_
unsigned int minNrVertices_
Definition: BeamMonitor.h:104
BeamMonitor::cutFlowTable
MonitorElement * cutFlowTable
Definition: BeamMonitor.h:168
dqm::impl::MonitorElement::setOption
virtual void setOption(const char *option)
Definition: MonitorElement.cc:887
BeamMonitor
Definition: BeamMonitor.h:33
BeamSpotOnlineObjects::SetCreationTime
void SetCreationTime(cond::Time_t val)
Definition: BeamSpotOnlineObjects.cc:65
BeamMonitor::bookHistograms
void bookHistograms(DQMStore::IBooker &i, const edm::Run &r, const edm::EventSetup &c) override
Definition: BeamMonitor.cc:207
BeamMonitor::mapPVx
std::map< int, std::vector< float > > mapPVx
Definition: BeamMonitor.h:150
edm::LuminosityBlock
Definition: LuminosityBlock.h:50
BeamMonitor::h_PVxz
MonitorElement * h_PVxz
Definition: BeamMonitor.h:144
BeamMonitor::frun
int frun
Definition: BeamMonitor.h:177
edm::Run
Definition: Run.h:45
BeamSpotOnlineObjects::SetNumTracks
void SetNumTracks(int val)
Definition: BeamSpotOnlineObjects.cc:59
zMuMuMuonUserData.alpha
alpha
zGenParticlesMatch = cms.InputTag(""),
Definition: zMuMuMuonUserData.py:9
BeamMonitor::pvSrc_
edm::EDGetTokenT< reco::VertexCollection > pvSrc_
Definition: BeamMonitor.h:74
TriggerEvent.h
LuminosityBlock.h
BeamMonitor::endLumiOfPVFit_
int endLumiOfPVFit_
Definition: BeamMonitor.h:93
edm
HLT enums.
Definition: AlignableModifier.h:19
BeamMonitor::onlineMode_
bool onlineMode_
Definition: BeamMonitor.h:83
BeamMonitor::jetTrigger_
std::vector< std::string > jetTrigger_
Definition: BeamMonitor.h:84
edm::LuminosityBlockBase::beginTime
Timestamp const & beginTime() const
Definition: LuminosityBlockBase.h:46
BeamMonitor.h
CEST
#define CEST
edm::LogInfo
Definition: MessageLogger.h:254
triggerResults
static const std::string triggerResults
Definition: EdmProvDump.cc:45
BeamMonitor::dxBin_
const int dxBin_
Definition: BeamMonitor.h:55
timingPdfMaker.histo
histo
Definition: timingPdfMaker.py:279
Calorimetry_cff.da
da
Definition: Calorimetry_cff.py:154
cms::cuda::assert
assert(be >=bs)
edm::EDConsumerBase::consumesCollector
ConsumesCollector consumesCollector()
Use a ConsumesCollector to gather consumes information from helper functions.
Definition: EDConsumerBase.cc:71
DQMStore.h
BeamMonitor::nFits_
int nFits_
Definition: BeamMonitor.h:100
BeamSpotObjects::SetBeamWidthY
void SetBeamWidthY(double val)
set average transverse beam width Y
Definition: BeamSpotObjects.h:50
BeamMonitor::mapNPV
std::map< int, std::vector< int > > mapNPV
Definition: BeamMonitor.h:151
BeamMonitor::analyze
void analyze(const edm::Event &e, const edm::EventSetup &c) override
Definition: BeamMonitor.cc:640
dqm::impl::MonitorElement::getRMSError
virtual double getRMSError(int axis=1) const
get RMS uncertainty of histogram along x, y or z axis(axis=1,2,3 respectively)
Definition: MonitorElement.cc:568
BeamMonitor::mapLSBSTrkSize
std::map< int, std::size_t > mapLSBSTrkSize
Definition: BeamMonitor.h:156
BeamMonitor::reportSummary
MonitorElement * reportSummary
Definition: BeamMonitor.h:165
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
edm::Timestamp::value
TimeValue_t value() const
Definition: Timestamp.h:45
BeamMonitor::vxBin_
const int vxBin_
Definition: BeamMonitor.h:59
BeamMonitor::fitResults
MonitorElement * fitResults
Definition: BeamMonitor.h:132
BeamMonitor::h_sigmaY0
MonitorElement * h_sigmaY0
Definition: BeamMonitor.h:137
BeamMonitor::h_nVtx
MonitorElement * h_nVtx
Definition: BeamMonitor.h:139
tools.TF1
TF1
Definition: tools.py:23
newFWLiteAna.found
found
Definition: newFWLiteAna.py:118
edm::Handle< reco::BeamSpot >
edm::Service::isAvailable
bool isAvailable() const
Definition: Service.h:40
edm::RunBase::run
RunNumber_t run() const
Definition: RunBase.h:40
BeamMonitor::countEvt_
int countEvt_
Definition: BeamMonitor.h:88
BeamMonitor::minVtxWgt_
double minVtxWgt_
Definition: BeamMonitor.h:106
BeamMonitor::h_PVz
MonitorElement * h_PVz[2]
Definition: BeamMonitor.h:143
end
#define end
Definition: vmac.h:39
BeamSpotObjects::SetSigmaZ
void SetSigmaZ(double val)
set sigma Z, RMS bunch length
Definition: BeamSpotObjects.h:42
BeamMonitor::h_nTrk_lumi
MonitorElement * h_nTrk_lumi
Definition: BeamMonitor.h:122
BeamMonitor::testScroll
bool testScroll(std::time_t &, std::time_t &)
Definition: BeamMonitor.cc:1513
BeamMonitor::nextlumi_
int nextlumi_
Definition: BeamMonitor.h:95
BeamMonitor::h_y0
MonitorElement * h_y0
Definition: BeamMonitor.h:134
BeamMonitor::minVtxNdf_
double minVtxNdf_
Definition: BeamMonitor.h:105
BeamMonitor::processed_
bool processed_
Definition: BeamMonitor.h:113
BeamMonitor::h_PVyz
MonitorElement * h_PVyz
Definition: BeamMonitor.h:145
MakerMacros.h
cms::cuda::bs
bs
Definition: HistoContainer.h:127
BeamMonitor::fitPVNLumi_
int fitPVNLumi_
Definition: BeamMonitor.h:78
BeamMonitor::pvResults
MonitorElement * pvResults
Definition: BeamMonitor.h:146
h
edm::LuminosityBlockBase::endTime
Timestamp const & endTime() const
Definition: LuminosityBlockBase.h:47
BeamMonitor::dxMin_
const double dxMin_
Definition: BeamMonitor.h:56
BeamMonitor::refBS
reco::BeamSpot refBS
Definition: BeamMonitor.h:118
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:16
BeamMonitor::countGapLumi_
int countGapLumi_
Definition: BeamMonitor.h:111
Service.h
edm::LuminosityBlockBase::luminosityBlock
LuminosityBlockNumber_t luminosityBlock() const
Definition: LuminosityBlockBase.h:40
L1TEGammaOffline_cfi.PVCollection
PVCollection
Definition: L1TEGammaOffline_cfi.py:34
BeamMonitor::mapPVz
std::map< int, std::vector< float > > mapPVz
Definition: BeamMonitor.h:150
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
BeamMonitor::endLuminosityBlock
void endLuminosityBlock(const edm::LuminosityBlock &lumiSeg, const edm::EventSetup &c) override
Definition: BeamMonitor.cc:777
dqm::impl::MonitorElement::Fill
void Fill(long long x)
Definition: MonitorElement.h:290
BeamMonitor::h_sigmaZ0
MonitorElement * h_sigmaZ0
Definition: BeamMonitor.h:138
reco::BeamSpot
Definition: BeamSpot.h:21
dqm::impl::MonitorElement::Reset
virtual void Reset()
Remove all data from the ME, keept the empty histogram with all its settings.
Definition: MonitorElement.cc:354
dqm::impl::MonitorElement::ShiftFillLast
DQM_DEPRECATED void ShiftFillLast(double y, double ye=0., int32_t xscale=1)
Definition: MonitorElement.cc:256
Run.h
BeamMonitor::reportSummary_
Float_t reportSummary_
Definition: BeamMonitor.h:162
BeamMonitor::mapBeginBSTime
std::map< int, std::time_t > mapBeginBSTime
Definition: BeamMonitor.h:154
hgcalPlots.xtitle
xtitle
Definition: hgcalPlots.py:94
dqm::impl::MonitorElement::getRMS
virtual double getRMS(int axis=1) const
get RMS of histogram along x, y or z axis (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:562
BeamSpotObjects::SetEmittanceY
void SetEmittanceY(double val)
set emittance
Definition: BeamSpotObjects.h:62
dqm::impl::MonitorElement::getTH1F
virtual TH1F * getTH1F()
Definition: MonitorElement.cc:974
HLTMuonOfflineAnalyzer_cfi.z0
z0
Definition: HLTMuonOfflineAnalyzer_cfi.py:98
OrderedSet.t
t
Definition: OrderedSet.py:90
b
double b
Definition: hdecay.h:118
BeamMonitor::h_nVtx_lumi_all
MonitorElement * h_nVtx_lumi_all
Definition: BeamMonitor.h:124
dqm::impl::MonitorElement::getTH1
virtual TH1 * getTH1()
Definition: MonitorElement.cc:969
BeamMonitor::startTime
std::time_t startTime
Definition: BeamMonitor.h:173
BeamSpotObjects::SetPosition
void SetPosition(double x, double y, double z)
set XYZ position
Definition: BeamSpotObjects.h:36
BeamMonitor::tracksLabel_
edm::EDGetTokenT< reco::TrackCollection > tracksLabel_
Definition: BeamMonitor.h:73
BeamMonitor::mapBeginPVTime
std::map< int, std::time_t > mapBeginPVTime
Definition: BeamMonitor.h:154
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
BeamMonitor::h_vy_dz
MonitorElement * h_vy_dz
Definition: BeamMonitor.h:129
EgHLTOffTrigSelection_cfi.trigName
trigName
Definition: EgHLTOffTrigSelection_cfi.py:8
BeamMonitor::h_sigmaX0
MonitorElement * h_sigmaX0
Definition: BeamMonitor.h:136
BeamMonitor::vxMin_
const double vxMin_
Definition: BeamMonitor.h:60
BeamMonitor::dzMax_
const double dzMax_
Definition: BeamMonitor.h:69
BeamSpotObjects::SetType
void SetType(int type)
set beam type
Definition: BeamSpotObjects.h:58
edm::ParameterSet
Definition: ParameterSet.h:36
BeamMonitor::refTime
std::time_t refTime
Definition: BeamMonitor.h:174
BeamMonitor::formatFitTime
void formatFitTime(char *, const std::time_t &)
Definition: BeamMonitor.cc:44
edm::LogError
Definition: MessageLogger.h:183
BeamMonitor::endLumiOfBSFit_
int endLumiOfBSFit_
Definition: BeamMonitor.h:91
BeamMonitor::intervalInSec_
int intervalInSec_
Definition: BeamMonitor.h:81
B2GTnPMonitor_cfi.histTitle
histTitle
Definition: B2GTnPMonitor_cfi.py:112
BeamMonitor::h_nVtx_lumi
MonitorElement * h_nVtx_lumi
Definition: BeamMonitor.h:123
BeamMonitor::refPVtime
std::time_t refPVtime[2]
Definition: BeamMonitor.h:97
BeamMonitor::RestartFitting
void RestartFitting()
Definition: BeamMonitor.cc:1437
BeamSpotObjects::SetEmittanceX
void SetEmittanceX(double val)
set emittance
Definition: BeamSpotObjects.h:60
BeamSpotObjects::SetCovariance
void SetCovariance(int i, int j, double val)
set i,j element of the full covariance matrix 7x7
Definition: BeamSpotObjects.h:56
BeamMonitor::vxMax_
const double vxMax_
Definition: BeamMonitor.h:61
edm::Service
Definition: Service.h:30
createfilelist.int
int
Definition: createfilelist.py:10
TriggerNames.h
MetAnalyzer.pv
def pv(vc)
Definition: MetAnalyzer.py:7
iEvent
int iEvent
Definition: GenABIO.cc:224
BeamMonitor::StartAverage_
bool StartAverage_
Definition: BeamMonitor.h:109
edm::LuminosityBlockID::luminosityBlock
LuminosityBlockNumber_t luminosityBlock() const
Definition: LuminosityBlockID.h:42
edm::LuminosityBlockBase::id
LuminosityBlockID id() const
Definition: LuminosityBlockBase.h:44
dqm::impl::MonitorElement::setBinLabel
virtual void setBinLabel(int bin, const std::string &label, int axis=1)
set bin label for x, y or z axis (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:771
plotBeamSpotDB.ptm
ptm
Definition: plotBeamSpotDB.py:396
dqm::impl::MonitorElement::getTProfile
virtual TProfile * getTProfile()
Definition: MonitorElement.cc:1016
reco::BeamSpot::BeamWidthYError
double BeamWidthYError() const
error on beam width Y, assume error in X = Y
Definition: BeamSpot.h:101
Hists
Hists
Definition: BeamMonitor.cc:166
edm::EventSetup
Definition: EventSetup.h:57
BeamMonitor::reportSummaryContents
MonitorElement * reportSummaryContents[3]
Definition: BeamMonitor.h:166
reco::BeamSpot::BeamWidthX
double BeamWidthX() const
beam width X
Definition: BeamSpot.h:82
BeamSpotObjects::Setdxdz
void Setdxdz(double val)
set dxdz slope, crossing angle
Definition: BeamSpotObjects.h:44
BeamSpotOnlineObjects::SetLastAnalyzedFill
void SetLastAnalyzedFill(int val)
Definition: BeamSpotOnlineObjects.h:50
BeamMonitor::h_x0
MonitorElement * h_x0
Definition: BeamMonitor.h:133
alignCSCRings.r
r
Definition: alignCSCRings.py:93
newFWLiteAna.bin
bin
Definition: newFWLiteAna.py:161
BeamMonitor::bsSrc_
edm::EDGetTokenT< reco::BeamSpot > bsSrc_
Definition: BeamMonitor.h:72
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
dqm::impl::MonitorElement::setBinContent
virtual void setBinContent(int binx, double content)
set content of bin (1-D)
Definition: MonitorElement.cc:691
BeamMonitor::h_z0
MonitorElement * h_z0
Definition: BeamMonitor.h:135
BeamMonitor::mapLSCF
std::map< int, TH1F > mapLSCF
Definition: BeamMonitor.h:159
BeamMonitor::beginLumiOfPVFit_
int beginLumiOfPVFit_
Definition: BeamMonitor.h:92
heppy_batch.val
val
Definition: heppy_batch.py:351
std
Definition: JetResolutionObject.h:76
BeamMonitor::deltaSigCut_
double deltaSigCut_
Definition: BeamMonitor.h:101
BeamMonitor::dzBin_
const int dzBin_
Definition: BeamMonitor.h:67
BeamMonitor::h_PVx
MonitorElement * h_PVx[2]
Definition: BeamMonitor.h:141
OnlineDBOutputService.h
BeamSpotOnlineObjects::SetLastAnalyzedLumi
void SetLastAnalyzedLumi(int val)
Setters Methods.
Definition: BeamSpotOnlineObjects.h:44
BeamSpotOnlineObjects
Definition: BeamSpotOnlineObjects.h:25
BeamMonitor::maxZ_
double maxZ_
Definition: BeamMonitor.h:103
BeamMonitor::resetPVNLumi_
int resetPVNLumi_
Definition: BeamMonitor.h:80
BeamMonitor::debug_
bool debug_
Definition: BeamMonitor.h:82
BeamSpotObjects::SetBeamWidthX
void SetBeamWidthX(double val)
set average transverse beam width X
Definition: BeamSpotObjects.h:48
BeamMonitor::phiBin_
const int phiBin_
Definition: BeamMonitor.h:63
edm::TriggerNames
Definition: TriggerNames.h:55
BeamMonitor::preBS
reco::BeamSpot preBS
Definition: BeamMonitor.h:119
BeamMonitor::lastlumi_
int lastlumi_
Definition: BeamMonitor.h:94
BeamMonitor::h_nVtx_st
MonitorElement * h_nVtx_st
Definition: BeamMonitor.h:140
BeamMonitor::reportSummaryMap
MonitorElement * reportSummaryMap
Definition: BeamMonitor.h:167
BeamMonitor::summaryContent_
Float_t summaryContent_[3]
Definition: BeamMonitor.h:164
BeamMonitor::FitAndFill
void FitAndFill(const edm::LuminosityBlock &lumiSeg, int &, int &, int &)
Definition: BeamMonitor.cc:790
AlcaSiPixelAliHarvester0T_cff.options
options
Definition: AlcaSiPixelAliHarvester0T_cff.py:42
BeamMonitor::fitNLumi_
int fitNLumi_
Definition: BeamMonitor.h:77
BeamMonitor::countLumi_
int countLumi_
Definition: BeamMonitor.h:89
BeamMonitor::scrollTH1
void scrollTH1(TH1 *, std::time_t)
Definition: BeamMonitor.cc:1493
BeamMonitor::dxMax_
const double dxMax_
Definition: BeamMonitor.h:57
dqm::impl::MonitorElement::getMean
virtual double getMean(int axis=1) const
get mean value of histogram along x, y or z axis (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:549
BeamMonitor::resetHistos_
bool resetHistos_
Definition: BeamMonitor.h:108
BeamMonitor::h_PVy
MonitorElement * h_PVy[2]
Definition: BeamMonitor.h:142
BeamMonitor::mapLSPVStoreSize
std::map< int, size_t > mapLSPVStoreSize
Definition: BeamMonitor.h:157
BeamMonitor::h_trkPt
MonitorElement * h_trkPt
Definition: BeamMonitor.h:130
HLT_2018_cff.track
track
Definition: HLT_2018_cff.py:10352
BeamSpotOnlineObjects::SetLastAnalyzedRun
void SetLastAnalyzedRun(int val)
Definition: BeamSpotOnlineObjects.h:47
BeamMonitor::h_trkVz
MonitorElement * h_trkVz
Definition: BeamMonitor.h:131
BeamSpotObjects::SetBeamWidthXError
void SetBeamWidthXError(double val)
set beam width X error
Definition: BeamSpotObjects.h:52
BeamSpotOnlineObjects.h
BeamMonitor::hltSrc_
edm::EDGetTokenT< edm::TriggerResults > hltSrc_
Definition: BeamMonitor.h:75
ConsumesCollector.h
BeamMonitor::phiMax_
const double phiMax_
Definition: BeamMonitor.h:65
genParticles_cff.map
map
Definition: genParticles_cff.py:11
BeamSpotObjects::SetBeamWidthYError
void SetBeamWidthYError(double val)
set beam width Y error
Definition: BeamSpotObjects.h:54
View.h
BeamMonitor::nthBSTrk_
unsigned int nthBSTrk_
Definition: BeamMonitor.h:98
dqm::impl::MonitorElement::getMeanError
virtual double getMeanError(int axis=1) const
Definition: MonitorElement.cc:556
TrackCandidate.h
BeamMonitor::h_trk_z0
MonitorElement * h_trk_z0
Definition: BeamMonitor.h:126
BeamMonitor::h_d0_phi0
MonitorElement * h_d0_phi0
Definition: BeamMonitor.h:125
dqmiolumiharvest.j
j
Definition: dqmiolumiharvest.py:66
BeamMonitor::beginLuminosityBlock
void beginLuminosityBlock(const edm::LuminosityBlock &lumiSeg, const edm::EventSetup &context) override
Definition: BeamMonitor.cc:518
BSFitter.h
ntuplemaker.time
time
Definition: ntuplemaker.py:310
BeamMonitor::min_Ntrks_
unsigned int min_Ntrks_
Definition: BeamMonitor.h:102
hltrates_dqm_sourceclient-live_cfg.offset
offset
Definition: hltrates_dqm_sourceclient-live_cfg.py:78
BeamMonitor::nFitElements_
int nFitElements_
Definition: BeamMonitor.h:99
BeamMonitor::mapBeginBSLS
std::map< int, int > mapBeginBSLS
Definition: BeamMonitor.h:153
edm::Event
Definition: Event.h:73
BeamMonitor::summarySum_
Float_t summarySum_
Definition: BeamMonitor.h:163
DeadROC_duringRun.f1
f1
Definition: DeadROC_duringRun.py:219
BeamSpotObjects::Setdydz
void Setdydz(double val)
set dydz slope, crossing angle in XZ
Definition: BeamSpotObjects.h:46
BeamMonitor::resetFitNLumi_
int resetFitNLumi_
Definition: BeamMonitor.h:79
edm::RunBase::beginTime
Timestamp const & beginTime() const
Definition: RunBase.h:41
dqm::impl::MonitorElement::setAxisTitle
virtual void setAxisTitle(const std::string &title, int axis=1)
set x-, y- or z-axis title (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:800
BeamMonitor::h_vx_dz
MonitorElement * h_vx_dz
Definition: BeamMonitor.h:128
cuy.ii
ii
Definition: cuy.py:590
edm::InputTag
Definition: InputTag.h:15
begin
#define begin
Definition: vmac.h:32
reco::TrackCollection
std::vector< Track > TrackCollection
collection of Tracks
Definition: TrackFwd.h:14
label
const char * label
Definition: PFTauDecayModeTools.cc:11
cond::service::PoolDBOutputService::currentTime
cond::Time_t currentTime() const
Definition: PoolDBOutputService.cc:179
BeamMonitor::BeamMonitor
BeamMonitor(const edm::ParameterSet &)
Definition: BeamMonitor.cc:95
reco::BeamSpot::BeamWidthY
double BeamWidthY() const
beam width Y
Definition: BeamSpot.h:84
edm::TimeValue_t
unsigned long long TimeValue_t
Definition: Timestamp.h:28
BeamMonitor::dqmEndRun
void dqmEndRun(const edm::Run &r, const edm::EventSetup &c) override
Definition: BeamMonitor.cc:1475
BeamSpotOnlineObjects::SetNumPVs
void SetNumPVs(int val)
Definition: BeamSpotOnlineObjects.cc:63
BeamMonitor::theBeamFitter
std::unique_ptr< BeamFitter > theBeamFitter
Definition: BeamMonitor.h:86
BeamMonitor::mapBeginPVLS
std::map< int, int > mapBeginPVLS
Definition: BeamMonitor.h:153
BeamMonitor::mapPVy
std::map< int, std::vector< float > > mapPVy
Definition: BeamMonitor.h:150
hgcalPlots.ytitle
ytitle
Definition: hgcalPlots.py:1410
Generated for CMSSW Reference Manual by doxygen 1.8.16