CMS 3D CMS Logo

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
RPCMonitorDigi.cc
Go to the documentation of this file.
3 
8 
12 
13 #include <set>
14 #include <sstream>
15 
16 const std::array<std::string, 3> RPCMonitorDigi::regionNames_ = {{"Endcap-", "Barrel", "Endcap+"}};
17 
18 RPCMonitorDigi::RPCMonitorDigi(const edm::ParameterSet& pset) : counter(0), numberOfDisks_(0), numberOfInnerRings_(0) {
19  useMuonDigis_ = pset.getUntrackedParameter<bool>("UseMuon", true);
20  useRollInfo_ = pset.getUntrackedParameter<bool>("UseRollInfo", false);
21 
22  muPtCut_ = pset.getUntrackedParameter<double>("MuonPtCut", 3.0);
23  muEtaCut_ = pset.getUntrackedParameter<double>("MuonEtaCut", 1.9);
24 
25  subsystemFolder_ = pset.getUntrackedParameter<std::string>("RPCFolder", "RPC");
26  globalFolder_ = pset.getUntrackedParameter<std::string>("GlobalFolder", "SummaryHistograms");
27 
28  //Parametersets for tokens
29  muonLabel_ = consumes<reco::CandidateView>(pset.getParameter<edm::InputTag>("MuonLabel"));
30  rpcRecHitLabel_ = consumes<RPCRecHitCollection>(pset.getParameter<edm::InputTag>("RecHitLabel"));
31  scalersRawToDigiLabel_ = consumes<DcsStatusCollection>(pset.getParameter<edm::InputTag>("ScalersRawToDigiLabel"));
32 
33  noiseFolder_ = pset.getUntrackedParameter<std::string>("NoiseFolder", "AllHits");
34  muonFolder_ = pset.getUntrackedParameter<std::string>("MuonFolder", "Muon");
35 }
36 
38  edm::LogInfo("rpcmonitordigi") << "[RPCMonitorDigi]: Begin Run ";
39 
40  std::set<int> disk_set, ring_set;
41  edm::ESHandle<RPCGeometry> rpcGeoHandle;
42  iSetup.get<MuonGeometryRecord>().get(rpcGeoHandle);
43  const RPCGeometry* rpcGeo = rpcGeoHandle.product();
44 
45  //loop on geometry to book all MEs
46  edm::LogInfo("rpcmonitordigi") << "[RPCMonitorDigi]: Booking histograms per roll. ";
47  for (TrackingGeometry::DetContainer::const_iterator it = rpcGeo->dets().begin(); it < rpcGeo->dets().end(); it++) {
48  if (dynamic_cast<const RPCChamber*>(*it) != nullptr) {
49  const RPCChamber* ch = dynamic_cast<const RPCChamber*>(*it);
50  std::vector<const RPCRoll*> roles = (ch->rolls());
51  if (useRollInfo_) {
52  for (std::vector<const RPCRoll*>::const_iterator r = roles.begin(); r != roles.end(); ++r) {
53  RPCDetId rpcId = (*r)->id();
54 
55  //get station and inner ring
56  if (rpcId.region() != 0) {
57  disk_set.insert(rpcId.station());
58  ring_set.insert(rpcId.ring());
59  }
60 
61  //booking all histograms
62  RPCGeomServ rpcsrv(rpcId);
63  std::string nameID = rpcsrv.name();
64  if (useMuonDigis_)
65  bookRollME(ibooker, rpcId, rpcGeo, muonFolder_, meMuonCollection[nameID]);
66  bookRollME(ibooker, rpcId, rpcGeo, noiseFolder_, meNoiseCollection[nameID]);
67  }
68  } else {
69  RPCDetId rpcId = roles[0]->id(); //any roll would do - here I just take the first one
70  RPCGeomServ rpcsrv(rpcId);
71  std::string nameID = rpcsrv.chambername();
72  if (useMuonDigis_)
73  bookRollME(ibooker, rpcId, rpcGeo, muonFolder_, meMuonCollection[nameID]);
74  bookRollME(ibooker, rpcId, rpcGeo, noiseFolder_, meNoiseCollection[nameID]);
75  if (rpcId.region() != 0) {
76  disk_set.insert(rpcId.station());
77  ring_set.insert(rpcId.ring());
78  }
79  }
80  }
81  } //end loop on geometry to book all MEs
82 
83  numberOfDisks_ = disk_set.size();
84  numberOfInnerRings_ = (*ring_set.begin());
85 
86  //Book
90 
91  std::string currentFolder = subsystemFolder_ + "/" + noiseFolder_;
92  ibooker.setCurrentFolder(currentFolder);
93 
94  noiseRPCEvents_ = ibooker.book1D("RPCEvents", "RPCEvents", 1, 0.5, 1.5);
95 
96  if (useMuonDigis_) {
100 
101  currentFolder = subsystemFolder_ + "/" + muonFolder_;
102  ibooker.setCurrentFolder(currentFolder);
103 
104  muonRPCEvents_ = ibooker.book1D("RPCEvents", "RPCEvents", 1, 0.5, 1.5);
105  NumberOfMuon_ = ibooker.book1D("NumberOfMuons", "Number of Muons", 11, -0.5, 10.5);
106  NumberOfRecHitMuon_ = ibooker.book1D("NumberOfRecHitMuons", "Number of RPC RecHits per Muon", 8, -0.5, 7.5);
107  }
108 }
109 
111  counter++;
112  edm::LogInfo("rpcmonitordigi") << "[RPCMonitorDigi]: Beginning analyzing event " << counter;
113 
114  //Muons
116  event.getByToken(muonLabel_, muonCands);
117 
118  std::map<RPCDetId, std::vector<RPCRecHit> > rechitMuon;
119 
120  int numMuons = 0;
121  int numRPCRecHit = 0;
122 
123  if (muonCands.isValid()) {
124  int nStaMuons = muonCands->size();
125 
126  for (int i = 0; i < nStaMuons; i++) {
127  const reco::Candidate& goodMuon = (*muonCands)[i];
128  const reco::Muon* muCand = dynamic_cast<const reco::Muon*>(&goodMuon);
129 
130  if (!muCand->isGlobalMuon())
131  continue;
132  if (muCand->pt() < muPtCut_ || fabs(muCand->eta()) > muEtaCut_)
133  continue;
134  numMuons++;
135  reco::Track muTrack = (*(muCand->outerTrack()));
136  std::vector<TrackingRecHitRef> rpcTrackRecHits;
137  //loop on mu rechits
138  for (trackingRecHit_iterator it = muTrack.recHitsBegin(); it != muTrack.recHitsEnd(); it++) {
139  if (!(*it)->isValid())
140  continue;
141  int muSubDetId = (*it)->geographicalId().subdetId();
142  if (muSubDetId == MuonSubdetId::RPC) {
143  numRPCRecHit++;
144  TrackingRecHit* tkRecHit = (*it)->clone();
145  RPCRecHit* rpcRecHit = dynamic_cast<RPCRecHit*>(tkRecHit);
146  int detId = (int)rpcRecHit->rpcId();
147  if (rechitMuon.find(detId) == rechitMuon.end() || rechitMuon[detId].empty()) {
148  std::vector<RPCRecHit> myVect(1, *rpcRecHit);
149  rechitMuon[detId] = myVect;
150  } else {
151  rechitMuon[detId].push_back(*rpcRecHit);
152  }
153  }
154  } // end loop on mu rechits
155  }
156 
157  //Fill muon counter
158  if (NumberOfMuon_) {
159  NumberOfMuon_->Fill(numMuons);
160  }
161 
162  //Fill rechit counter for muons
163  if (NumberOfRecHitMuon_ && numMuons > 0) {
164  NumberOfRecHitMuon_->Fill(numRPCRecHit);
165  }
166 
167  //Fill counter of RPC events with rechits associated in with a muon
168  if (muonRPCEvents_ != nullptr && numRPCRecHit > 0) {
169  muonRPCEvents_->Fill(1);
170  }
171 
172  //Perform client operation
173  this->performSourceOperation(rechitMuon, muonFolder_);
174 
175  } else {
176  edm::LogError("rpcmonitordigi") << "[RPCMonitorDigi]: Muons - Product not valid for event" << counter;
177  }
178 
179  //RecHits
181  event.getByToken(rpcRecHitLabel_, rpcHits);
182  std::map<RPCDetId, std::vector<RPCRecHit> > rechitNoise;
183 
184  if (rpcHits.isValid()) {
185  // RPC rec hits NOT associated to a muon
186  for (auto rpcRecHitIter = rpcHits->begin(); rpcRecHitIter != rpcHits->end(); rpcRecHitIter++) {
187  RPCRecHit rpcRecHit = (*rpcRecHitIter);
188  int detId = (int)rpcRecHit.rpcId();
189  if (rechitNoise.find(detId) == rechitNoise.end() || rechitNoise[detId].empty()) {
190  std::vector<RPCRecHit> myVect(1, rpcRecHit);
191  rechitNoise[detId] = myVect;
192  } else {
193  rechitNoise[detId].push_back(rpcRecHit);
194  }
195  }
196  } else {
197  edm::LogError("rpcmonitordigi") << "[RPCMonitorDigi]: RPCRecHits - Product not valid for event" << counter;
198  }
199 
200  //Fill counter for all RPC events
201  if (noiseRPCEvents_ != nullptr && !rechitNoise.empty()) {
202  noiseRPCEvents_->Fill(1);
203  }
204  //Perform client operation
205  this->performSourceOperation(rechitNoise, noiseFolder_);
206 }
207 
208 void RPCMonitorDigi::performSourceOperation(std::map<RPCDetId, std::vector<RPCRecHit> >& recHitMap,
209  std::string recHittype) {
210  edm::LogInfo("rpcmonitordigi") << "[RPCMonitorDigi]: Performing DQM source operations for ";
211 
212  if (recHitMap.empty())
213  return;
214 
215  std::map<std::string, std::map<std::string, MonitorElement*> > meRollCollection;
216  std::map<std::string, MonitorElement*> meWheelDisk;
217  std::map<std::string, MonitorElement*> meRegion;
218  std::map<std::string, MonitorElement*> meSectorRing;
219 
220  if (recHittype == muonFolder_) {
221  meRollCollection = meMuonCollection;
222  meWheelDisk = wheelDiskMuonCollection;
223  meRegion = regionMuonCollection;
224  meSectorRing = sectorRingMuonCollection;
225  } else if (recHittype == noiseFolder_) {
226  meRollCollection = meNoiseCollection;
227  meWheelDisk = wheelDiskNoiseCollection;
228  meRegion = regionNoiseCollection;
229  meSectorRing = sectorRingNoiseCollection;
230  } else {
231  edm::LogWarning("rpcmonitordigi") << "[RPCMonitorDigi]: RecHit type not valid.";
232  return;
233  }
234 
235  int totalNumberOfRecHits[3] = {0, 0, 0};
236  std::stringstream os;
237 
238  //Loop on Rolls
239  for (std::map<RPCDetId, std::vector<RPCRecHit> >::const_iterator detIdIter = recHitMap.begin();
240  detIdIter != recHitMap.end();
241  detIdIter++) {
242  RPCDetId detId = (*detIdIter).first;
243 
244  //get roll number
245  rpcdqm::utils rpcUtils;
246  int nr = rpcUtils.detId2RollNr(detId);
247 
248  RPCGeomServ geoServ(detId);
249  std::string nameRoll = "";
250 
251  if (useRollInfo_)
252  nameRoll = geoServ.name();
253  else
254  nameRoll = geoServ.chambername();
255 
256  int region = (int)detId.region();
257  int wheelOrDiskNumber;
258  std::string wheelOrDiskType;
259  int ring = 0;
260  int sector = detId.sector();
261  int layer = 0;
262  int totalRolls = 3;
263  int roll = detId.roll();
264  if (region == 0) {
265  wheelOrDiskType = "Wheel";
266  wheelOrDiskNumber = (int)detId.ring();
267  int station = detId.station();
268 
269  if (station == 1) {
270  if (detId.layer() == 1) {
271  layer = 1; //RB1in
272  totalRolls = 2;
273  } else {
274  layer = 2; //RB1out
275  totalRolls = 2;
276  }
277  if (roll == 3)
278  roll = 2; // roll=3 is Forward
279  } else if (station == 2) {
280  if (detId.layer() == 1) {
281  layer = 3; //RB2in
282  if (abs(wheelOrDiskNumber) == 2 && roll == 3) {
283  roll = 2; //W -2, +2 RB2in has only 2 rolls
284  totalRolls = 2;
285  }
286  } else {
287  layer = 4; //RB2out
288  if (abs(wheelOrDiskNumber) != 2 && roll == 3) {
289  roll = 2; //W -1, 0, +1 RB2out has only 2 rolls
290  totalRolls = 2;
291  }
292  }
293  } else if (station == 3) {
294  layer = 5; //RB3
295  totalRolls = 2;
296  if (roll == 3)
297  roll = 2;
298  } else {
299  layer = 6; //RB4
300  totalRolls = 2;
301  if (roll == 3)
302  roll = 2;
303  }
304 
305  } else {
306  wheelOrDiskType = "Disk";
307  wheelOrDiskNumber = region * (int)detId.station();
308  ring = detId.ring();
309  }
310 
311  std::vector<RPCRecHit> recHits = (*detIdIter).second;
312  int numberOfRecHits = recHits.size();
313  totalNumberOfRecHits[region + 1] += numberOfRecHits;
314 
315  std::set<int> bxSet;
316  int numDigi = 0;
317 
318  std::map<std::string, MonitorElement*> meMap = meRollCollection[nameRoll];
319 
320  //Loop on recHits
321  for (std::vector<RPCRecHit>::const_iterator recHitIter = recHits.begin(); recHitIter != recHits.end();
322  recHitIter++) {
323  RPCRecHit recHit = (*recHitIter);
324 
325  int bx = recHit.BunchX();
326  bxSet.insert(bx);
327  int clusterSize = (int)recHit.clusterSize();
328  numDigi += clusterSize;
329  int firstStrip = recHit.firstClusterStrip();
330  int lastStrip = clusterSize + firstStrip - 1;
331 
332  // ###################### Roll Level #################################
333 
334  os.str("");
335  os << "Occupancy_" << nameRoll;
336  if (meMap[os.str()]) {
337  for (int s = firstStrip; s <= lastStrip; s++) {
338  if (useRollInfo_) {
339  meMap[os.str()]->Fill(s);
340  } else {
341  int nstrips = meMap[os.str()]->getNbinsX() / totalRolls;
342  meMap[os.str()]->Fill(s + nstrips * (roll - 1));
343  }
344  }
345  }
346 
347  os.str("");
348  os << "BXDistribution_" << nameRoll;
349  if (meMap[os.str()])
350  meMap[os.str()]->Fill(bx);
351 
352  os.str("");
353  os << "ClusterSize_" << nameRoll;
354  if (meMap[os.str()])
355  meMap[os.str()]->Fill(clusterSize);
356 
357  // ###################### Sector- Ring Level #################################
358 
359  os.str("");
360  os << "Occupancy_" << wheelOrDiskType << "_" << wheelOrDiskNumber << "_Sector_" << sector;
361  if (meSectorRing[os.str()]) {
362  for (int s = firstStrip; s <= lastStrip; s++) { //Loop on digis
363  meSectorRing[os.str()]->Fill(s, nr);
364  }
365  }
366 
367  os.str("");
368  if (geoServ.segment() > 0 && geoServ.segment() < 19) {
369  os << "Occupancy_" << wheelOrDiskType << "_" << wheelOrDiskNumber << "_Ring_" << ring << "_CH01-CH18";
370  } else if (geoServ.segment() > 18) {
371  os << "Occupancy_" << wheelOrDiskType << "_" << wheelOrDiskNumber << "_Ring_" << ring << "_CH19-CH36";
372  }
373 
374  if (meSectorRing[os.str()]) {
375  for (int s = firstStrip; s <= lastStrip; s++) { //Loop on digis
376  meSectorRing[os.str()]->Fill(s + 32 * (detId.roll() - 1), geoServ.segment());
377  }
378  }
379 
380  // ###################### Wheel/Disk Level #########################��� if (region == 0) { os.str(""); os << "1DOccupancy_Wheel_" << wheelOrDiskNumber; if (meWheelDisk[os.str()]) meWheelDisk[os.str()]->Fill(sector, clusterSize); os.str(""); os << "Occupancy_Roll_vs_Sector_" << wheelOrDiskType << "_" << wheelOrDiskNumber; if (meWheelDisk[os.str()]) meWheelDisk[os.str()]->Fill(sector, nr, clusterSize); } else { os.str(""); os << "1DOccupancy_Ring_" << ring; if ((meWheelDisk[os.str()])) { if (wheelOrDiskNumber > 0) { meWheelDisk[os.str()]->Fill(wheelOrDiskNumber + numberOfDisks_, clusterSize); } else { meWheelDisk[os.str()]->Fill(wheelOrDiskNumber + numberOfDisks_ + 1, clusterSize); } } os.str(""); os << "Occupancy_Ring_vs_Segment_" << wheelOrDiskType << "_" << wheelOrDiskNumber; if (meWheelDisk[os.str()]) meWheelDisk[os.str()]->Fill(geoServ.segment(), (ring - 1) * 3 - detId.roll() + 1, clusterSize); } os.str(""); os << "BxDistribution_" << wheelOrDiskType << "_" << wheelOrDiskNumber; if (meWheelDisk[os.str()]) meWheelDisk[os.str()]->Fill(bx); os.str(""); os << "ClusterSize_" << wheelOrDiskType << "_" << wheelOrDiskNumber << "_Layer" << layer; if (meWheelDisk[os.str()]) meWheelDisk[os.str()]->Fill(clusterSize); os.str(""); os << "ClusterSize_" << wheelOrDiskType << "_" << wheelOrDiskNumber << "_Ring" << ring; if (meWheelDisk[os.str()]) meWheelDisk[os.str()]->Fill(clusterSize); // ###################### Global ################################## os.str(""); os << "ClusterSize_" << RPCMonitorDigi::regionNames_[region + 1]; if (meRegion[os.str()]) meRegion[os.str()]->Fill(clusterSize); os.str(""); os << "ClusterSize_"; if (region == 0) { os << "Layer" << layer; } else { os << "Ring" << ring; } if (meRegion[os.str()]) meRegion[os.str()]->Fill(clusterSize); } //end loop on recHits os.str(""); os << "BXWithData_" << nameRoll; if (meMap[os.str()]) meMap[os.str()]->Fill(bxSet.size()); os.str(""); os << "NumberOfClusters_" << nameRoll; if (meMap[os.str()]) meMap[os.str()]->Fill(numberOfRecHits); os.str(""); os << "Multiplicity_" << RPCMonitorDigi::regionNames_[region + 1]; if (meRegion[os.str()]) meRegion[os.str()]->Fill(numDigi); os.str(""); if (region == 0) { os << "Occupancy_for_Barrel"; if (meRegion[os.str()]) meRegion[os.str()]->Fill(sector, wheelOrDiskNumber, numDigi); } else { os << "Occupancy_for_Endcap"; int xbin = wheelOrDiskNumber + numberOfDisks_; if (region == -1) { xbin = wheelOrDiskNumber + numberOfDisks_ + 1; } if (meRegion[os.str()]) { meRegion[os.str()]->Fill(xbin, ring, numDigi); } } os.str(""); os << "Multiplicity_" << nameRoll; if (meMap[os.str()]) meMap[os.str()]->Fill(numDigi); } //end loop on rolls for (int i = 0; i < 3; i++) { os.str(""); os << "NumberOfClusters_" << RPCMonitorDigi::regionNames_[i]; if (meRegion[os.str()]) meRegion[os.str()]->Fill(totalNumberOfRecHits[i]); } }
381  if (region == 0) {
382  os.str("");
383  os << "1DOccupancy_Wheel_" << wheelOrDiskNumber;
384  if (meWheelDisk[os.str()])
385  meWheelDisk[os.str()]->Fill(sector, clusterSize);
386 
387  os.str("");
388  os << "Occupancy_Roll_vs_Sector_" << wheelOrDiskType << "_" << wheelOrDiskNumber;
389  if (meWheelDisk[os.str()])
390  meWheelDisk[os.str()]->Fill(sector, nr, clusterSize);
391 
392  } else {
393  os.str("");
394  os << "1DOccupancy_Ring_" << ring;
395  if ((meWheelDisk[os.str()])) {
396  if (wheelOrDiskNumber > 0) {
397  meWheelDisk[os.str()]->Fill(wheelOrDiskNumber + numberOfDisks_, clusterSize);
398  } else {
399  meWheelDisk[os.str()]->Fill(wheelOrDiskNumber + numberOfDisks_ + 1, clusterSize);
400  }
401  }
402 
403  os.str("");
404  os << "Occupancy_Ring_vs_Segment_" << wheelOrDiskType << "_" << wheelOrDiskNumber;
405  if (meWheelDisk[os.str()])
406  meWheelDisk[os.str()]->Fill(geoServ.segment(), (ring - 1) * 3 - detId.roll() + 1, clusterSize);
407  }
408 
409  os.str("");
410  os << "BxDistribution_" << wheelOrDiskType << "_" << wheelOrDiskNumber;
411  if (meWheelDisk[os.str()])
412  meWheelDisk[os.str()]->Fill(bx);
413 
414  os.str("");
415  os << "ClusterSize_" << wheelOrDiskType << "_" << wheelOrDiskNumber << "_Layer" << layer;
416  if (meWheelDisk[os.str()])
417  meWheelDisk[os.str()]->Fill(clusterSize);
418 
419  os.str("");
420  os << "ClusterSize_" << wheelOrDiskType << "_" << wheelOrDiskNumber << "_Ring" << ring;
421  if (meWheelDisk[os.str()])
422  meWheelDisk[os.str()]->Fill(clusterSize);
423 
424  // ###################### Global ##################################
425 
426  os.str("");
427  os << "ClusterSize_" << RPCMonitorDigi::regionNames_[region + 1];
428  if (meRegion[os.str()])
429  meRegion[os.str()]->Fill(clusterSize);
430 
431  os.str("");
432  os << "ClusterSize_";
433  if (region == 0) {
434  os << "Layer" << layer;
435  } else {
436  os << "Ring" << ring;
437  }
438  if (meRegion[os.str()])
439  meRegion[os.str()]->Fill(clusterSize);
440 
441  } //end loop on recHits
442 
443  os.str("");
444  os << "BXWithData_" << nameRoll;
445  if (meMap[os.str()])
446  meMap[os.str()]->Fill(bxSet.size());
447 
448  os.str("");
449  os << "NumberOfClusters_" << nameRoll;
450  if (meMap[os.str()])
451  meMap[os.str()]->Fill(numberOfRecHits);
452 
453  os.str("");
454  os << "Multiplicity_" << RPCMonitorDigi::regionNames_[region + 1];
455  if (meRegion[os.str()])
456  meRegion[os.str()]->Fill(numDigi);
457 
458  os.str("");
459  if (region == 0) {
460  os << "Occupancy_for_Barrel";
461  if (meRegion[os.str()])
462  meRegion[os.str()]->Fill(sector, wheelOrDiskNumber, numDigi);
463  } else {
464  os << "Occupancy_for_Endcap";
465  int xbin = wheelOrDiskNumber + numberOfDisks_;
466  if (region == -1) {
467  xbin = wheelOrDiskNumber + numberOfDisks_ + 1;
468  }
469  if (meRegion[os.str()]) {
470  meRegion[os.str()]->Fill(xbin, ring, numDigi);
471  }
472  }
473 
474  os.str("");
475  os << "Multiplicity_" << nameRoll;
476  if (meMap[os.str()])
477  meMap[os.str()]->Fill(numDigi);
478 
479  } //end loop on rolls
480 
481  for (int i = 0; i < 3; i++) {
482  os.str("");
483  os << "NumberOfClusters_" << RPCMonitorDigi::regionNames_[i];
484  if (meRegion[os.str()])
485  meRegion[os.str()]->Fill(totalNumberOfRecHits[i]);
486  }
487 }
virtual std::string chambername()
Definition: RPCGeomServ.cc:89
MonitorElement * book1D(TString const &name, TString const &title, int const nchX, double const lowX, double const highX)
Definition: DQMStore.cc:239
T getParameter(std::string const &) const
int firstClusterStrip() const
Definition: RPCRecHit.h:75
T getUntrackedParameter(std::string const &, T const &) const
std::map< std::string, std::map< std::string, MonitorElement * > > meMuonCollection
double eta() const final
momentum pseudorapidity
std::string globalFolder_
std::string muonFolder_
void setCurrentFolder(std::string const &fullpath)
Definition: DQMStore.cc:418
std::map< std::string, MonitorElement * > wheelDiskNoiseCollection
std::map< std::string, MonitorElement * > sectorRingMuonCollection
size_type size() const
double pt() const final
transverse momentum
MonitorElement * muonRPCEvents_
void bookSectorRingME(DQMStore::IBooker &, const std::string &, std::map< std::string, MonitorElement * > &)
Booking of MonitoringElement at Sector/Ring level.
RPCMonitorDigi(const edm::ParameterSet &)
void analyze(const edm::Event &, const edm::EventSetup &) override
std::string noiseFolder_
void Fill(long long x)
int clusterSize() const
Definition: RPCRecHit.h:77
RPCDetId rpcId() const
Return the rpcId.
Definition: RPCRecHit.h:71
virtual std::string name()
Definition: RPCGeomServ.cc:11
int roll() const
Definition: RPCDetId.h:92
bool isGlobalMuon() const override
Definition: Muon.h:298
int ring() const
Definition: RPCDetId.h:59
virtual TrackingRecHit * clone() const =0
void bookRollME(DQMStore::IBooker &, const RPCDetId &, const RPCGeometry *rpcGeo, const std::string &, std::map< std::string, MonitorElement * > &)
Booking of MonitoringElement for one RPCDetId (= roll)
const std::vector< const RPCRoll * > & rolls() const
Return the Rolls.
Definition: RPCChamber.cc:40
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
static const std::array< std::string, 3 > regionNames_
trackingRecHit_iterator recHitsBegin() const
Iterator to first hit on the track.
Definition: Track.h:88
bool isValid() const
Definition: HandleBase.h:70
virtual TrackRef outerTrack() const
reference to Track reconstructed in the muon detector only
Definition: Muon.h:48
MonitorElement * NumberOfRecHitMuon_
std::map< std::string, MonitorElement * > regionMuonCollection
int layer() const
Definition: RPCDetId.h:85
virtual int segment()
Definition: RPCGeomServ.cc:361
int detId2RollNr(const RPCDetId &_id)
Definition: utils.h:31
const DetContainer & dets() const override
Returm a vector of all GeomDet (including all GeomDetUnits)
Definition: RPCGeometry.cc:24
std::map< std::string, MonitorElement * > sectorRingNoiseCollection
static constexpr int RPC
Definition: MuonSubdetId.h:13
edm::EDGetTokenT< RPCRecHitCollection > rpcRecHitLabel_
edm::EDGetTokenT< DcsStatusCollection > scalersRawToDigiLabel_
std::map< std::string, std::map< std::string, MonitorElement * > > meNoiseCollection
int sector() const
Sector id: the group of chambers at same phi (and increasing r)
Definition: RPCDetId.h:81
void performSourceOperation(std::map< RPCDetId, std::vector< RPCRecHit > > &, std::string)
void bookHistograms(DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
std::map< std::string, MonitorElement * > wheelDiskMuonCollection
T get() const
Definition: EventSetup.h:73
void bookWheelDiskME(DQMStore::IBooker &, const std::string &, std::map< std::string, MonitorElement * > &)
Booking of MonitoringElemnt at Wheel/Disk level.
std::map< std::string, MonitorElement * > regionNoiseCollection
int BunchX() const
Definition: RPCRecHit.h:73
MonitorElement * noiseRPCEvents_
void bookRegionME(DQMStore::IBooker &, const std::string &, std::map< std::string, MonitorElement * > &)
Booking of MonitoringElemnt at region (Barrel/Endcap) level.
MonitorElement * NumberOfMuon_
T const * product() const
Definition: ESHandle.h:86
std::string subsystemFolder_
Definition: event.py:1
Definition: Run.h:45
edm::EDGetTokenT< reco::CandidateView > muonLabel_
trackingRecHit_iterator recHitsEnd() const
Iterator to last hit on the track.
Definition: Track.h:91
int region() const
Region id: 0 for Barrel, +/-1 For +/- Endcap.
Definition: RPCDetId.h:53
int station() const
Definition: RPCDetId.h:78