CMS 3D CMS Logo
TotemTimingDQMSource.cc
Go to the documentation of this file.
1 /****************************************************************************
2  *
3  * This is a part of CTPPS offline software.
4  * Authors:
5  * Nicola Minafra
6  * Laurent Forthomme
7  *
8  ****************************************************************************/
9 
10 #include "FWCore/Framework/interface/ESHandle.h"
11 #include "FWCore/Framework/interface/Event.h"
12 #include "FWCore/Framework/interface/EventSetup.h"
13 #include "FWCore/Framework/interface/MakerMacros.h"
14 #include "FWCore/Framework/interface/Run.h"
15 #include "FWCore/ParameterSet/interface/ParameterSet.h"
16 #include "FWCore/Utilities/interface/InputTag.h"
17 
18 #include "DQMServices/Core/interface/DQMOneEDAnalyzer.h"
19 #include "DQMServices/Core/interface/DQMStore.h"
20 
21 #include "DataFormats/CTPPSDigi/interface/TotemFEDInfo.h"
22 #include "DataFormats/CTPPSDigi/interface/TotemVFATStatus.h"
23 #include "DataFormats/CTPPSReco/interface/TotemRPLocalTrack.h"
24 #include "DataFormats/Common/interface/DetSetVector.h"
25 #include "DataFormats/FEDRawData/interface/FEDNumbering.h"
26 #include "DataFormats/Provenance/interface/EventRange.h"
27 
28 #include "DataFormats/CTPPSDetId/interface/TotemTimingDetId.h"
29 #include "DataFormats/CTPPSDigi/interface/TotemTimingDigi.h"
30 #include "DataFormats/CTPPSReco/interface/TotemTimingRecHit.h"
31 
32 #include "DataFormats/CTPPSDetId/interface/TotemRPDetId.h"
33 #include "DataFormats/CTPPSReco/interface/TotemRPLocalTrack.h"
34 #include "Geometry/Records/interface/VeryForwardRealGeometryRecord.h"
35 #include "Geometry/VeryForwardGeometryBuilder/interface/CTPPSGeometry.h"
36 
37 #include <string>
38 
39 //----------------------------------------------------------------------------------------------------
40 
41 namespace totemds {
42  struct Cache {
43  std::unordered_map<unsigned int, std::unique_ptr<TH2F>> hitDistribution2dMap;
44 
45  std::unordered_map<unsigned int, unsigned long> hitsCounterMap;
46  };
47 } // namespace totemds
48 
49 class TotemTimingDQMSource : public DQMOneEDAnalyzer<edm::LuminosityBlockCache<totemds::Cache>> {
50 public:
51  TotemTimingDQMSource(const edm::ParameterSet &);
52  ~TotemTimingDQMSource() override;
53 
54 protected:
55  void dqmBeginRun(const edm::Run &, const edm::EventSetup &) override;
56  void bookHistograms(DQMStore::IBooker &, const edm::Run &, const edm::EventSetup &) override;
57  void analyze(const edm::Event &, const edm::EventSetup &) override;
58  std::shared_ptr<totemds::Cache> globalBeginLuminosityBlock(const edm::LuminosityBlock &,
59  const edm::EventSetup &) const override;
60  void globalEndLuminosityBlock(const edm::LuminosityBlock &, const edm::EventSetup &) override;
61 
62 private:
63  // Constants
64  static const double SEC_PER_LUMI_SECTION; // Number of seconds per
65  // lumisection: used to compute hit
66  // rates in Hz
67  static const double LHC_CLOCK_PERIOD_NS;
68  static const double DQM_FRACTION_OF_EVENTS; // approximate fraction of events
69  // sent to DQM stream
70  static const double HIT_RATE_FACTOR; // factor to have real rate in Hz
71  static const double DISPLAY_RESOLUTION_FOR_HITS_MM; // Bin width of histograms
72  // showing hits and tracks
73  // (in mm)
74  static const double INV_DISPLAY_RESOLUTION_FOR_HITS_MM;
75  static const double TOMOGRAPHY_RESOLUTION_MM;
76  static const double SAMPIC_SAMPLING_PERIOD_NS; // ns per HPTDC bin
77  static const double SAMPIC_MAX_NUMBER_OF_SAMPLES;
78  static const double SAMPIC_ADC_V;
79  static const int CTPPS_NUM_OF_ARMS;
80  static const int TOTEM_TIMING_STATION_ID;
81  static const int TOTEM_STATION_210;
82  static const int TOTEM_STATION_220;
83  static const int TOTEM_TIMING_TOP_RP_ID;
84  static const int TOTEM_TIMING_BOT_RP_ID;
85  static const int TOTEM_STRIP_MIN_RP_ID;
86  static const int TOTEM_STRIP_MAX_RP_ID;
87  static const int CTPPS_NEAR_RP_ID;
88  static const int CTPPS_FAR_RP_ID;
89  static const int TOTEM_TIMING_NUM_OF_PLANES;
90  static const int TOTEM_TIMING_NUM_OF_CHANNELS;
91  static const int TOTEM_TIMING_FED_ID_45;
92  static const int TOTEM_TIMING_FED_ID_56;
93  static const float COS_8_DEG;
94  static const float SIN_8_DEG;
95 
96  edm::EDGetTokenT<edm::DetSetVector<TotemRPLocalTrack>> tokenLocalTrack_;
97  edm::EDGetTokenT<edm::DetSetVector<TotemTimingDigi>> tokenDigi_;
98  edm::EDGetTokenT<edm::DetSetVector<TotemTimingRecHit>> tokenRecHit_;
99  // edm::EDGetTokenT<edm::DetSetVector<TotemTimingLocalTrack>> tokenTrack_;
100  edm::EDGetTokenT<std::vector<TotemFEDInfo>> tokenFEDInfo_;
101 
102  double minimumStripAngleForTomography_;
103  double maximumStripAngleForTomography_;
104  unsigned int samplesForNoise_;
105  unsigned int verbosity_;
106  edm::TimeValue_t timeOfPreviousEvent_;
107 
108  float verticalShiftBot_, verticalShiftTop_;
109 
111  struct GlobalPlots {
112  MonitorElement *digiSentPercentage = nullptr;
113 
114  GlobalPlots() {}
115  GlobalPlots(DQMStore::IBooker &ibooker);
116  };
117 
118  GlobalPlots globalPlot_;
119 
121  struct PotPlots {
122  // Digis
123  MonitorElement *activityPerBX = nullptr;
124  MonitorElement *digiDistribution = nullptr;
125  MonitorElement *dataSamplesRaw = nullptr;
126  MonitorElement *baseline = nullptr;
127  MonitorElement *noiseRMS = nullptr;
128 
129  MonitorElement *digiSent = nullptr;
130  MonitorElement *digiAll = nullptr;
131  MonitorElement *digiSentPercentage = nullptr;
132 
133  // RecHits
134  MonitorElement *hitDistribution2d = nullptr;
135  MonitorElement *hitDistribution2dWithTime = nullptr;
136  MonitorElement *hitDistribution2d_lumisection = nullptr;
137 
138  MonitorElement *recHitTime = nullptr;
139  MonitorElement *amplitude = nullptr;
140  MonitorElement *baselineRMS = nullptr;
141  MonitorElement *tirggerCellTime = nullptr;
142  MonitorElement *meanAmplitude = nullptr;
143  MonitorElement *cellOfMax = nullptr;
144 
145  MonitorElement *hitRate = nullptr;
146 
147  MonitorElement *planesWithDigis = nullptr;
148  MonitorElement *planesWithTime = nullptr;
149 
150  // MonitorElement *trackDistribution = nullptr;
151 
152  MonitorElement *stripTomography210 = nullptr;
153  MonitorElement *stripTomography220 = nullptr;
154 
155  std::set<unsigned int> planesWithDigisSet;
156  std::set<unsigned int> planesWithTimeSet;
157 
158  PotPlots(){};
159  PotPlots(DQMStore::IBooker &ibooker, unsigned int id);
160  };
161 
162  std::unordered_map<unsigned int, PotPlots> potPlots_;
163 
165  struct PlanePlots {
166  MonitorElement *digiDistribution = nullptr;
167 
168  MonitorElement *hitProfile = nullptr;
169  MonitorElement *hitMultiplicity = nullptr;
170  MonitorElement *hitMultiplicityWithTime = nullptr;
171 
172  PlanePlots() {}
173  PlanePlots(DQMStore::IBooker &ibooker, unsigned int id);
174  };
175 
176  std::unordered_map<unsigned int, PlanePlots> planePlots_;
177 
179  struct ChannelPlots {
180  // Digis
181  MonitorElement *activityPerBX = nullptr;
182  MonitorElement *dataSamplesRaw = nullptr;
183  MonitorElement *cellOfMax = nullptr;
184  MonitorElement *maxTimeAfterTrigger = nullptr;
185 
186  // RecHits
187  MonitorElement *tirggerCellTime = nullptr;
188  MonitorElement *recHitTime = nullptr;
189  MonitorElement *amplitude = nullptr;
190  MonitorElement *noiseSamples = nullptr;
191 
192  MonitorElement *hitTime = nullptr;
193  MonitorElement *hitRate = nullptr;
194 
195  MonitorElement *stripTomography210 = nullptr;
196  MonitorElement *stripTomography220 = nullptr;
197 
198  ChannelPlots() {}
199  ChannelPlots(DQMStore::IBooker &ibooker, unsigned int id);
200  };
201 
202  std::unordered_map<unsigned int, ChannelPlots> channelPlots_;
203 };
204 
205 //----------------------------------------------------------------------------------------------------
206 
207 // Values for all constants
208 const double TotemTimingDQMSource::SEC_PER_LUMI_SECTION = 23.31;
209 const double TotemTimingDQMSource::LHC_CLOCK_PERIOD_NS = 24.95;
210 const double TotemTimingDQMSource::DQM_FRACTION_OF_EVENTS = 1.;
211 const double TotemTimingDQMSource::HIT_RATE_FACTOR = DQM_FRACTION_OF_EVENTS / SEC_PER_LUMI_SECTION;
212 const double TotemTimingDQMSource::DISPLAY_RESOLUTION_FOR_HITS_MM = 0.1;
213 const double TotemTimingDQMSource::INV_DISPLAY_RESOLUTION_FOR_HITS_MM = 1. / DISPLAY_RESOLUTION_FOR_HITS_MM;
214 const double TotemTimingDQMSource::TOMOGRAPHY_RESOLUTION_MM = 1;
215 const double TotemTimingDQMSource::SAMPIC_SAMPLING_PERIOD_NS = 1. / 7.8e9;
216 const double TotemTimingDQMSource::SAMPIC_MAX_NUMBER_OF_SAMPLES = 64;
217 const double TotemTimingDQMSource::SAMPIC_ADC_V = 1. / 256;
218 const int TotemTimingDQMSource::CTPPS_NUM_OF_ARMS = 2;
219 const int TotemTimingDQMSource::TOTEM_TIMING_STATION_ID = 2;
220 const int TotemTimingDQMSource::TOTEM_STATION_210 = 0;
221 const int TotemTimingDQMSource::TOTEM_STATION_220 = 2;
222 const int TotemTimingDQMSource::TOTEM_TIMING_TOP_RP_ID = 0;
223 const int TotemTimingDQMSource::TOTEM_TIMING_BOT_RP_ID = 1;
224 const int TotemTimingDQMSource::TOTEM_STRIP_MIN_RP_ID = 4;
225 const int TotemTimingDQMSource::TOTEM_STRIP_MAX_RP_ID = 5;
226 const int TotemTimingDQMSource::CTPPS_NEAR_RP_ID = 2;
227 const int TotemTimingDQMSource::CTPPS_FAR_RP_ID = 3;
228 const int TotemTimingDQMSource::TOTEM_TIMING_NUM_OF_PLANES = 4;
229 const int TotemTimingDQMSource::TOTEM_TIMING_NUM_OF_CHANNELS = 12;
230 const int TotemTimingDQMSource::TOTEM_TIMING_FED_ID_45 = FEDNumbering::MAXTotemRPTimingVerticalFEDID;
231 const int TotemTimingDQMSource::TOTEM_TIMING_FED_ID_56 = FEDNumbering::MINTotemRPTimingVerticalFEDID;
232 const float TotemTimingDQMSource::COS_8_DEG = 0.990268;
233 const float TotemTimingDQMSource::SIN_8_DEG = -0.139173;
234 
235 //----------------------------------------------------------------------------------------------------
236 
237 TotemTimingDQMSource::GlobalPlots::GlobalPlots(DQMStore::IBooker &ibooker) {
238  ibooker.setCurrentFolder("CTPPS/TimingFastSilicon");
239 
240  digiSentPercentage = ibooker.book2D(
241  "sent digis percentage", "sent digis percentage (sampic);board + 0.5 sampic;channel", 14, -0.5, 6.5, 16, 0, 16);
242 }
243 
244 //----------------------------------------------------------------------------------------------------
245 
246 TotemTimingDQMSource::PotPlots::PotPlots(DQMStore::IBooker &ibooker, unsigned int id) {
247  std::string path, title;
248  TotemTimingDetId(id).rpName(path, TotemTimingDetId::nPath);
249  ibooker.setCurrentFolder(path);
250 
251  TotemTimingDetId(id).rpName(title, TotemTimingDetId::nFull);
252 
253  activityPerBX = ibooker.book1D("activity per BX CMS", title + " Activity per BX;Event.BX", 3600, -1.5, 3598. + 0.5);
254 
255  digiDistribution =
256  ibooker.book2D("digi distribution", title + " digi distribution;plane;channel", 10, -0.5, 4.5, 12, 0, 12);
257 
258  dataSamplesRaw = ibooker.book1D("raw Samples", title + " Raw Samples; ADC", 256, 0, 256);
259 
260  baseline = ibooker.book2D("baseline", title + " baseline (V);plane;channel", 10, -0.5, 4.5, 12, 0, 12);
261  noiseRMS = ibooker.book2D("noise RMS", title + " noise RMS (V);plane;channel", 10, -0.5, 4.5, 12, 0, 12);
262 
263  digiSent =
264  ibooker.book2D("digis sent", title + " digi sent (sampic);board + 0.5 sampic;channel", 14, -0.5, 6.5, 16, 0, 16);
265  digiAll =
266  ibooker.book2D("all digis", title + " all digis(sampic);board + 0.5 sampic;channel", 14, -0.5, 6.5, 16, 0, 16);
267  digiSentPercentage = ibooker.book2D("sent digis percentage",
268  title + " sent digis percentage (sampic);board + 0.5 sampic;channel",
269  14,
270  -0.5,
271  6.5,
272  16,
273  0,
274  16);
275 
276  hitDistribution2d = ibooker.book2D("hits in planes",
277  title + " hits in planes;plane number;x (mm)",
278  18,
279  -0.5,
280  4,
281  15. * INV_DISPLAY_RESOLUTION_FOR_HITS_MM,
282  0,
283  15);
284  hitDistribution2dWithTime = ibooker.book2D("hits in planes with time",
285  title + " hits in planes with time;plane number;x (mm)",
286  18,
287  -0.5,
288  4,
289  15. * INV_DISPLAY_RESOLUTION_FOR_HITS_MM,
290  0,
291  15);
292  hitDistribution2d_lumisection = ibooker.book2D("hits in planes lumisection",
293  title + " hits in planes in the last lumisection;plane number;x (mm)",
294  18,
295  -0.5,
296  4,
297  15. * INV_DISPLAY_RESOLUTION_FOR_HITS_MM,
298  0,
299  15);
300 
301  recHitTime = ibooker.book1D("recHit time", title + " time in the recHits; t (ns)", 500, -25, 25);
302  amplitude = ibooker.book1D("amplitude", title + " amplitude above baseline; amplitude (V)", 50, 0, 1);
303  tirggerCellTime = ibooker.book1D("trigger cell time", title + " Trigger Cell Time; t (ns)", 390, -25, 25);
304  baselineRMS = ibooker.book2D("noise RMS", title + " noise RMS (V);plane;channel", 10, -0.5, 4.5, 12, 0, 12);
305  meanAmplitude =
306  ibooker.book2D("mean amplitude", title + " Mean Amplitude (V);plane;channel", 10, -0.5, 4.5, 12, 0, 12);
307  cellOfMax = ibooker.book2D("cell of max", title + " cell of max (0-23);plane;channel", 10, -0.5, 4.5, 12, 0, 12);
308 
309  hitRate = ibooker.book2D("hit rate", title + " hit rate (Hz);plane;channel", 10, -0.5, 4.5, 12, 0, 12);
310 
311  planesWithDigis = ibooker.book1D(
312  "active planes digis", title + " active planes with digis sent (per event);number of active planes", 6, -0.5, 5.5);
313  planesWithTime = ibooker.book1D(
314  "active planes with time", title + " active planes with time (per event);number of active planes", 6, -0.5, 5.5);
315 
316  // trackDistribution = ibooker.book1D( "tracks", title+" tracks;x (mm)",
317  // 19.*INV_DISPLAY_RESOLUTION_FOR_HITS_MM, -1, 18 ); //TODO needs tracks
318 
319  stripTomography210 =
320  ibooker.book2D("tomography 210",
321  title + " tomography (only with time) with strips 210 (all planes);x + 50*plane(mm);y (mm)",
322  190 / TOMOGRAPHY_RESOLUTION_MM,
323  -20,
324  170,
325  25 / TOMOGRAPHY_RESOLUTION_MM,
326  0,
327  25);
328  stripTomography220 =
329  ibooker.book2D("tomography 220",
330  title + " tomography (only with time) with strips 220 (all planes);x + 50*plane(mm);y (mm)",
331  190 / TOMOGRAPHY_RESOLUTION_MM,
332  -20,
333  170,
334  25 / TOMOGRAPHY_RESOLUTION_MM,
335  0,
336  25);
337 }
338 
339 //----------------------------------------------------------------------------------------------------
340 
341 TotemTimingDQMSource::PlanePlots::PlanePlots(DQMStore::IBooker &ibooker, unsigned int id) {
342  std::string path, title;
343  TotemTimingDetId(id).planeName(path, TotemTimingDetId::nPath);
344  ibooker.setCurrentFolder(path);
345 
346  TotemTimingDetId(id).planeName(title, TotemTimingDetId::nFull);
347 
348  digiDistribution = ibooker.book1D("digi distribution", title + " digi distribution;channel", 12, 0, 12);
349 
350  hitProfile = ibooker.book1D("hit distribution with time",
351  title + " hit distribution (with time);y (+ 15 for x>3) (mm)",
352  30. * INV_DISPLAY_RESOLUTION_FOR_HITS_MM,
353  0,
354  30);
355 
356  hitMultiplicity = ibooker.book1D("channels per plane", title + " channels per plane; ch per plane", 13, -0.5, 12.5);
357 
358  hitMultiplicityWithTime = ibooker.book1D(
359  "channels per plane with time", title + " channels per plane with time; ch per plane", 13, -0.5, 12.5);
360 }
361 
362 //----------------------------------------------------------------------------------------------------
363 
364 TotemTimingDQMSource::ChannelPlots::ChannelPlots(DQMStore::IBooker &ibooker, unsigned int id) {
365  std::string path, title;
366  TotemTimingDetId(id).channelName(path, TotemTimingDetId::nPath);
367  ibooker.setCurrentFolder(path);
368 
369  TotemTimingDetId(id).channelName(title, TotemTimingDetId::nFull);
370 
371  activityPerBX = ibooker.book1D("activity per BX", title + " Activity per BX;Event.BX", 1000, -1.5, 998. + 0.5);
372  dataSamplesRaw = ibooker.book1D("raw samples", title + " Raw Samples; ADC", 256, 0, 256);
373  cellOfMax = ibooker.book1D("cell of max", title + " cell of max; cell", 24, 0, 24);
374 
375  tirggerCellTime = ibooker.book1D("sampic trigger time", title + " Sampic Trigger Time; t (ns)", 100, -25, 25);
376  recHitTime = ibooker.book1D("recHit Time", title + " recHit Time; t (ns)", 500, -25, 25);
377  amplitude = ibooker.book1D("amplitude", title + " amplitude above baseline; amplitude (V)", 50, 0, 1);
378  noiseSamples = ibooker.book1D("noise samples", title + " noise samples; V", 50, 0, 1);
379 
380  hitTime = ibooker.book1D("hit time", title + "hit time;t - t_previous (us)", 100, 0, 10000);
381  hitRate = ibooker.book1D("hit rate", title + "hit rate;rate (Hz)", 100, 0, 10000);
382 
383  stripTomography210 = ibooker.book2D("tomography 210",
384  title + " tomography with strips 210;x (mm);y (mm)",
385  20 / TOMOGRAPHY_RESOLUTION_MM,
386  -20,
387  20,
388  25 / TOMOGRAPHY_RESOLUTION_MM,
389  0,
390  25);
391  stripTomography220 = ibooker.book2D("tomography 220",
392  title + " tomography with strips 220;x (mm);y (mm)",
393  20 / TOMOGRAPHY_RESOLUTION_MM,
394  -20,
395  20,
396  25 / TOMOGRAPHY_RESOLUTION_MM,
397  0,
398  25);
399 }
400 
401 //----------------------------------------------------------------------------------------------------
402 
403 TotemTimingDQMSource::TotemTimingDQMSource(const edm::ParameterSet &ps)
404  : tokenLocalTrack_(consumes<edm::DetSetVector<TotemRPLocalTrack>>(ps.getParameter<edm::InputTag>("tagLocalTrack"))),
405  tokenDigi_(consumes<edm::DetSetVector<TotemTimingDigi>>(ps.getParameter<edm::InputTag>("tagDigi"))),
406  tokenRecHit_(consumes<edm::DetSetVector<TotemTimingRecHit>>(ps.getParameter<edm::InputTag>("tagRecHits"))),
407  // tokenTrack_(consumes<edm::DetSetVector<TotemTimingLocalTrack>>(
408  // ps.getParameter<edm::InputTag>("tagLocalTracks"))),
409  tokenFEDInfo_(consumes<std::vector<TotemFEDInfo>>(ps.getParameter<edm::InputTag>("tagFEDInfo"))),
410  minimumStripAngleForTomography_(ps.getParameter<double>("minimumStripAngleForTomography")),
411  maximumStripAngleForTomography_(ps.getParameter<double>("maximumStripAngleForTomography")),
412  samplesForNoise_(ps.getUntrackedParameter<unsigned int>("samplesForNoise", 5)),
413  verbosity_(ps.getUntrackedParameter<unsigned int>("verbosity", 0)),
414  timeOfPreviousEvent_(0) {}
415 
416 //----------------------------------------------------------------------------------------------------
417 
418 TotemTimingDQMSource::~TotemTimingDQMSource() {}
419 
420 //----------------------------------------------------------------------------------------------------
421 
422 void TotemTimingDQMSource::dqmBeginRun(const edm::Run &iRun, const edm::EventSetup &iSetup) {
423  // Get detector shifts from the geometry (if present)
424  edm::ESHandle<CTPPSGeometry> geometry_;
425  iSetup.get<VeryForwardRealGeometryRecord>().get(geometry_);
426  const CTPPSGeometry *geom = geometry_.product();
427  const TotemTimingDetId detid_top(0, TOTEM_TIMING_STATION_ID, TOTEM_TIMING_BOT_RP_ID, 0, 0);
428  const TotemTimingDetId detid_bot(0, TOTEM_TIMING_STATION_ID, TOTEM_TIMING_TOP_RP_ID, 0, 7);
429  verticalShiftTop_ = 0;
430  verticalShiftBot_ = 0;
431  {
432  const DetGeomDesc *det_top = geom->sensorNoThrow(detid_top);
433  if (det_top) {
434  verticalShiftTop_ = det_top->translation().y() + det_top->getDiamondDimensions().yHalfWidth;
435  }
436  const DetGeomDesc *det_bot = geom->sensorNoThrow(detid_bot);
437  if (det_bot)
438  verticalShiftBot_ = det_bot->translation().y() + det_bot->getDiamondDimensions().yHalfWidth;
439  }
440 }
441 
442 //----------------------------------------------------------------------------------------------------
443 
444 void TotemTimingDQMSource::bookHistograms(DQMStore::IBooker &ibooker, const edm::Run &, const edm::EventSetup &) {
445  ibooker.cd();
446  ibooker.setCurrentFolder("CTPPS");
447 
448  globalPlot_ = GlobalPlots(ibooker);
449 
450  for (unsigned short arm = 0; arm < CTPPS_NUM_OF_ARMS; ++arm) {
451  for (unsigned short rp = TOTEM_TIMING_TOP_RP_ID; rp <= TOTEM_TIMING_BOT_RP_ID; ++rp) {
452  const TotemTimingDetId rpId(arm, TOTEM_TIMING_STATION_ID, rp);
453  potPlots_[rpId] = PotPlots(ibooker, rpId);
454  for (unsigned short pl = 0; pl < TOTEM_TIMING_NUM_OF_PLANES; ++pl) {
455  const TotemTimingDetId plId(arm, TOTEM_TIMING_STATION_ID, rp, pl);
456  planePlots_[plId] = PlanePlots(ibooker, plId);
457  for (unsigned short ch = 0; ch < TOTEM_TIMING_NUM_OF_CHANNELS; ++ch) {
458  const TotemTimingDetId chId(arm, TOTEM_TIMING_STATION_ID, rp, pl, ch);
459  channelPlots_[chId] = ChannelPlots(ibooker, chId);
460  }
461  }
462  }
463  }
464 }
465 
466 //----------------------------------------------------------------------------------------------------
467 
468 std::shared_ptr<totemds::Cache> TotemTimingDQMSource::globalBeginLuminosityBlock(const edm::LuminosityBlock &,
469  const edm::EventSetup &) const {
470  auto d = std::make_shared<totemds::Cache>();
471  d->hitDistribution2dMap.reserve(potPlots_.size());
472  for (auto &plot : potPlots_)
473  d->hitDistribution2dMap[plot.first] =
474  std::unique_ptr<TH2F>(static_cast<TH2F *>(plot.second.hitDistribution2d_lumisection->getTH2F()->Clone()));
475  return d;
476 }
477 
478 //----------------------------------------------------------------------------------------------------
479 
480 void TotemTimingDQMSource::analyze(const edm::Event &event, const edm::EventSetup &eventSetup) {
481  // get event setup data
482  edm::ESHandle<CTPPSGeometry> geometry;
483  eventSetup.get<VeryForwardRealGeometryRecord>().get(geometry);
484 
485  // get event data
486  edm::Handle<edm::DetSetVector<TotemRPLocalTrack>> stripTracks;
487  event.getByToken(tokenLocalTrack_, stripTracks);
488 
489  edm::Handle<edm::DetSetVector<TotemTimingDigi>> timingDigis;
490  event.getByToken(tokenDigi_, timingDigis);
491 
492  edm::Handle<std::vector<TotemFEDInfo>> fedInfo;
493  event.getByToken(tokenFEDInfo_, fedInfo);
494 
495  edm::Handle<edm::DetSetVector<TotemTimingRecHit>> timingRecHits;
496  event.getByToken(tokenRecHit_, timingRecHits);
497 
498  // edm::Handle<edm::DetSetVector<TotemTimingLocalTrack>> timingLocalTracks;
499  // event.getByToken(timingLocalTracks, timingLocalTracks);
500 
501  // check validity
502  bool valid = true;
503  valid &= timingDigis.isValid();
504  valid &= fedInfo.isValid();
505 
506  if (!valid) {
507  if (verbosity_) {
508  edm::LogProblem("TotemTimingDQMSource") << "ERROR in TotemTimingDQMSource::analyze > some of the required inputs "
509  "are not valid. Skipping this event.\n"
510  << " timingDigis.isValid = " << timingDigis.isValid() << "\n"
511  << " fedInfo.isValid = " << fedInfo.isValid();
512  }
513 
514  return;
515  }
516 
517  // Using TotemTimingDigi
518  std::set<uint8_t> boardSet;
519  std::unordered_map<unsigned int, unsigned int> channelsPerPlane;
520  std::unordered_map<unsigned int, unsigned int> channelsPerPlaneWithTime;
521 
522  auto lumiCache = luminosityBlockCache(event.getLuminosityBlock().index());
523  for (const auto &digis : *timingDigis) {
524  const TotemTimingDetId detId(digis.detId());
525  TotemTimingDetId detId_pot(digis.detId());
526  detId_pot.setPlane(0);
527  detId_pot.setChannel(0);
528  TotemTimingDetId detId_plane(digis.detId());
529  detId_plane.setChannel(0);
530 
531  for (const auto &digi : digis) {
532  // Pot Plots
533  if (potPlots_.find(detId_pot) != potPlots_.end()) {
534  potPlots_[detId_pot].activityPerBX->Fill(event.bunchCrossing());
535 
536  potPlots_[detId_pot].digiDistribution->Fill(detId.plane(), detId.channel());
537 
538  for (auto it = digi.samplesBegin(); it != digi.samplesEnd(); ++it)
539  potPlots_[detId_pot].dataSamplesRaw->Fill(*it);
540 
541  float boardId = digi.eventInfo().hardwareBoardId() + 0.5 * digi.eventInfo().hardwareSampicId();
542  potPlots_[detId_pot].digiSent->Fill(boardId, digi.hardwareChannelId());
543  if (boardSet.find(digi.eventInfo().hardwareId()) == boardSet.end()) {
544  // This guarantees that every board is counted only once
545  boardSet.insert(digi.eventInfo().hardwareId());
546  std::bitset<16> chMap(digi.eventInfo().channelMap());
547  for (int i = 0; i < 16; ++i) {
548  if (chMap.test(i)) {
549  potPlots_[detId_pot].digiAll->Fill(boardId, i);
550  }
551  }
552  }
553 
554  potPlots_[detId_pot].planesWithDigisSet.insert(detId.plane());
555  }
556 
557  // Plane Plots
558  if (planePlots_.find(detId_plane) != planePlots_.end()) {
559  planePlots_[detId_plane].digiDistribution->Fill(detId.channel());
560 
561  if (channelsPerPlane.find(detId_plane) != channelsPerPlane.end())
562  channelsPerPlane[detId_plane]++;
563  else
564  channelsPerPlane[detId_plane] = 0;
565  }
566 
567  // Channel Plots
568  if (channelPlots_.find(detId) != channelPlots_.end()) {
569  channelPlots_[detId].activityPerBX->Fill(event.bunchCrossing());
570 
571  for (auto it = digi.samplesBegin(); it != digi.samplesEnd(); ++it)
572  channelPlots_[detId].dataSamplesRaw->Fill(*it);
573  for (unsigned short i = 0; i < samplesForNoise_; ++i)
574  channelPlots_[detId].noiseSamples->Fill(SAMPIC_ADC_V * digi.sampleAt(i));
575 
576  unsigned int cellOfMax = std::max_element(digi.samplesBegin(), digi.samplesEnd()) - digi.samplesBegin();
577  channelPlots_[detId].cellOfMax->Fill((int)cellOfMax);
578 
579  if (timeOfPreviousEvent_ != 0)
580  channelPlots_[detId].hitTime->Fill(1e-3 * LHC_CLOCK_PERIOD_NS *
581  (event.time().value() - timeOfPreviousEvent_));
582  ++(lumiCache->hitsCounterMap[detId]);
583  }
584  }
585  }
586  // End digis
587 
588  for (const auto &rechits : *timingRecHits) {
589  const TotemTimingDetId detId(rechits.detId());
590  TotemTimingDetId detId_pot(rechits.detId());
591  detId_pot.setPlane(0);
592  detId_pot.setChannel(0);
593  TotemTimingDetId detId_plane(rechits.detId());
594  detId_plane.setChannel(0);
595 
596  for (const auto &rechit : rechits) {
597  if (potPlots_.find(detId_pot) != potPlots_.end()) {
598  potPlots_[detId_pot].amplitude->Fill(rechit.amplitude());
599 
600  TH2F *hitHistoTmp = potPlots_[detId_pot].hitDistribution2d->getTH2F();
601  TAxis *hitHistoTmpYAxis = hitHistoTmp->GetYaxis();
602  float yCorrected = rechit.y();
603  yCorrected += (detId.rp() == TOTEM_TIMING_TOP_RP_ID) ? verticalShiftTop_ : verticalShiftBot_;
604  float x_shift = detId.plane();
605  x_shift += (rechit.x() > 2) ? 0.25 : 0;
606  int startBin = hitHistoTmpYAxis->FindBin(yCorrected - 0.5 * rechit.yWidth());
607  int numOfBins = rechit.yWidth() * INV_DISPLAY_RESOLUTION_FOR_HITS_MM;
608  for (int i = 0; i < numOfBins; ++i) {
609  potPlots_[detId_pot].hitDistribution2d->Fill(detId.plane() + 0.25 * (rechit.x() > 2),
610  hitHistoTmpYAxis->GetBinCenter(startBin + i));
611  potPlots_[detId_pot].hitDistribution2d_lumisection->Fill(x_shift,
612  hitHistoTmpYAxis->GetBinCenter(startBin + i));
613  }
614 
615  //All plots with Time
616  if (rechit.time() != TotemTimingRecHit::NO_T_AVAILABLE) {
617  for (int i = 0; i < numOfBins; ++i)
618  potPlots_[detId_pot].hitDistribution2dWithTime->Fill(detId.plane() + 0.25 * (rechit.x() > 2),
619  hitHistoTmpYAxis->GetBinCenter(startBin + i));
620 
621  potPlots_[detId_pot].recHitTime->Fill(rechit.time());
622  potPlots_[detId_pot].planesWithTimeSet.insert(detId.plane());
623 
624  // Plane Plots
625  if (planePlots_.find(detId_plane) != planePlots_.end()) {
626  // Visualization tricks
627  float x_shift = (rechit.x() > 2) ? 15 : 0;
628  TH1F *hitProfileHistoTmp = planePlots_[detId_plane].hitProfile->getTH1F();
629  int numOfBins = rechit.yWidth() * INV_DISPLAY_RESOLUTION_FOR_HITS_MM;
630  if (detId.rp() == TOTEM_TIMING_TOP_RP_ID) {
631  float yCorrected = rechit.y() + verticalShiftTop_ - 0.5 * rechit.yWidth() + x_shift;
632  int startBin = hitProfileHistoTmp->FindBin(yCorrected);
633  for (int i = 0; i < numOfBins; ++i)
634  hitProfileHistoTmp->Fill(hitProfileHistoTmp->GetBinCenter(startBin + i));
635  } else {
636  float yCorrected = rechit.y() + verticalShiftBot_ + 0.5 * rechit.yWidth() + (15 - x_shift);
637  int startBin = hitProfileHistoTmp->FindBin(yCorrected);
638  int totBins = hitProfileHistoTmp->GetNbinsX();
639  for (int i = 0; i < numOfBins; ++i)
640  hitProfileHistoTmp->Fill(hitProfileHistoTmp->GetBinCenter(totBins - startBin + i));
641  }
642 
643  if (channelsPerPlaneWithTime.find(detId_plane) != channelsPerPlaneWithTime.end())
644  channelsPerPlaneWithTime[detId_plane]++;
645  else
646  channelsPerPlaneWithTime[detId_plane] = 0;
647  }
648 
649  if (channelPlots_.find(detId) != channelPlots_.end()) {
650  potPlots_[detId_pot].tirggerCellTime->Fill(rechit.sampicThresholdTime());
651  channelPlots_[detId].tirggerCellTime->Fill(rechit.sampicThresholdTime());
652  channelPlots_[detId].recHitTime->Fill(rechit.time());
653  channelPlots_[detId].amplitude->Fill(rechit.amplitude());
654  }
655  }
656  }
657  }
658  }
659  // End RecHits
660 
661  // Tomography of timing using strips
662  for (const auto &rechits : *timingRecHits) {
663  const TotemTimingDetId detId(rechits.detId());
664  TotemTimingDetId detId_pot(rechits.detId());
665  detId_pot.setPlane(0);
666  detId_pot.setChannel(0);
667  TotemTimingDetId detId_plane(rechits.detId());
668  detId_plane.setChannel(0);
669 
670  float y_shift = (detId.rp() == TOTEM_TIMING_TOP_RP_ID) ? 20 : 5;
671 
672  for (const auto &rechit : rechits) {
673  if (rechit.time() != TotemTimingRecHit::NO_T_AVAILABLE && potPlots_.find(detId_pot) != potPlots_.end() &&
674  planePlots_.find(detId_plane) != planePlots_.end() && channelPlots_.find(detId) != channelPlots_.end()) {
675  if (stripTracks.isValid()) {
676  for (const auto &ds : *stripTracks) {
677  const CTPPSDetId stripId(ds.detId());
678  // mean position of U and V planes
679  TotemRPDetId plId_V(stripId);
680  plId_V.setPlane(0);
681  TotemRPDetId plId_U(stripId);
682  plId_U.setPlane(1);
683 
684  double rp_x = 0;
685  double rp_y = 0;
686  try {
687  rp_x = (geometry->sensor(plId_V)->translation().x() + geometry->sensor(plId_U)->translation().x()) / 2;
688  rp_y = (geometry->sensor(plId_V)->translation().y() + geometry->sensor(plId_U)->translation().y()) / 2;
689  } catch (const cms::Exception &) {
690  continue;
691  }
692 
693  for (const auto &striplt : ds) {
694  if (striplt.isValid() && stripId.arm() == detId.arm()) {
695  if (striplt.tx() > maximumStripAngleForTomography_ || striplt.ty() > maximumStripAngleForTomography_)
696  continue;
697  if (striplt.tx() < minimumStripAngleForTomography_ || striplt.ty() < minimumStripAngleForTomography_)
698  continue;
699  if (stripId.rp() - detId.rp() == (TOTEM_STRIP_MAX_RP_ID - TOTEM_TIMING_BOT_RP_ID)) {
700  double x = striplt.x0() - rp_x;
701  double y = striplt.y0() - rp_y;
702  if (stripId.station() == TOTEM_STATION_210) {
703  potPlots_[detId_pot].stripTomography210->Fill(x + detId.plane() * 50, y + y_shift);
704  channelPlots_[detId].stripTomography210->Fill(x, y + y_shift);
705  } else if (stripId.station() == TOTEM_STATION_220) {
706  potPlots_[detId_pot].stripTomography220->Fill(x + detId.plane() * 50, y + y_shift);
707  channelPlots_[detId].stripTomography220->Fill(x, y + y_shift);
708  }
709  }
710  }
711  }
712  }
713  }
714  }
715  }
716  }
717 
718  for (auto &plt : potPlots_) {
719  plt.second.planesWithDigis->Fill(plt.second.planesWithDigisSet.size());
720  plt.second.planesWithDigisSet.clear();
721  plt.second.planesWithTime->Fill(plt.second.planesWithTimeSet.size());
722  plt.second.planesWithTimeSet.clear();
723  }
724 
725  for (const auto &plt : channelsPerPlane) {
726  planePlots_[plt.first].hitMultiplicity->Fill(plt.second);
727  }
728  for (const auto &plt : channelsPerPlaneWithTime) {
729  planePlots_[plt.first].hitMultiplicityWithTime->Fill(plt.second);
730  }
731 
732  timeOfPreviousEvent_ = event.time().value();
733 }
734 
735 //----------------------------------------------------------------------------------------------------
736 
737 void TotemTimingDQMSource::globalEndLuminosityBlock(const edm::LuminosityBlock &iLumi, const edm::EventSetup &) {
738  auto lumiCache = luminosityBlockCache(iLumi.index());
739  for (auto &plot : potPlots_) {
740  *(plot.second.hitDistribution2d_lumisection->getTH2F()) = *(lumiCache->hitDistribution2dMap[plot.first]);
741  }
742 
743  globalPlot_.digiSentPercentage->Reset();
744  TH2F *hitHistoGlobalTmp = globalPlot_.digiSentPercentage->getTH2F();
745  for (auto &plot : potPlots_) {
746  TH2F *hitHistoTmp = plot.second.digiSentPercentage->getTH2F();
747  TH2F *histoSent = plot.second.digiSent->getTH2F();
748  TH2F *histoAll = plot.second.digiAll->getTH2F();
749 
750  hitHistoTmp->Divide(histoSent, histoAll);
751  hitHistoTmp->Scale(100);
752  hitHistoGlobalTmp->Add(hitHistoTmp, 1);
753 
754  plot.second.baseline->Reset();
755  plot.second.noiseRMS->Reset();
756  plot.second.meanAmplitude->Reset();
757  plot.second.cellOfMax->Reset();
758  plot.second.hitRate->Reset();
759  TotemTimingDetId rpId(plot.first);
760  for (auto &chPlot : channelPlots_) {
761  TotemTimingDetId chId(chPlot.first);
762  if (chId.arm() == rpId.arm() && chId.rp() == rpId.rp()) {
763  plot.second.baseline->Fill(chId.plane(), chId.channel(), chPlot.second.noiseSamples->getTH1F()->GetMean());
764  plot.second.noiseRMS->Fill(chId.plane(), chId.channel(), chPlot.second.noiseSamples->getTH1F()->GetRMS());
765  plot.second.meanAmplitude->Fill(chId.plane(), chId.channel(), chPlot.second.amplitude->getTH1F()->GetMean());
766  plot.second.cellOfMax->Fill(chId.plane(), chId.channel(), chPlot.second.cellOfMax->getTH1F()->GetMean());
767  auto hitsCounterPerLumisection = lumiCache->hitsCounterMap[chPlot.first];
768  plot.second.hitRate->Fill(chId.plane(), chId.channel(), (double)hitsCounterPerLumisection * HIT_RATE_FACTOR);
769  }
770  }
771  }
772 
773  for (auto &plot : channelPlots_) {
774  auto hitsCounterPerLumisection = lumiCache->hitsCounterMap[plot.first];
775  if (hitsCounterPerLumisection != 0) {
776  plot.second.hitRate->Fill((double)hitsCounterPerLumisection * HIT_RATE_FACTOR);
777  }
778  }
779 }
780 
781 DEFINE_FWK_MODULE(TotemTimingDQMSource);
VeryForwardRealGeometryRecord
Event setup record containing the real (actual) geometry information.
Definition: VeryForwardRealGeometryRecord.h:22
FEDNumbering.h
edm::ESHandle::product
T const * product() const
Definition: ESHandle.h:86
TotemTimingDQMSource::PlanePlots
plots related to one Diamond plane
Definition: TotemTimingDQMSource.cc:164
TotemTimingDQMSource::globalEndLuminosityBlock
void globalEndLuminosityBlock(const edm::LuminosityBlock &, const edm::EventSetup &) override
Definition: TotemTimingDQMSource.cc:736
TotemTimingDQMSource::PotPlots::planesWithTime
MonitorElement * planesWithTime
Definition: TotemTimingDQMSource.cc:147
dqm::impl::MonitorElement
Definition: MonitorElement.h:98
DDAxes::y
CTPPSDetId::rp
uint32_t rp() const
Definition: CTPPSDetId.h:69
geometry
ESHandle< TrackerGeometry > geometry
Definition: TkLasBeamFitter.cc:200
TotemTimingDetId::channel
uint32_t channel() const
Definition: TotemTimingDetId.h:56
runGCPTkAlMap.title
string title
Definition: runGCPTkAlMap.py:94
mps_fire.i
i
Definition: mps_fire.py:428
TotemTimingDQMSource::PotPlots::baselineRMS
MonitorElement * baselineRMS
Definition: TotemTimingDQMSource.cc:139
TotemTimingDQMSource::dqmBeginRun
void dqmBeginRun(const edm::Run &, const edm::EventSetup &) override
Definition: TotemTimingDQMSource.cc:421
amcDumpToRaw_cfi.boardId
boardId
Definition: amcDumpToRaw_cfi.py:9
CustomPhysics_cfi.amplitude
amplitude
Definition: CustomPhysics_cfi.py:12
CTPPSGeometry
The manager class for TOTEM RP geometry.
Definition: CTPPSGeometry.h:29
ESHandle.h
DetGeomDesc::translation
const Translation & translation() const
Definition: DetGeomDesc.h:73
TotemTimingDQMSource::ChannelPlots::activityPerBX
MonitorElement * activityPerBX
Definition: TotemTimingDQMSource.cc:180
edm::LuminosityBlock
Definition: LuminosityBlock.h:50
TotemTimingDQMSource::TOTEM_TIMING_NUM_OF_PLANES
static const int TOTEM_TIMING_NUM_OF_PLANES
Definition: TotemTimingDQMSource.cc:88
edm::Run
Definition: Run.h:45
TotemTimingDQMSource::ChannelPlots::recHitTime
MonitorElement * recHitTime
Definition: TotemTimingDQMSource.cc:187
edm::EDGetTokenT
Definition: EDGetToken.h:33
TotemTimingDQMSource::CTPPS_NEAR_RP_ID
static const int CTPPS_NEAR_RP_ID
Definition: TotemTimingDQMSource.cc:86
edm::LuminosityBlock::index
LuminosityBlockIndex index() const
Definition: LuminosityBlock.cc:27
edm
HLT enums.
Definition: AlignableModifier.h:19
TotemTimingDQMSource::verticalShiftBot_
float verticalShiftBot_
Definition: TotemTimingDQMSource.cc:107
geometry
Definition: geometry.py:1
totemds::Cache::hitsCounterMap
std::unordered_map< unsigned int, unsigned long > hitsCounterMap
Definition: TotemTimingDQMSource.cc:56
HLT_FULL_cff.InputTag
InputTag
Definition: HLT_FULL_cff.py:89287
TotemTimingDigi.h
TotemTimingDQMSource::ChannelPlots::hitTime
MonitorElement * hitTime
Definition: TotemTimingDQMSource.cc:191
dqm::implementation::NavigatorBase::setCurrentFolder
virtual void setCurrentFolder(std::string const &fullpath)
Definition: DQMStore.cc:32
TotemTimingDQMSource::HIT_RATE_FACTOR
static const double HIT_RATE_FACTOR
Definition: TotemTimingDQMSource.cc:69
DQMOneEDAnalyzer
Definition: DQMOneEDAnalyzer.h:20
TotemTimingDQMSource::COS_8_DEG
static const float COS_8_DEG
Definition: TotemTimingDQMSource.cc:92
TotemTimingDQMSource::TOTEM_TIMING_FED_ID_45
static const int TOTEM_TIMING_FED_ID_45
Definition: TotemTimingDQMSource.cc:90
DQMStore.h
FEDNumbering::MAXTotemRPTimingVerticalFEDID
Definition: FEDNumbering.h:42
TotemTimingDQMSource::PotPlots::meanAmplitude
MonitorElement * meanAmplitude
Definition: TotemTimingDQMSource.cc:141
TotemTimingDetId::plane
uint32_t plane() const
Definition: TotemTimingDetId.h:49
TotemTimingDQMSource::ChannelPlots::cellOfMax
MonitorElement * cellOfMax
Definition: TotemTimingDQMSource.cc:182
DDAxes::x
TotemTimingRecHit.h
totemds::Cache::hitDistribution2dMap
std::unordered_map< unsigned int, std::unique_ptr< TH2F > > hitDistribution2dMap
Definition: TotemTimingDQMSource.cc:54
TotemTimingDQMSource::CTPPS_NUM_OF_ARMS
static const int CTPPS_NUM_OF_ARMS
Definition: TotemTimingDQMSource.cc:78
TotemTimingDQMSource::PotPlots::stripTomography220
MonitorElement * stripTomography220
Definition: TotemTimingDQMSource.cc:152
year_2016_postTS2_cff.rpId
rpId
Definition: year_2016_postTS2_cff.py:23
TotemTimingDQMSource::PlanePlots::hitMultiplicity
MonitorElement * hitMultiplicity
Definition: TotemTimingDQMSource.cc:168
TotemTimingDQMSource::GlobalPlots::GlobalPlots
GlobalPlots()
Definition: TotemTimingDQMSource.cc:113
edm::Handle
Definition: AssociativeIterator.h:50
TotemTimingDQMSource::PlanePlots::hitProfile
MonitorElement * hitProfile
Definition: TotemTimingDQMSource.cc:167
plotFactory.plot
plot
Definition: plotFactory.py:109
CTPPSDetId::nPath
Definition: CTPPSDetId.h:87
TotemTimingDQMSource::PotPlots::planesWithTimeSet
std::set< unsigned int > planesWithTimeSet
Definition: TotemTimingDQMSource.cc:155
TotemTimingDQMSource::channelPlots_
std::unordered_map< unsigned int, ChannelPlots > channelPlots_
Definition: TotemTimingDQMSource.cc:201
TotemRPDetId::setPlane
void setPlane(uint32_t det)
Definition: TotemRPDetId.h:53
TotemTimingDQMSource::timeOfPreviousEvent_
edm::TimeValue_t timeOfPreviousEvent_
Definition: TotemTimingDQMSource.cc:105
TotemTimingDQMSource::PlanePlots::hitMultiplicityWithTime
MonitorElement * hitMultiplicityWithTime
Definition: TotemTimingDQMSource.cc:169
TotemTimingDQMSource::analyze
void analyze(const edm::Event &, const edm::EventSetup &) override
Definition: TotemTimingDQMSource.cc:479
DQMOneEDAnalyzer.h
TotemTimingDQMSource::SEC_PER_LUMI_SECTION
static const double SEC_PER_LUMI_SECTION
Definition: TotemTimingDQMSource.cc:63
TotemTimingDQMSource::PotPlots
plots related to one Diamond detector package
Definition: TotemTimingDQMSource.cc:120
TotemTimingDQMSource::DISPLAY_RESOLUTION_FOR_HITS_MM
static const double DISPLAY_RESOLUTION_FOR_HITS_MM
Definition: TotemTimingDQMSource.cc:70
TotemTimingDQMSource::planePlots_
std::unordered_map< unsigned int, PlanePlots > planePlots_
Definition: TotemTimingDQMSource.cc:175
TotemTimingDQMSource::TOTEM_TIMING_BOT_RP_ID
static const int TOTEM_TIMING_BOT_RP_ID
Definition: TotemTimingDQMSource.cc:83
TotemTimingDQMSource::ChannelPlots::stripTomography210
MonitorElement * stripTomography210
Definition: TotemTimingDQMSource.cc:194
dqm::impl::MonitorElement::getTH2F
virtual TH2F * getTH2F()
Definition: MonitorElement.cc:992
CTPPSGeometry.h
MakerMacros.h
TotemTimingDQMSource::verbosity_
unsigned int verbosity_
Definition: TotemTimingDQMSource.cc:104
TotemTimingDQMSource::PotPlots::baseline
MonitorElement * baseline
Definition: TotemTimingDQMSource.cc:125
TotemTimingDQMSource::SAMPIC_ADC_V
static const double SAMPIC_ADC_V
Definition: TotemTimingDQMSource.cc:77
edm::EventSetup::get
T get() const
Definition: EventSetup.h:80
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:16
TotemTimingDQMSource::PotPlots::noiseRMS
MonitorElement * noiseRMS
Definition: TotemTimingDQMSource.cc:126
TotemTimingDQMSource::ChannelPlots
plots related to one Diamond channel
Definition: TotemTimingDQMSource.cc:178
TotemTimingDigi
Definition: TotemTimingDigi.h:19
edm::LogProblem
Log< level::Error, true > LogProblem
Definition: MessageLogger.h:131
totemds::Cache
Definition: TotemTimingDQMSource.cc:47
TotemTimingDetId.h
TotemTimingDQMSource::PotPlots::digiSentPercentage
MonitorElement * digiSentPercentage
Definition: TotemTimingDQMSource.cc:130
DetGeomDesc::getDiamondDimensions
const DiamondDimensions & getDiamondDimensions() const
Definition: DetGeomDesc.h:82
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
Run.h
TotemTimingDQMSource::TOMOGRAPHY_RESOLUTION_MM
static const double TOMOGRAPHY_RESOLUTION_MM
Definition: TotemTimingDQMSource.cc:74
TotemTimingDQMSource::PotPlots::digiSent
MonitorElement * digiSent
Definition: TotemTimingDQMSource.cc:128
edm::ESHandle< CTPPSGeometry >
dqm::implementation::NavigatorBase::cd
virtual void cd()
Definition: DQMStore.cc:29
TotemTimingDQMSource::DQM_FRACTION_OF_EVENTS
static const double DQM_FRACTION_OF_EVENTS
Definition: TotemTimingDQMSource.cc:67
TotemTimingDQMSource::PotPlots::tirggerCellTime
MonitorElement * tirggerCellTime
Definition: TotemTimingDQMSource.cc:140
relativeConstraints.geom
geom
Definition: relativeConstraints.py:72
HI_PhotonSkim_cff.rechits
rechits
Definition: HI_PhotonSkim_cff.py:76
TotemTimingDQMSource::PotPlots::amplitude
MonitorElement * amplitude
Definition: TotemTimingDQMSource.cc:138
TotemTimingRecHit
Definition: TotemTimingRecHit.h:16
TotemTimingDQMSource::PotPlots::stripTomography210
MonitorElement * stripTomography210
Definition: TotemTimingDQMSource.cc:151
TotemTimingDQMSource::PlanePlots::digiDistribution
MonitorElement * digiDistribution
Definition: TotemTimingDQMSource.cc:165
TotemTimingDQMSource::PotPlots::hitDistribution2d_lumisection
MonitorElement * hitDistribution2d_lumisection
Definition: TotemTimingDQMSource.cc:135
TotemTimingDQMSource::PotPlots::hitDistribution2dWithTime
MonitorElement * hitDistribution2dWithTime
Definition: TotemTimingDQMSource.cc:134
TotemVFATStatus.h
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
TotemTimingDQMSource::PotPlots::hitRate
MonitorElement * hitRate
Definition: TotemTimingDQMSource.cc:144
TotemTimingDQMSource::globalPlot_
GlobalPlots globalPlot_
Definition: TotemTimingDQMSource.cc:117
CTPPSDetId::arm
uint32_t arm() const
Definition: CTPPSDetId.h:55
TotemTimingDQMSource::TotemTimingDQMSource
TotemTimingDQMSource(const edm::ParameterSet &)
Definition: TotemTimingDQMSource.cc:402
TotemTimingDQMSource
Definition: TotemTimingDQMSource.cc:48
TotemTimingDetId
Detector ID class for CTPPS Totem Timing detectors. Bits [19:31] : Assigend in CTPPSDetId Calss Bits ...
Definition: TotemTimingDetId.h:26
TotemTimingDQMSource::TOTEM_TIMING_FED_ID_56
static const int TOTEM_TIMING_FED_ID_56
Definition: TotemTimingDQMSource.cc:91
TotemTimingDQMSource::ChannelPlots::hitRate
MonitorElement * hitRate
Definition: TotemTimingDQMSource.cc:192
TotemTimingDetId::setChannel
void setChannel(uint32_t channel)
Definition: TotemTimingDetId.h:58
edm::ParameterSet
Definition: ParameterSet.h:47
TotemTimingDQMSource::~TotemTimingDQMSource
~TotemTimingDQMSource() override
Definition: TotemTimingDQMSource.cc:417
TotemTimingDQMSource::GlobalPlots
plots related to the whole system
Definition: TotemTimingDQMSource.cc:110
Event.h
TotemTimingDQMSource::tokenDigi_
edm::EDGetTokenT< edm::DetSetVector< TotemTimingDigi > > tokenDigi_
Definition: TotemTimingDQMSource.cc:96
TotemTimingDQMSource::ChannelPlots::amplitude
MonitorElement * amplitude
Definition: TotemTimingDQMSource.cc:188
TotemTimingDQMSource::ChannelPlots::dataSamplesRaw
MonitorElement * dataSamplesRaw
Definition: TotemTimingDQMSource.cc:181
totemds
Definition: TotemTimingDQMSource.cc:40
TotemTimingDQMSource::PotPlots::activityPerBX
MonitorElement * activityPerBX
Definition: TotemTimingDQMSource.cc:122
TotemTimingDQMSource::tokenLocalTrack_
edm::EDGetTokenT< edm::DetSetVector< TotemRPLocalTrack > > tokenLocalTrack_
Definition: TotemTimingDQMSource.cc:95
CTPPSDetId::nFull
Definition: CTPPSDetId.h:87
CTPPSDetId
Base class for CTPPS detector IDs.
Definition: CTPPSDetId.h:31
createfilelist.int
int
Definition: createfilelist.py:10
DetGeomDesc
Definition: DetGeomDesc.h:49
TotemTimingDQMSource::ChannelPlots::noiseSamples
MonitorElement * noiseSamples
Definition: TotemTimingDQMSource.cc:189
TotemTimingDQMSource::PotPlots::hitDistribution2d
MonitorElement * hitDistribution2d
Definition: TotemTimingDQMSource.cc:133
TotemTimingDQMSource::SAMPIC_MAX_NUMBER_OF_SAMPLES
static const double SAMPIC_MAX_NUMBER_OF_SAMPLES
Definition: TotemTimingDQMSource.cc:76
DiamondDimensions::yHalfWidth
double yHalfWidth
Definition: DetGeomDesc.h:45
TotemTimingDQMSource::INV_DISPLAY_RESOLUTION_FOR_HITS_MM
static const double INV_DISPLAY_RESOLUTION_FOR_HITS_MM
Definition: TotemTimingDQMSource.cc:73
trackerHitRTTI::vector
Definition: trackerHitRTTI.h:21
TotemTimingDQMSource::samplesForNoise_
unsigned int samplesForNoise_
Definition: TotemTimingDQMSource.cc:103
edm::EventSetup
Definition: EventSetup.h:57
TotemTimingDQMSource::PlanePlots::PlanePlots
PlanePlots()
Definition: TotemTimingDQMSource.cc:171
TotemTimingDQMSource::PotPlots::digiAll
MonitorElement * digiAll
Definition: TotemTimingDQMSource.cc:129
TotemTimingDQMSource::TOTEM_STATION_220
static const int TOTEM_STATION_220
Definition: TotemTimingDQMSource.cc:81
DetSetVector.h
TotemTimingDQMSource::ChannelPlots::stripTomography220
MonitorElement * stripTomography220
Definition: TotemTimingDQMSource.cc:195
TotemTimingDQMSource::TOTEM_STATION_210
static const int TOTEM_STATION_210
Definition: TotemTimingDQMSource.cc:80
get
#define get
TotemTimingRecHit::NO_T_AVAILABLE
Definition: TotemTimingRecHit.h:25
VeryForwardRealGeometryRecord.h
TotemTimingDQMSource::PotPlots::PotPlots
PotPlots()
Definition: TotemTimingDQMSource.cc:157
InputTag.h
TotemTimingDQMSource::SAMPIC_SAMPLING_PERIOD_NS
static const double SAMPIC_SAMPLING_PERIOD_NS
Definition: TotemTimingDQMSource.cc:75
TotemTimingDQMSource::tokenRecHit_
edm::EDGetTokenT< edm::DetSetVector< TotemTimingRecHit > > tokenRecHit_
Definition: TotemTimingDQMSource.cc:97
std
Definition: JetResolutionObject.h:76
TotemTimingDQMSource::TOTEM_TIMING_TOP_RP_ID
static const int TOTEM_TIMING_TOP_RP_ID
Definition: TotemTimingDQMSource.cc:82
TotemTimingDQMSource::potPlots_
std::unordered_map< unsigned int, PotPlots > potPlots_
Definition: TotemTimingDQMSource.cc:161
FEDNumbering::MINTotemRPTimingVerticalFEDID
Definition: FEDNumbering.h:41
TotemTimingDQMSource::bookHistograms
void bookHistograms(DQMStore::IBooker &, const edm::Run &, const edm::EventSetup &) override
Definition: TotemTimingDQMSource.cc:443
TotemTimingDQMSource::PotPlots::recHitTime
MonitorElement * recHitTime
Definition: TotemTimingDQMSource.cc:137
dqm::implementation::IBooker::book2D
MonitorElement * book2D(TString const &name, TString const &title, int nchX, double lowX, double highX, int nchY, double lowY, double highY, FUNC onbooking=NOOP())
Definition: DQMStore.h:177
TotemTimingDQMSource::verticalShiftTop_
float verticalShiftTop_
Definition: TotemTimingDQMSource.cc:107
TotemTimingDQMSource::LHC_CLOCK_PERIOD_NS
static const double LHC_CLOCK_PERIOD_NS
Definition: TotemTimingDQMSource.cc:66
TotemTimingDQMSource::TOTEM_STRIP_MIN_RP_ID
static const int TOTEM_STRIP_MIN_RP_ID
Definition: TotemTimingDQMSource.cc:84
TotemTimingDQMSource::globalBeginLuminosityBlock
std::shared_ptr< totemds::Cache > globalBeginLuminosityBlock(const edm::LuminosityBlock &, const edm::EventSetup &) const override
Definition: TotemTimingDQMSource.cc:467
TotemRPLocalTrack
A track fit through a single RP.
Definition: TotemRPLocalTrack.h:30
TotemRPDetId.h
TotemTimingDQMSource::GlobalPlots::digiSentPercentage
MonitorElement * digiSentPercentage
Definition: TotemTimingDQMSource.cc:111
TotemTimingDQMSource::CTPPS_FAR_RP_ID
static const int CTPPS_FAR_RP_ID
Definition: TotemTimingDQMSource.cc:87
EventSetup.h
TotemTimingDQMSource::TOTEM_STRIP_MAX_RP_ID
static const int TOTEM_STRIP_MAX_RP_ID
Definition: TotemTimingDQMSource.cc:85
dqm::implementation::IBooker
Definition: DQMStore.h:43
TotemFEDInfo
OptoRx headers and footers.
Definition: TotemFEDInfo.h:16
TotemTimingDQMSource::TOTEM_TIMING_NUM_OF_CHANNELS
static const int TOTEM_TIMING_NUM_OF_CHANNELS
Definition: TotemTimingDQMSource.cc:89
ztail.d
d
Definition: ztail.py:151
TotemTimingDetId::planeName
void planeName(std::string &name, NameFlag flag=nFull) const
Definition: TotemTimingDetId.h:69
TotemTimingDQMSource::ChannelPlots::maxTimeAfterTrigger
MonitorElement * maxTimeAfterTrigger
Definition: TotemTimingDQMSource.cc:183
cms::Exception
Definition: Exception.h:70
castor_dqm_sourceclient_file_cfg.path
path
Definition: castor_dqm_sourceclient_file_cfg.py:37
RunInfoPI::valid
Definition: RunInfoPayloadInspectoHelper.h:16
TotemFEDInfo.h
ParameterSet.h
TotemRPLocalTrack.h
edm::EDConsumerBase::consumes
EDGetTokenT< ProductType > consumes(edm::InputTag const &tag)
Definition: EDConsumerBase.h:153
TotemTimingDQMSource::PotPlots::dataSamplesRaw
MonitorElement * dataSamplesRaw
Definition: TotemTimingDQMSource.cc:124
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:70
event
Definition: event.py:1
TotemTimingDQMSource::tokenFEDInfo_
edm::EDGetTokenT< std::vector< TotemFEDInfo > > tokenFEDInfo_
Definition: TotemTimingDQMSource.cc:99
edm::Event
Definition: Event.h:73
TotemTimingDetId::channelName
void channelName(std::string &name, NameFlag flag=nFull) const
Definition: TotemTimingDetId.h:86
TotemTimingDQMSource::ChannelPlots::ChannelPlots
ChannelPlots()
Definition: TotemTimingDQMSource.cc:197
TotemTimingDQMSource::SIN_8_DEG
static const float SIN_8_DEG
Definition: TotemTimingDQMSource.cc:93
TotemTimingDQMSource::PotPlots::planesWithDigis
MonitorElement * planesWithDigis
Definition: TotemTimingDQMSource.cc:146
TotemTimingDQMSource::ChannelPlots::tirggerCellTime
MonitorElement * tirggerCellTime
Definition: TotemTimingDQMSource.cc:186
TotemTimingDQMSource::PotPlots::planesWithDigisSet
std::set< unsigned int > planesWithDigisSet
Definition: TotemTimingDQMSource.cc:154
TotemRPDetId
Detector ID class for TOTEM Si strip detectors.
Definition: TotemRPDetId.h:29
TotemTimingDQMSource::minimumStripAngleForTomography_
double minimumStripAngleForTomography_
Definition: TotemTimingDQMSource.cc:101
TotemTimingDQMSource::TOTEM_TIMING_STATION_ID
static const int TOTEM_TIMING_STATION_ID
Definition: TotemTimingDQMSource.cc:79
TotemTimingDQMSource::PotPlots::cellOfMax
MonitorElement * cellOfMax
Definition: TotemTimingDQMSource.cc:142
TotemTimingDQMSource::maximumStripAngleForTomography_
double maximumStripAngleForTomography_
Definition: TotemTimingDQMSource.cc:102
edm::TimeValue_t
unsigned long long TimeValue_t
Definition: Timestamp.h:28
dqm::implementation::IBooker::book1D
MonitorElement * book1D(TString const &name, TString const &title, int const nchX, double const lowX, double const highX, FUNC onbooking=NOOP())
Definition: DQMStore.h:98
EventRange.h
TotemTimingDetId::setPlane
void setPlane(uint32_t channel)
Definition: TotemTimingDetId.h:51
MillePedeFileConverter_cfg.e
e
Definition: MillePedeFileConverter_cfg.py:37
CTPPSDetId::rpName
void rpName(std::string &name, NameFlag flag=nFull) const
Definition: CTPPSDetId.h:132
TotemTimingDQMSource::PotPlots::digiDistribution
MonitorElement * digiDistribution
Definition: TotemTimingDQMSource.cc:123
Generated for CMSSW Reference Manual by doxygen 1.8.16