CMS 3D CMS Logo
List of all members | Public Member Functions | Protected Member Functions | Private Member Functions | Private Attributes | Static Private Attributes
RPCMonitorDigi Class Reference

#include <RPCMonitorDigi.h>

Inheritance diagram for RPCMonitorDigi:
DQMEDAnalyzer edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >

Public Member Functions

 RPCMonitorDigi (const edm::ParameterSet &)
 
 ~RPCMonitorDigi () override=default
 
- Public Member Functions inherited from DQMEDAnalyzer
void accumulate (edm::Event const &event, edm::EventSetup const &setup) final
 
void beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final
 
void beginRun (edm::Run const &run, edm::EventSetup const &setup) final
 
void beginStream (edm::StreamID id) final
 
virtual void dqmBeginRun (edm::Run const &, edm::EventSetup const &)
 
 DQMEDAnalyzer ()
 
void endLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final
 
void endRun (edm::Run const &run, edm::EventSetup const &setup) final
 
virtual bool getCanSaveByLumi ()
 
- Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
 EDProducer ()=default
 
bool hasAbilityToProduceInBeginLumis () const final
 
bool hasAbilityToProduceInBeginRuns () const final
 
bool hasAbilityToProduceInEndLumis () const final
 
bool hasAbilityToProduceInEndRuns () const final
 

Protected Member Functions

void analyze (const edm::Event &, const edm::EventSetup &) override
 
void bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
 
void bookRegionME (DQMStore::IBooker &, const std::string &, std::map< std::string, MonitorElement * > &)
 Booking of MonitoringElemnt at region (Barrel/Endcap) level. More...
 
void bookRollME (DQMStore::IBooker &, const RPCDetId &, const RPCGeometry *rpcGeo, const std::string &, std::map< std::string, MonitorElement * > &)
 Booking of MonitoringElement for one RPCDetId (= roll) More...
 
void bookSectorRingME (DQMStore::IBooker &, const std::string &, std::map< std::string, MonitorElement * > &)
 Booking of MonitoringElement at Sector/Ring level. More...
 
void bookWheelDiskME (DQMStore::IBooker &, const std::string &, std::map< std::string, MonitorElement * > &)
 Booking of MonitoringElemnt at Wheel/Disk level. More...
 
- Protected Member Functions inherited from DQMEDAnalyzer
uint64_t meId () const
 

Private Member Functions

void performSourceOperation (std::map< RPCDetId, std::vector< RPCRecHit > > &, std::string)
 
int stripsInRoll (const RPCDetId &id, const RPCGeometry *rpcGeo) const
 

Private Attributes

int counter
 
std::string globalFolder_
 
std::map< std::string, std::map< std::string, MonitorElement * > > meMuonCollection
 
std::map< std::string, std::map< std::string, MonitorElement * > > meNoiseCollection
 
float muEtaCut_
 
std::string muonFolder_
 
edm::EDGetTokenT< reco::CandidateView > muonLabel_
 
MonitorElement * muonRPCEvents_
 
float muPtCut_
 
std::string noiseFolder_
 
MonitorElement * noiseRPCEvents_
 
int numberOfDisks_
 
int numberOfInnerRings_
 
MonitorElement * NumberOfMuon_
 
MonitorElement * NumberOfRecHitMuon_
 
std::map< std::string, MonitorElement * > regionMuonCollection
 
std::map< std::string, MonitorElement * > regionNoiseCollection
 
edm::EDGetTokenT< RPCRecHitCollection > rpcRecHitLabel_
 
edm::EDGetTokenT< DcsStatusCollection > scalersRawToDigiLabel_
 
std::map< std::string, MonitorElement * > sectorRingMuonCollection
 
std::map< std::string, MonitorElement * > sectorRingNoiseCollection
 
std::string subsystemFolder_
 
bool useMuonDigis_
 
bool useRollInfo_
 
std::map< std::string, MonitorElement * > wheelDiskMuonCollection
 
std::map< std::string, MonitorElement * > wheelDiskNoiseCollection
 

Static Private Attributes

static const std::array< std::string, 3 > regionNames_ = {{"Endcap-", "Barrel", "Endcap+"}}
 

Additional Inherited Members

- Public Types inherited from DQMEDAnalyzer
typedef dqm::reco::DQMStore DQMStore
 
typedef dqm::reco::MonitorElement MonitorElement
 
- Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
typedef CacheContexts< T... > CacheTypes
 
typedef CacheTypes::GlobalCache GlobalCache
 
typedef AbilityChecker< T... > HasAbility
 
typedef CacheTypes::LuminosityBlockCache LuminosityBlockCache
 
typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache > LuminosityBlockContext
 
typedef CacheTypes::LuminosityBlockSummaryCache LuminosityBlockSummaryCache
 
typedef CacheTypes::RunCache RunCache
 
typedef RunContextT< RunCache, GlobalCache > RunContext
 
typedef CacheTypes::RunSummaryCache RunSummaryCache
 
- Static Public Member Functions inherited from DQMEDAnalyzer
static void globalEndJob (DQMEDAnalyzerGlobalCache const *)
 
static void globalEndLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &setup, LuminosityBlockContext const *context)
 
static void globalEndRunProduce (edm::Run &run, edm::EventSetup const &setup, RunContext const *context)
 
static std::unique_ptr< DQMEDAnalyzerGlobalCache > initializeGlobalCache (edm::ParameterSet const &)
 
- Protected Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMToken > lumiToken_
 
edm::EDPutTokenT< DQMToken > runToken_
 
unsigned int streamId_
 

Detailed Description

Definition at line 21 of file RPCMonitorDigi.h.

Constructor & Destructor Documentation

◆ RPCMonitorDigi()

RPCMonitorDigi::RPCMonitorDigi ( const edm::ParameterSet &  pset)
explicit

Definition at line 18 of file RPCMonitorDigi.cc.

19  : counter(0),
20  muonRPCEvents_(nullptr),
21  NumberOfRecHitMuon_(nullptr),
22  NumberOfMuon_(nullptr),
23  numberOfDisks_(0),
24  numberOfInnerRings_(0) {
25  useMuonDigis_ = pset.getUntrackedParameter<bool>("UseMuon", true);
26  useRollInfo_ = pset.getUntrackedParameter<bool>("UseRollInfo", false);
27 
28  muPtCut_ = pset.getUntrackedParameter<double>("MuonPtCut", 3.0);
29  muEtaCut_ = pset.getUntrackedParameter<double>("MuonEtaCut", 1.9);
30 
31  subsystemFolder_ = pset.getUntrackedParameter<std::string>("RPCFolder", "RPC");
32  globalFolder_ = pset.getUntrackedParameter<std::string>("GlobalFolder", "SummaryHistograms");
33 
34  //Parametersets for tokens
35  muonLabel_ = consumes<reco::CandidateView>(pset.getParameter<edm::InputTag>("MuonLabel"));
36  rpcRecHitLabel_ = consumes<RPCRecHitCollection>(pset.getParameter<edm::InputTag>("RecHitLabel"));
37  scalersRawToDigiLabel_ = consumes<DcsStatusCollection>(pset.getParameter<edm::InputTag>("ScalersRawToDigiLabel"));
38 
39  noiseFolder_ = pset.getUntrackedParameter<std::string>("NoiseFolder", "AllHits");
40  muonFolder_ = pset.getUntrackedParameter<std::string>("MuonFolder", "Muon");
41 }

References globalFolder_, muEtaCut_, muonFolder_, muonLabel_, muPtCut_, noiseFolder_, muonDTDigis_cfi::pset, rpcRecHitLabel_, scalersRawToDigiLabel_, AlCaHLTBitMon_QueryRunRegistry::string, subsystemFolder_, useMuonDigis_, and useRollInfo_.

◆ ~RPCMonitorDigi()

RPCMonitorDigi::~RPCMonitorDigi ( )
overridedefault

Member Function Documentation

◆ analyze()

void RPCMonitorDigi::analyze ( const edm::Event &  event,
const edm::EventSetup &  setup 
)
overrideprotectedvirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 116 of file RPCMonitorDigi.cc.

116  {
117  counter++;
118  edm::LogInfo("rpcmonitordigi") << "[RPCMonitorDigi]: Beginning analyzing event " << counter;
119 
120  //Muons
121  edm::Handle<reco::CandidateView> muonCands;
122  event.getByToken(muonLabel_, muonCands);
123 
124  std::map<RPCDetId, std::vector<RPCRecHit> > rechitMuon;
125 
126  int numMuons = 0;
127  int numRPCRecHit = 0;
128 
129  if (muonCands.isValid()) {
130  int nStaMuons = muonCands->size();
131 
132  for (int i = 0; i < nStaMuons; i++) {
133  const reco::Candidate& goodMuon = (*muonCands)[i];
134  const reco::Muon* muCand = dynamic_cast<const reco::Muon*>(&goodMuon);
135 
136  if (!muCand->isGlobalMuon())
137  continue;
138  if (muCand->pt() < muPtCut_ || fabs(muCand->eta()) > muEtaCut_)
139  continue;
140  numMuons++;
141  reco::Track muTrack = (*(muCand->outerTrack()));
142  std::vector<TrackingRecHitRef> rpcTrackRecHits;
143  //loop on mu rechits
144  for (trackingRecHit_iterator it = muTrack.recHitsBegin(); it != muTrack.recHitsEnd(); it++) {
145  if (!(*it)->isValid())
146  continue;
147  int muSubDetId = (*it)->geographicalId().subdetId();
148  if (muSubDetId == MuonSubdetId::RPC) {
149  numRPCRecHit++;
150  TrackingRecHit* tkRecHit = (*it)->clone();
151  RPCRecHit* rpcRecHit = dynamic_cast<RPCRecHit*>(tkRecHit);
152  int detId = (int)rpcRecHit->rpcId();
153  if (rechitMuon.find(detId) == rechitMuon.end() || rechitMuon[detId].empty()) {
154  std::vector<RPCRecHit> myVect(1, *rpcRecHit);
155  rechitMuon[detId] = myVect;
156  } else {
157  rechitMuon[detId].push_back(*rpcRecHit);
158  }
159  }
160  } // end loop on mu rechits
161  }
162 
163  //Fill muon counter
164  if (NumberOfMuon_) {
165  NumberOfMuon_->Fill(numMuons);
166  }
167 
168  //Fill rechit counter for muons
169  if (NumberOfRecHitMuon_ && numMuons > 0) {
170  NumberOfRecHitMuon_->Fill(numRPCRecHit);
171  }
172 
173  //Fill counter of RPC events with rechits associated in with a muon
174  if (muonRPCEvents_ != nullptr && numRPCRecHit > 0) {
175  muonRPCEvents_->Fill(1);
176  }
177 
178  //Perform client operation
179  this->performSourceOperation(rechitMuon, muonFolder_);
180 
181  } else {
182  edm::LogError("rpcmonitordigi") << "[RPCMonitorDigi]: Muons - Product not valid for event" << counter;
183  }
184 
185  //RecHits
186  edm::Handle<RPCRecHitCollection> rpcHits;
187  event.getByToken(rpcRecHitLabel_, rpcHits);
188  std::map<RPCDetId, std::vector<RPCRecHit> > rechitNoise;
189 
190  if (rpcHits.isValid()) {
191  // RPC rec hits NOT associated to a muon
192  for (auto rpcRecHitIter = rpcHits->begin(); rpcRecHitIter != rpcHits->end(); rpcRecHitIter++) {
193  RPCRecHit rpcRecHit = (*rpcRecHitIter);
194  int detId = (int)rpcRecHit.rpcId();
195  if (rechitNoise.find(detId) == rechitNoise.end() || rechitNoise[detId].empty()) {
196  std::vector<RPCRecHit> myVect(1, rpcRecHit);
197  rechitNoise[detId] = myVect;
198  } else {
199  rechitNoise[detId].push_back(rpcRecHit);
200  }
201  }
202  } else {
203  edm::LogError("rpcmonitordigi") << "[RPCMonitorDigi]: RPCRecHits - Product not valid for event" << counter;
204  }
205 
206  //Fill counter for all RPC events
207  if (noiseRPCEvents_ != nullptr && !rechitNoise.empty()) {
208  noiseRPCEvents_->Fill(1);
209  }
210  //Perform client operation
211  this->performSourceOperation(rechitNoise, noiseFolder_);
212 }

References TrackingRecHit::clone(), counter, reco::LeafCandidate::eta(), dqm::impl::MonitorElement::Fill(), mps_fire::i, createfilelist::int, reco::Muon::isGlobalMuon(), edm::HandleBase::isValid(), muEtaCut_, muonFolder_, muonLabel_, muonRPCEvents_, muPtCut_, noiseFolder_, noiseRPCEvents_, NumberOfMuon_, NumberOfRecHitMuon_, patZpeak::numMuons, reco::Muon::outerTrack(), performSourceOperation(), reco::LeafCandidate::pt(), reco::Track::recHitsBegin(), reco::Track::recHitsEnd(), MuonSubdetId::RPC, RPCRecHit::rpcId(), rpcRecHitLabel_, and edm::View< T >::size().

◆ bookHistograms()

void RPCMonitorDigi::bookHistograms ( DQMStore::IBooker &  ibooker,
edm::Run const &  r,
edm::EventSetup const &  iSetup 
)
overrideprotectedvirtual

Implements DQMEDAnalyzer.

Definition at line 43 of file RPCMonitorDigi.cc.

43  {
44  edm::LogInfo("rpcmonitordigi") << "[RPCMonitorDigi]: Begin Run ";
45 
46  std::set<int> disk_set, ring_set;
47  edm::ESHandle<RPCGeometry> rpcGeoHandle;
48  iSetup.get<MuonGeometryRecord>().get(rpcGeoHandle);
49  const RPCGeometry* rpcGeo = rpcGeoHandle.product();
50 
51  //loop on geometry to book all MEs
52  edm::LogInfo("rpcmonitordigi") << "[RPCMonitorDigi]: Booking histograms per roll. ";
53  for (TrackingGeometry::DetContainer::const_iterator it = rpcGeo->dets().begin(); it < rpcGeo->dets().end(); it++) {
54  if (dynamic_cast<const RPCChamber*>(*it) != nullptr) {
55  const RPCChamber* ch = dynamic_cast<const RPCChamber*>(*it);
56  std::vector<const RPCRoll*> roles = (ch->rolls());
57  if (useRollInfo_) {
58  for (std::vector<const RPCRoll*>::const_iterator r = roles.begin(); r != roles.end(); ++r) {
59  RPCDetId rpcId = (*r)->id();
60 
61  //get station and inner ring
62  if (rpcId.region() != 0) {
63  disk_set.insert(rpcId.station());
64  ring_set.insert(rpcId.ring());
65  }
66 
67  //booking all histograms
68  RPCGeomServ rpcsrv(rpcId);
69  std::string nameID = rpcsrv.name();
70  if (useMuonDigis_)
71  bookRollME(ibooker, rpcId, rpcGeo, muonFolder_, meMuonCollection[nameID]);
72  bookRollME(ibooker, rpcId, rpcGeo, noiseFolder_, meNoiseCollection[nameID]);
73  }
74  } else {
75  RPCDetId rpcId = roles[0]->id(); //any roll would do - here I just take the first one
76  RPCGeomServ rpcsrv(rpcId);
77  std::string nameID = rpcsrv.chambername();
78  if (useMuonDigis_)
79  bookRollME(ibooker, rpcId, rpcGeo, muonFolder_, meMuonCollection[nameID]);
80  bookRollME(ibooker, rpcId, rpcGeo, noiseFolder_, meNoiseCollection[nameID]);
81  if (rpcId.region() != 0) {
82  disk_set.insert(rpcId.station());
83  ring_set.insert(rpcId.ring());
84  }
85  }
86  }
87  } //end loop on geometry to book all MEs
88 
89  numberOfDisks_ = disk_set.size();
90  numberOfInnerRings_ = (*ring_set.begin());
91 
92  //Book
93  this->bookRegionME(ibooker, noiseFolder_, regionNoiseCollection);
94  this->bookSectorRingME(ibooker, noiseFolder_, sectorRingNoiseCollection);
95  this->bookWheelDiskME(ibooker, noiseFolder_, wheelDiskNoiseCollection);
96 
97  std::string currentFolder = subsystemFolder_ + "/" + noiseFolder_;
98  ibooker.setCurrentFolder(currentFolder);
99 
100  noiseRPCEvents_ = ibooker.book1D("RPCEvents", "RPCEvents", 1, 0.5, 1.5);
101 
102  if (useMuonDigis_) {
103  this->bookRegionME(ibooker, muonFolder_, regionMuonCollection);
104  this->bookSectorRingME(ibooker, muonFolder_, sectorRingMuonCollection);
105  this->bookWheelDiskME(ibooker, muonFolder_, wheelDiskMuonCollection);
106 
107  currentFolder = subsystemFolder_ + "/" + muonFolder_;
108  ibooker.setCurrentFolder(currentFolder);
109 
110  muonRPCEvents_ = ibooker.book1D("RPCEvents", "RPCEvents", 1, 0.5, 1.5);
111  NumberOfMuon_ = ibooker.book1D("NumberOfMuons", "Number of Muons", 11, -0.5, 10.5);
112  NumberOfRecHitMuon_ = ibooker.book1D("NumberOfRecHitMuons", "Number of RPC RecHits per Muon", 8, -0.5, 7.5);
113  }
114 }

References dqm::implementation::IBooker::book1D(), bookRegionME(), bookRollME(), bookSectorRingME(), bookWheelDiskME(), RPCGeomServ::chambername(), RPCGeometry::dets(), edm::EventSetup::get(), get, meMuonCollection, meNoiseCollection, muonFolder_, muonRPCEvents_, RPCGeomServ::name(), noiseFolder_, noiseRPCEvents_, numberOfDisks_, numberOfInnerRings_, NumberOfMuon_, NumberOfRecHitMuon_, edm::ESHandle< T >::product(), alignCSCRings::r, RPCDetId::region(), regionMuonCollection, regionNoiseCollection, RPCDetId::ring(), RPCChamber::rolls(), sectorRingMuonCollection, sectorRingNoiseCollection, dqm::implementation::NavigatorBase::setCurrentFolder(), RPCDetId::station(), AlCaHLTBitMon_QueryRunRegistry::string, subsystemFolder_, useMuonDigis_, useRollInfo_, wheelDiskMuonCollection, and wheelDiskNoiseCollection.

◆ bookRegionME()

void RPCMonitorDigi::bookRegionME ( DQMStore::IBooker &  ibooker,
const std::string &  recHitType,
std::map< std::string, MonitorElement * > &  meMap 
)
protected

Booking of MonitoringElemnt at region (Barrel/Endcap) level.

Definition at line 287 of file RPCBookDetUnitME.cc.

289  {
290  std::string currentFolder = subsystemFolder_ + "/" + recHitType + "/" + globalFolder_;
291  ibooker.setCurrentFolder(currentFolder);
292 
293  std::stringstream name;
294  std::stringstream title;
295  for (int r = 0; r < 3; r++) { //RPC regions are E-, B, and E+
296 
297  std::string regionName = RPCMonitorDigi::regionNames_[r];
298  //Cluster size
299  name.str("");
300  title.str("");
301  name << "ClusterSize_" << regionName;
302  title << "ClusterSize - " << regionName;
303  meMap[name.str()] = ibooker.book1D(name.str(), title.str(), 16, 0.5, 16.5);
304  }
305 
306  //Number of Cluster
307  name.str("");
308  title.str("");
309  name << "NumberOfClusters_Barrel";
310  title << "Number of Clusters per Event - Barrel";
311  meMap[name.str()] = ibooker.book1D(name.str(), title.str(), 30, 0.5, 30.5);
312 
313  name.str("");
314  title.str("");
315  name << "NumberOfClusters_Endcap+";
316  title << "Number of Clusters per Event - Endcap+";
317  meMap[name.str()] = ibooker.book1D(name.str(), title.str(), 15, 0.5, 15.5);
318 
319  name.str("");
320  title.str("");
321  name << "NumberOfClusters_Endcap-";
322  title << "Number of Clusters per Event - Endcap-";
323  meMap[name.str()] = ibooker.book1D(name.str(), title.str(), 15, 0.5, 15.5);
324 
325  //Number of Digis
326  name.str("");
327  title.str("");
328  name << "Multiplicity_Barrel";
329  title << "Multiplicity per Event per Roll - Barrel";
330  meMap[name.str()] = ibooker.book1D(name.str(), title.str(), 50, 0.5, 50.5);
331 
332  name.str("");
333  title.str("");
334  name << "Multiplicity_Endcap+";
335  title << "Multiplicity per Event per Roll - Endcap+";
336  meMap[name.str()] = ibooker.book1D(name.str(), title.str(), 32, 0.5, 32.5);
337 
338  name.str("");
339  title.str("");
340  name << "Multiplicity_Endcap-";
341  title << "Multiplicity per Event per Roll - Endcap-";
342  meMap[name.str()] = ibooker.book1D(name.str(), title.str(), 32, 0.5, 32.5);
343 
344  for (int layer = 1; layer <= 6; layer++) {
345  name.str("");
346  title.str("");
347  name << "ClusterSize_Layer" << layer;
348  title << "ClusterSize - Layer" << layer;
349  meMap[name.str()] = ibooker.book1D(name.str(), title.str(), 16, 0.5, 16.5);
350  }
351 
352  for (int ring = RPCMonitorDigi::numberOfInnerRings_; ring <= 3; ring++) {
353  name.str("");
354  title.str("");
355  name << "ClusterSize_Ring" << ring;
356  title << "ClusterSize - Ring" << ring;
357  meMap[name.str()] = ibooker.book1D(name.str(), title.str(), 16, 0.5, 16.5);
358  }
359 
360  meMap["Occupancy_for_Endcap"] = ibooker.book2D("Occupancy_for_Endcap",
361  "Occupancy Endcap",
362  (int)RPCMonitorDigi::numberOfDisks_ * 2.0,
363  0.5,
364  ((float)RPCMonitorDigi::numberOfDisks_ * 2.0) + 0.5,
365  2,
366  1.5,
367  3.5);
368  meMap["Occupancy_for_Endcap"]->setAxisTitle("Disk", 1);
369  meMap["Occupancy_for_Endcap"]->setAxisTitle("Ring", 2);
370 
371  std::stringstream binlabel;
372  for (int bin = 1; bin <= RPCMonitorDigi::numberOfDisks_ * 2; bin++) {
373  binlabel.str("");
374  if (bin < (RPCMonitorDigi::numberOfDisks_ + 1)) { //negative endcap
375  binlabel << (bin - (RPCMonitorDigi::numberOfDisks_ + 1));
376  } else { //positive endcaps
377  binlabel << (bin - RPCMonitorDigi::numberOfDisks_);
378  }
379  meMap["Occupancy_for_Endcap"]->setBinLabel(bin, binlabel.str(), 1);
380  }
381 
382  meMap["Occupancy_for_Endcap"]->setBinLabel(1, "2", 2);
383  meMap["Occupancy_for_Endcap"]->setBinLabel(2, "3", 2);
384 
385  meMap["Occupancy_for_Barrel"] =
386  ibooker.book2D("Occupancy_for_Barrel", "Occupancy Barrel", 12, 0.5, 12.5, 5, -2.5, 2.5);
387  meMap["Occupancy_for_Barrel"]->setAxisTitle("Sec", 1);
388  meMap["Occupancy_for_Barrel"]->setAxisTitle("Wheel", 2);
389 
390  for (int bin = 1; bin <= 12; bin++) {
391  binlabel.str("");
392  binlabel << bin;
393  meMap["Occupancy_for_Barrel"]->setBinLabel(bin, binlabel.str(), 1);
394  if (bin <= 5) {
395  binlabel.str("");
396  binlabel << (bin - 3);
397  meMap["Occupancy_for_Barrel"]->setBinLabel(bin, binlabel.str(), 2);
398  }
399  }
400 }

References newFWLiteAna::bin, dqm::implementation::IBooker::book1D(), dqm::implementation::IBooker::book2D(), globalFolder_, Skims_PA_cff::name, numberOfDisks_, numberOfInnerRings_, alignCSCRings::r, regionNames_, relativeConstraints::ring, dqm::impl::MonitorElement::setAxisTitle(), dqm::implementation::NavigatorBase::setCurrentFolder(), AlCaHLTBitMon_QueryRunRegistry::string, subsystemFolder_, and overlapproblemtsosanalyzer_cfi::title.

Referenced by bookHistograms().

◆ bookRollME()

void RPCMonitorDigi::bookRollME ( DQMStore::IBooker &  ibooker,
const RPCDetId &  detId,
const RPCGeometry *  rpcGeo,
const std::string &  recHitType,
std::map< std::string, MonitorElement * > &  meMap 
)
protected

Booking of MonitoringElement for one RPCDetId (= roll)

Name components common to current RPCDetId

Definition at line 8 of file RPCBookDetUnitME.cc.

12  {
13  RPCBookFolderStructure folderStr;
14  std::string folder = subsystemFolder_ + "/" + recHitType + "/" + folderStr.folderStructure(detId);
15 
16  ibooker.setCurrentFolder(folder);
17 
18  //get number of strips in current roll
19  int nstrips = this->stripsInRoll(detId, rpcGeo);
20  if (nstrips == 0) {
21  nstrips = 1;
22  }
23 
25  RPCGeomServ RPCname(detId);
26  std::string nameRoll = "";
27 
28  if (RPCMonitorDigi::useRollInfo_) {
29  nameRoll = RPCname.name();
30  } else {
31  nameRoll = RPCname.chambername();
32 
33  if (detId.region() != 0 || //Endcaps
34  (abs(detId.ring()) == 2 && detId.station() == 2 && detId.layer() != 1) || //Wheel -/+2 RB2out
35  (abs(detId.ring()) != 2 && detId.station() == 2 && detId.layer() == 1)) {
36  nstrips *= 3;
37  } //Wheel -1,0,+1 RB2in
38  else {
39  nstrips *= 2;
40  }
41  }
42 
43  std::stringstream os;
44  os.str("");
45  os << "Occupancy_" << nameRoll;
46  meMap[os.str()] = ibooker.book1D(os.str(), os.str(), nstrips, 0.5, nstrips + 0.5);
47 
48  os.str("");
49  os << "BXDistribution_" << nameRoll;
50  meMap[os.str()] = ibooker.book1D(os.str(), os.str(), 7, -3.5, 3.5);
51 
52  if (detId.region() == 0) {
53  os.str("");
54  os << "ClusterSize_" << nameRoll;
55  meMap[os.str()] = ibooker.book1D(os.str(), os.str(), 15, 0.5, 15.5);
56 
57  os.str("");
58  os << "Multiplicity_" << nameRoll;
59  meMap[os.str()] = ibooker.book1D(os.str(), os.str(), 30, 0.5, 30.5);
60 
61  } else {
62  os.str("");
63  os << "ClusterSize_" << nameRoll;
64  meMap[os.str()] = ibooker.book1D(os.str(), os.str(), 10, 0.5, 10.5);
65 
66  os.str("");
67  os << "Multiplicity_" << nameRoll;
68  meMap[os.str()] = ibooker.book1D(os.str(), os.str(), 15, 0.5, 15.5);
69  }
70 
71  os.str("");
72  os << "NumberOfClusters_" << nameRoll;
73  meMap[os.str()] = ibooker.book1D(os.str(), os.str(), 10, 0.5, 10.5);
74 }

References funct::abs(), dqm::implementation::IBooker::book1D(), RPCGeomServ::chambername(), printsummarytable::folder, RPCBookFolderStructure::folderStructure(), RPCDetId::layer(), RPCGeomServ::name(), RPCDetId::region(), RPCDetId::ring(), dqm::implementation::NavigatorBase::setCurrentFolder(), RPCDetId::station(), AlCaHLTBitMon_QueryRunRegistry::string, stripsInRoll(), subsystemFolder_, and useRollInfo_.

Referenced by bookHistograms().

◆ bookSectorRingME()

void RPCMonitorDigi::bookSectorRingME ( DQMStore::IBooker &  ibooker,
const std::string &  recHitType,
std::map< std::string, MonitorElement * > &  meMap 
)
protected

Booking of MonitoringElement at Sector/Ring level.

Definition at line 76 of file RPCBookDetUnitME.cc.

78  {
79  std::stringstream os;
80 
81  for (int wheel = -2; wheel <= 2; wheel++) {
82  os.str("");
83  os << subsystemFolder_ << "/" << recHitType << "/Barrel/Wheel_" << wheel << "/SummaryBySectors";
84  ibooker.setCurrentFolder(os.str());
85 
86  for (int sector = 1; sector <= 12; sector++) {
87  os.str("");
88  os << "Occupancy_Wheel_" << wheel << "_Sector_" << sector;
89 
90  if (sector == 9 || sector == 11)
91  meMap[os.str()] = ibooker.book2D(os.str(), os.str(), 91, 0.5, 91.5, 15, 0.5, 15.5);
92  else if (sector == 4)
93  meMap[os.str()] = ibooker.book2D(os.str(), os.str(), 91, 0.5, 91.5, 21, 0.5, 21.5);
94  else
95  meMap[os.str()] = ibooker.book2D(os.str(), os.str(), 91, 0.5, 91.5, 17, 0.5, 17.5);
96 
97  meMap[os.str()]->setAxisTitle("strip", 1);
98  rpcdqm::utils rpcUtils;
99  rpcUtils.labelYAxisRoll(meMap[os.str()], 0, wheel, true);
100  }
101  }
102 
103  for (int region = -1; region <= 1; region++) {
104  if (region == 0)
105  continue;
106 
107  std::string regionName = "Endcap-";
108  if (region == 1)
109  regionName = "Endcap+";
110 
111  for (int disk = 1; disk <= RPCMonitorDigi::numberOfDisks_; disk++) {
112  os.str("");
113  os << subsystemFolder_ << "/" << recHitType << "/" << regionName << "/Disk_" << (region * disk)
114  << "/SummaryByRings/";
115 
116  ibooker.setCurrentFolder(os.str());
117 
118  for (int ring = RPCMonitorDigi::numberOfInnerRings_; ring <= 3; ring++) {
119  os.str("");
120  os << "Occupancy_Disk_" << (region * disk) << "_Ring_" << ring << "_CH01-CH18";
121 
122  meMap[os.str()] = ibooker.book2D(os.str(), os.str(), 96, 0.5, 96.5, 18, 0.5, 18.5);
123  meMap[os.str()]->setAxisTitle("strip", 1);
124  rpcdqm::RPCMEHelper::setNoAlphanumeric(meMap[os.str()]);
125 
126  std::stringstream yLabel;
127  for (int i = 1; i <= 18; i++) {
128  yLabel.str("");
129  yLabel << "R" << ring << "_CH" << std::setw(2) << std::setfill('0') << i;
130  meMap[os.str()]->setBinLabel(i, yLabel.str(), 2);
131  }
132 
133  for (int i = 1; i <= 96; i++) {
134  if (i == 1)
135  meMap[os.str()]->setBinLabel(i, "1", 1);
136  else if (i == 16)
137  meMap[os.str()]->setBinLabel(i, "RollA", 1);
138  else if (i == 32)
139  meMap[os.str()]->setBinLabel(i, "32", 1);
140  else if (i == 33)
141  meMap[os.str()]->setBinLabel(i, "1", 1);
142  else if (i == 48)
143  meMap[os.str()]->setBinLabel(i, "RollB", 1);
144  else if (i == 64)
145  meMap[os.str()]->setBinLabel(i, "32", 1);
146  else if (i == 65)
147  meMap[os.str()]->setBinLabel(i, "1", 1);
148  else if (i == 80)
149  meMap[os.str()]->setBinLabel(i, "RollC", 1);
150  else if (i == 96)
151  meMap[os.str()]->setBinLabel(i, "32", 1);
152  else
153  meMap[os.str()]->setBinLabel(i, "", 1);
154  }
155 
156  os.str("");
157  os << "Occupancy_Disk_" << (region * disk) << "_Ring_" << ring << "_CH19-CH36";
158 
159  meMap[os.str()] = ibooker.book2D(os.str(), os.str(), 96, 0.5, 96.5, 18, 18.5, 36.5);
160  meMap[os.str()]->setAxisTitle("strip", 1);
161  rpcdqm::RPCMEHelper::setNoAlphanumeric(meMap[os.str()]);
162 
163  for (int i = 1; i <= 18; i++) {
164  yLabel.str("");
165  yLabel << "R" << ring << "_CH" << i + 18;
166  meMap[os.str()]->setBinLabel(i, yLabel.str(), 2);
167  }
168 
169  for (int i = 1; i <= 96; i++) {
170  if (i == 1)
171  meMap[os.str()]->setBinLabel(i, "1", 1);
172  else if (i == 16)
173  meMap[os.str()]->setBinLabel(i, "RollA", 1);
174  else if (i == 32)
175  meMap[os.str()]->setBinLabel(i, "32", 1);
176  else if (i == 33)
177  meMap[os.str()]->setBinLabel(i, "1", 1);
178  else if (i == 48)
179  meMap[os.str()]->setBinLabel(i, "RollB", 1);
180  else if (i == 64)
181  meMap[os.str()]->setBinLabel(i, "32", 1);
182  else if (i == 65)
183  meMap[os.str()]->setBinLabel(i, "1", 1);
184  else if (i == 80)
185  meMap[os.str()]->setBinLabel(i, "RollC", 1);
186  else if (i == 96)
187  meMap[os.str()]->setBinLabel(i, "32", 1);
188  else
189  meMap[os.str()]->setBinLabel(i, "", 1);
190  }
191 
192  } //loop ring
193  } //loop disk
194  } //loop region
195 }

References dqm::implementation::IBooker::book2D(), mps_fire::i, rpcdqm::utils::labelYAxisRoll(), numberOfDisks_, numberOfInnerRings_, HLT_2018_cff::region, relativeConstraints::ring, dqm::impl::MonitorElement::setAxisTitle(), dqm::implementation::NavigatorBase::setCurrentFolder(), rpcdqm::RPCMEHelper::setNoAlphanumeric(), AlCaHLTBitMon_QueryRunRegistry::string, subsystemFolder_, and makeMuonMisalignmentScenario::wheel.

Referenced by bookHistograms().

◆ bookWheelDiskME()

void RPCMonitorDigi::bookWheelDiskME ( DQMStore::IBooker &  ibooker,
const std::string &  recHitType,
std::map< std::string, MonitorElement * > &  meMap 
)
protected

Booking of MonitoringElemnt at Wheel/Disk level.

Definition at line 197 of file RPCBookDetUnitME.cc.

199  {
200  ibooker.setCurrentFolder(subsystemFolder_ + "/" + recHitType + "/" + globalFolder_);
201 
202  std::stringstream os, label, name, title;
203  rpcdqm::utils rpcUtils;
204 
205  for (int wheel = -2; wheel <= 2; wheel++) { //Loop on wheel
206  os.str("");
207  os << "1DOccupancy_Wheel_" << wheel;
208  meMap[os.str()] = ibooker.book1D(os.str(), os.str(), 12, 0.5, 12.5);
209  for (int i = 1; i < 12; i++) {
210  label.str("");
211  label << "Sec" << i;
212  meMap[os.str()]->setBinLabel(i, label.str(), 1);
213  }
214 
215  os.str("");
216  os << "Occupancy_Roll_vs_Sector_Wheel_" << wheel;
217  meMap[os.str()] = ibooker.book2D(os.str(), os.str(), 12, 0.5, 12.5, 21, 0.5, 21.5);
218  rpcUtils.labelXAxisSector(meMap[os.str()]);
219  rpcUtils.labelYAxisRoll(meMap[os.str()], 0, wheel, true);
220 
221  os.str("");
222  os << "BxDistribution_Wheel_" << wheel;
223  meMap[os.str()] = ibooker.book1D(os.str(), os.str(), 9, -4.5, 4.5);
224 
225  for (int layer = 1; layer <= 6; layer++) {
226  name.str("");
227  title.str("");
228  name << "ClusterSize_Wheel_" << wheel << "_Layer" << layer;
229  title << "ClusterSize - Wheel " << wheel << " Layer" << layer;
230  meMap[name.str()] = ibooker.book1D(name.str(), title.str(), 16, 0.5, 16.5);
231  }
232 
233  } //end loop on wheel
234 
235  for (int disk = -RPCMonitorDigi::numberOfDisks_; disk <= RPCMonitorDigi::numberOfDisks_; disk++) {
236  if (disk == 0)
237  continue;
238 
239  os.str("");
240  os << "Occupancy_Ring_vs_Segment_Disk_" << disk;
241  meMap[os.str()] = ibooker.book2D(os.str(), os.str(), 36, 0.5, 36.5, 6, 0.5, 6.5);
242 
243  rpcUtils.labelXAxisSegment(meMap[os.str()]);
244  rpcUtils.labelYAxisRing(meMap[os.str()], 2, true);
245 
246  os.str("");
247  os << "BxDistribution_Disk_" << disk;
248  meMap[os.str()] = ibooker.book1D(os.str(), os.str(), 9, -4.5, 4.5);
249 
250  for (int ring = RPCMonitorDigi::numberOfInnerRings_; ring <= 3; ring++) {
251  name.str("");
252  title.str("");
253  name << "ClusterSize_Disk_" << disk << "_Ring" << ring;
254  title << "ClusterSize - Disk" << disk << " Ring" << ring;
255  meMap[name.str()] = ibooker.book1D(name.str(), title.str(), 16, 0.5, 16.5);
256  }
257  }
258 
259  for (int ring = RPCMonitorDigi::numberOfInnerRings_; ring <= 3; ring++) {
260  os.str("");
261  os << "1DOccupancy_Ring_" << ring;
262  meMap[os.str()] = ibooker.book1D(os.str(),
263  os.str(),
264  RPCMonitorDigi::numberOfDisks_ * 2,
265  0.5,
266  ((double)RPCMonitorDigi::numberOfDisks_ * 2.0) + 0.5);
267  for (int xbin = 1; xbin <= RPCMonitorDigi::numberOfDisks_ * 2; xbin++) {
268  label.str("");
269  if (xbin < RPCMonitorDigi::numberOfDisks_ + 1)
270  label << "Disk " << (xbin - (RPCMonitorDigi::numberOfDisks_ + 1));
271  else
272  label << "Disk " << (xbin - RPCMonitorDigi::numberOfDisks_);
273  meMap[os.str()]->setBinLabel(xbin, label.str(), 1);
274  }
275  }
276 }

References dqm::implementation::IBooker::book1D(), dqm::implementation::IBooker::book2D(), globalFolder_, mps_fire::i, label, rpcdqm::utils::labelXAxisSector(), rpcdqm::utils::labelXAxisSegment(), rpcdqm::utils::labelYAxisRing(), rpcdqm::utils::labelYAxisRoll(), Skims_PA_cff::name, numberOfDisks_, numberOfInnerRings_, relativeConstraints::ring, dqm::implementation::NavigatorBase::setCurrentFolder(), subsystemFolder_, overlapproblemtsosanalyzer_cfi::title, and makeMuonMisalignmentScenario::wheel.

Referenced by bookHistograms().

◆ performSourceOperation()

void RPCMonitorDigi::performSourceOperation ( std::map< RPCDetId, std::vector< RPCRecHit > > &  recHitMap,
std::string  recHittype 
)
private

Definition at line 214 of file RPCMonitorDigi.cc.

215  {
216  edm::LogInfo("rpcmonitordigi") << "[RPCMonitorDigi]: Performing DQM source operations for ";
217 
218  if (recHitMap.empty())
219  return;
220 
221  std::map<std::string, std::map<std::string, MonitorElement*> > meRollCollection;
222  std::map<std::string, MonitorElement*> meWheelDisk;
223  std::map<std::string, MonitorElement*> meRegion;
224  std::map<std::string, MonitorElement*> meSectorRing;
225 
226  if (recHittype == muonFolder_) {
227  meRollCollection = meMuonCollection;
228  meWheelDisk = wheelDiskMuonCollection;
229  meRegion = regionMuonCollection;
230  meSectorRing = sectorRingMuonCollection;
231  } else if (recHittype == noiseFolder_) {
232  meRollCollection = meNoiseCollection;
233  meWheelDisk = wheelDiskNoiseCollection;
234  meRegion = regionNoiseCollection;
235  meSectorRing = sectorRingNoiseCollection;
236  } else {
237  edm::LogWarning("rpcmonitordigi") << "[RPCMonitorDigi]: RecHit type not valid.";
238  return;
239  }
240 
241  int totalNumberOfRecHits[3] = {0, 0, 0};
242  std::stringstream os;
243 
244  //Loop on Rolls
245  for (std::map<RPCDetId, std::vector<RPCRecHit> >::const_iterator detIdIter = recHitMap.begin();
246  detIdIter != recHitMap.end();
247  detIdIter++) {
248  RPCDetId detId = (*detIdIter).first;
249 
250  //get roll number
251  rpcdqm::utils rpcUtils;
252  int nr = rpcUtils.detId2RollNr(detId);
253 
254  RPCGeomServ geoServ(detId);
255  std::string nameRoll = "";
256 
257  if (useRollInfo_)
258  nameRoll = geoServ.name();
259  else
260  nameRoll = geoServ.chambername();
261 
262  int region = (int)detId.region();
263  int wheelOrDiskNumber;
264  std::string wheelOrDiskType;
265  int ring = 0;
266  int sector = detId.sector();
267  int layer = 0;
268  int totalRolls = 3;
269  int roll = detId.roll();
270  if (region == 0) {
271  wheelOrDiskType = "Wheel";
272  wheelOrDiskNumber = (int)detId.ring();
273  int station = detId.station();
274 
275  if (station == 1) {
276  if (detId.layer() == 1) {
277  layer = 1; //RB1in
278  totalRolls = 2;
279  } else {
280  layer = 2; //RB1out
281  totalRolls = 2;
282  }
283  if (roll == 3)
284  roll = 2; // roll=3 is Forward
285  } else if (station == 2) {
286  if (detId.layer() == 1) {
287  layer = 3; //RB2in
288  if (abs(wheelOrDiskNumber) == 2 && roll == 3) {
289  roll = 2; //W -2, +2 RB2in has only 2 rolls
290  totalRolls = 2;
291  }
292  } else {
293  layer = 4; //RB2out
294  if (abs(wheelOrDiskNumber) != 2 && roll == 3) {
295  roll = 2; //W -1, 0, +1 RB2out has only 2 rolls
296  totalRolls = 2;
297  }
298  }
299  } else if (station == 3) {
300  layer = 5; //RB3
301  totalRolls = 2;
302  if (roll == 3)
303  roll = 2;
304  } else {
305  layer = 6; //RB4
306  totalRolls = 2;
307  if (roll == 3)
308  roll = 2;
309  }
310 
311  } else {
312  wheelOrDiskType = "Disk";
313  wheelOrDiskNumber = region * (int)detId.station();
314  ring = detId.ring();
315  }
316 
317  std::vector<RPCRecHit> recHits = (*detIdIter).second;
318  int numberOfRecHits = recHits.size();
319  totalNumberOfRecHits[region + 1] += numberOfRecHits;
320 
321  std::set<int> bxSet;
322  int numDigi = 0;
323 
324  std::map<std::string, MonitorElement*> meMap = meRollCollection[nameRoll];
325 
326  //Loop on recHits
327  for (std::vector<RPCRecHit>::const_iterator recHitIter = recHits.begin(); recHitIter != recHits.end();
328  recHitIter++) {
329  RPCRecHit recHit = (*recHitIter);
330 
331  int bx = recHit.BunchX();
332  bxSet.insert(bx);
333  int clusterSize = (int)recHit.clusterSize();
334  numDigi += clusterSize;
335  int firstStrip = recHit.firstClusterStrip();
336  int lastStrip = clusterSize + firstStrip - 1;
337 
338  // ###################### Roll Level #################################
339 
340  os.str("");
341  os << "Occupancy_" << nameRoll;
342  if (meMap[os.str()]) {
343  for (int s = firstStrip; s <= lastStrip; s++) {
344  if (useRollInfo_) {
345  meMap[os.str()]->Fill(s);
346  } else {
347  int nstrips = meMap[os.str()]->getNbinsX() / totalRolls;
348  meMap[os.str()]->Fill(s + nstrips * (roll - 1));
349  }
350  }
351  }
352 
353  os.str("");
354  os << "BXDistribution_" << nameRoll;
355  if (meMap[os.str()])
356  meMap[os.str()]->Fill(bx);
357 
358  os.str("");
359  os << "ClusterSize_" << nameRoll;
360  if (meMap[os.str()])
361  meMap[os.str()]->Fill(clusterSize);
362 
363  // ###################### Sector- Ring Level #################################
364 
365  os.str("");
366  os << "Occupancy_" << wheelOrDiskType << "_" << wheelOrDiskNumber << "_Sector_" << sector;
367  if (meSectorRing[os.str()]) {
368  for (int s = firstStrip; s <= lastStrip; s++) { //Loop on digis
369  meSectorRing[os.str()]->Fill(s, nr);
370  }
371  }
372 
373  os.str("");
374  if (geoServ.segment() > 0 && geoServ.segment() < 19) {
375  os << "Occupancy_" << wheelOrDiskType << "_" << wheelOrDiskNumber << "_Ring_" << ring << "_CH01-CH18";
376  } else if (geoServ.segment() > 18) {
377  os << "Occupancy_" << wheelOrDiskType << "_" << wheelOrDiskNumber << "_Ring_" << ring << "_CH19-CH36";
378  }
379 
380  if (meSectorRing[os.str()]) {
381  for (int s = firstStrip; s <= lastStrip; s++) { //Loop on digis
382  meSectorRing[os.str()]->Fill(s + 32 * (detId.roll() - 1), geoServ.segment());
383  }
384  }
385 
386  // ###################### Wheel/Disk Level #########################
387  if (region == 0) {
388  os.str("");
389  os << "1DOccupancy_Wheel_" << wheelOrDiskNumber;
390  if (meWheelDisk[os.str()])
391  meWheelDisk[os.str()]->Fill(sector, clusterSize);
392 
393  os.str("");
394  os << "Occupancy_Roll_vs_Sector_" << wheelOrDiskType << "_" << wheelOrDiskNumber;
395  if (meWheelDisk[os.str()])
396  meWheelDisk[os.str()]->Fill(sector, nr, clusterSize);
397 
398  } else {
399  os.str("");
400  os << "1DOccupancy_Ring_" << ring;
401  if ((meWheelDisk[os.str()])) {
402  if (wheelOrDiskNumber > 0) {
403  meWheelDisk[os.str()]->Fill(wheelOrDiskNumber + numberOfDisks_, clusterSize);
404  } else {
405  meWheelDisk[os.str()]->Fill(wheelOrDiskNumber + numberOfDisks_ + 1, clusterSize);
406  }
407  }
408 
409  os.str("");
410  os << "Occupancy_Ring_vs_Segment_" << wheelOrDiskType << "_" << wheelOrDiskNumber;
411  if (meWheelDisk[os.str()])
412  meWheelDisk[os.str()]->Fill(geoServ.segment(), (ring - 1) * 3 - detId.roll() + 1, clusterSize);
413  }
414 
415  os.str("");
416  os << "BxDistribution_" << wheelOrDiskType << "_" << wheelOrDiskNumber;
417  if (meWheelDisk[os.str()])
418  meWheelDisk[os.str()]->Fill(bx);
419 
420  os.str("");
421  os << "ClusterSize_" << wheelOrDiskType << "_" << wheelOrDiskNumber << "_Layer" << layer;
422  if (meWheelDisk[os.str()])
423  meWheelDisk[os.str()]->Fill(clusterSize);
424 
425  os.str("");
426  os << "ClusterSize_" << wheelOrDiskType << "_" << wheelOrDiskNumber << "_Ring" << ring;
427  if (meWheelDisk[os.str()])
428  meWheelDisk[os.str()]->Fill(clusterSize);
429 
430  // ###################### Global ##################################
431 
432  os.str("");
433  os << "ClusterSize_" << RPCMonitorDigi::regionNames_[region + 1];
434  if (meRegion[os.str()])
435  meRegion[os.str()]->Fill(clusterSize);
436 
437  os.str("");
438  os << "ClusterSize_";
439  if (region == 0) {
440  os << "Layer" << layer;
441  } else {
442  os << "Ring" << ring;
443  }
444  if (meRegion[os.str()])
445  meRegion[os.str()]->Fill(clusterSize);
446 
447  } //end loop on recHits
448 
449  os.str("");
450  os << "BXWithData_" << nameRoll;
451  if (meMap[os.str()])
452  meMap[os.str()]->Fill(bxSet.size());
453 
454  os.str("");
455  os << "NumberOfClusters_" << nameRoll;
456  if (meMap[os.str()])
457  meMap[os.str()]->Fill(numberOfRecHits);
458 
459  os.str("");
460  os << "Multiplicity_" << RPCMonitorDigi::regionNames_[region + 1];
461  if (meRegion[os.str()])
462  meRegion[os.str()]->Fill(numDigi);
463 
464  os.str("");
465  if (region == 0) {
466  os << "Occupancy_for_Barrel";
467  if (meRegion[os.str()])
468  meRegion[os.str()]->Fill(sector, wheelOrDiskNumber, numDigi);
469  } else {
470  os << "Occupancy_for_Endcap";
471  int xbin = wheelOrDiskNumber + numberOfDisks_;
472  if (region == -1) {
473  xbin = wheelOrDiskNumber + numberOfDisks_ + 1;
474  }
475  if (meRegion[os.str()]) {
476  meRegion[os.str()]->Fill(xbin, ring, numDigi);
477  }
478  }
479 
480  os.str("");
481  os << "Multiplicity_" << nameRoll;
482  if (meMap[os.str()])
483  meMap[os.str()]->Fill(numDigi);
484 
485  } //end loop on rolls
486 
487  for (int i = 0; i < 3; i++) {
488  os.str("");
489  os << "NumberOfClusters_" << RPCMonitorDigi::regionNames_[i];
490  if (meRegion[os.str()])
491  meRegion[os.str()]->Fill(totalNumberOfRecHits[i]);
492  }
493 }

References funct::abs(), l1GtPatternGenerator_cfi::bx, RPCGeomServ::chambername(), rpcdqm::utils::detId2RollNr(), mps_fire::i, createfilelist::int, RPCDetId::layer(), genParticles_cff::map, meMuonCollection, meNoiseCollection, muonFolder_, RPCGeomServ::name(), noiseFolder_, EgHLTOffHistBins_cfi::nr, numberOfDisks_, rpcPointValidation_cfi::recHit, FastTrackerRecHitMaskProducer_cfi::recHits, RPCDetId::region(), HLT_2018_cff::region, regionMuonCollection, regionNames_, regionNoiseCollection, RPCDetId::ring(), relativeConstraints::ring, RPCDetId::roll(), alignCSCRings::s, RPCDetId::sector(), sectorRingMuonCollection, sectorRingNoiseCollection, RPCGeomServ::segment(), relativeConstraints::station, RPCDetId::station(), AlCaHLTBitMon_QueryRunRegistry::string, useRollInfo_, wheelDiskMuonCollection, and wheelDiskNoiseCollection.

Referenced by analyze().

◆ stripsInRoll()

int RPCMonitorDigi::stripsInRoll ( const RPCDetId &  id,
const RPCGeometry *  rpcGeo 
) const
private

Definition at line 279 of file RPCBookDetUnitME.cc.

279  {
280  const RPCRoll* rpcRoll = rpcGeo->roll(id);
281  if (!rpcRoll)
282  return 1;
283 
284  return rpcRoll->nstrips();
285 }

References RPCRoll::nstrips(), and RPCGeometry::roll().

Referenced by bookRollME().

Member Data Documentation

◆ counter

int RPCMonitorDigi::counter
private

Definition at line 51 of file RPCMonitorDigi.h.

Referenced by counter.Counters::__getitem__(), and analyze().

◆ globalFolder_

std::string RPCMonitorDigi::globalFolder_
private

Definition at line 73 of file RPCMonitorDigi.h.

Referenced by bookRegionME(), bookWheelDiskME(), and RPCMonitorDigi().

◆ meMuonCollection

std::map<std::string, std::map<std::string, MonitorElement *> > RPCMonitorDigi::meMuonCollection
private

Definition at line 63 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and performSourceOperation().

◆ meNoiseCollection

std::map<std::string, std::map<std::string, MonitorElement *> > RPCMonitorDigi::meNoiseCollection
private

Definition at line 68 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and performSourceOperation().

◆ muEtaCut_

float RPCMonitorDigi::muEtaCut_
private

Definition at line 53 of file RPCMonitorDigi.h.

Referenced by analyze(), and RPCMonitorDigi().

◆ muonFolder_

std::string RPCMonitorDigi::muonFolder_
private

Definition at line 49 of file RPCMonitorDigi.h.

Referenced by analyze(), bookHistograms(), performSourceOperation(), and RPCMonitorDigi().

◆ muonLabel_

edm::EDGetTokenT<reco::CandidateView> RPCMonitorDigi::muonLabel_
private

Definition at line 76 of file RPCMonitorDigi.h.

Referenced by analyze(), and RPCMonitorDigi().

◆ muonRPCEvents_

MonitorElement* RPCMonitorDigi::muonRPCEvents_
private

Definition at line 56 of file RPCMonitorDigi.h.

Referenced by analyze(), and bookHistograms().

◆ muPtCut_

float RPCMonitorDigi::muPtCut_
private

Definition at line 53 of file RPCMonitorDigi.h.

Referenced by analyze(), and RPCMonitorDigi().

◆ noiseFolder_

std::string RPCMonitorDigi::noiseFolder_
private

Definition at line 50 of file RPCMonitorDigi.h.

Referenced by analyze(), bookHistograms(), performSourceOperation(), and RPCMonitorDigi().

◆ noiseRPCEvents_

MonitorElement* RPCMonitorDigi::noiseRPCEvents_
private

Definition at line 55 of file RPCMonitorDigi.h.

Referenced by analyze(), and bookHistograms().

◆ numberOfDisks_

int RPCMonitorDigi::numberOfDisks_
private

Definition at line 61 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), bookRegionME(), bookSectorRingME(), bookWheelDiskME(), and performSourceOperation().

◆ numberOfInnerRings_

int RPCMonitorDigi::numberOfInnerRings_
private

Definition at line 61 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), bookRegionME(), bookSectorRingME(), and bookWheelDiskME().

◆ NumberOfMuon_

MonitorElement* RPCMonitorDigi::NumberOfMuon_
private

Definition at line 59 of file RPCMonitorDigi.h.

Referenced by analyze(), and bookHistograms().

◆ NumberOfRecHitMuon_

MonitorElement* RPCMonitorDigi::NumberOfRecHitMuon_
private

Definition at line 58 of file RPCMonitorDigi.h.

Referenced by analyze(), and bookHistograms().

◆ regionMuonCollection

std::map<std::string, MonitorElement *> RPCMonitorDigi::regionMuonCollection
private

Definition at line 65 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and performSourceOperation().

◆ regionNames_

const std::array< std::string, 3 > RPCMonitorDigi::regionNames_ = {{"Endcap-", "Barrel", "Endcap+"}}
staticprivate

Definition at line 48 of file RPCMonitorDigi.h.

Referenced by bookRegionME(), and performSourceOperation().

◆ regionNoiseCollection

std::map<std::string, MonitorElement *> RPCMonitorDigi::regionNoiseCollection
private

Definition at line 70 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and performSourceOperation().

◆ rpcRecHitLabel_

edm::EDGetTokenT<RPCRecHitCollection> RPCMonitorDigi::rpcRecHitLabel_
private

Definition at line 77 of file RPCMonitorDigi.h.

Referenced by analyze(), and RPCMonitorDigi().

◆ scalersRawToDigiLabel_

edm::EDGetTokenT<DcsStatusCollection> RPCMonitorDigi::scalersRawToDigiLabel_
private

Definition at line 78 of file RPCMonitorDigi.h.

Referenced by RPCMonitorDigi().

◆ sectorRingMuonCollection

std::map<std::string, MonitorElement *> RPCMonitorDigi::sectorRingMuonCollection
private

Definition at line 66 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and performSourceOperation().

◆ sectorRingNoiseCollection

std::map<std::string, MonitorElement *> RPCMonitorDigi::sectorRingNoiseCollection
private

Definition at line 71 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and performSourceOperation().

◆ subsystemFolder_

std::string RPCMonitorDigi::subsystemFolder_
private

Definition at line 74 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), bookRegionME(), bookRollME(), bookSectorRingME(), bookWheelDiskME(), and RPCMonitorDigi().

◆ useMuonDigis_

bool RPCMonitorDigi::useMuonDigis_
private

Definition at line 43 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and RPCMonitorDigi().

◆ useRollInfo_

bool RPCMonitorDigi::useRollInfo_
private

Definition at line 54 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), bookRollME(), performSourceOperation(), and RPCMonitorDigi().

◆ wheelDiskMuonCollection

std::map<std::string, MonitorElement *> RPCMonitorDigi::wheelDiskMuonCollection
private

Definition at line 64 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and performSourceOperation().

◆ wheelDiskNoiseCollection

std::map<std::string, MonitorElement *> RPCMonitorDigi::wheelDiskNoiseCollection
private

Definition at line 69 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and performSourceOperation().

rpcdqm::utils::labelXAxisSegment
void labelXAxisSegment(MonitorElement *myMe)
Definition: utils.h:247
edm::ESHandle::product
T const * product() const
Definition: ESHandle.h:86
RPCRoll
Definition: RPCRoll.h:12
counter
Definition: counter.py:1
RPCMonitorDigi::counter
int counter
Definition: RPCMonitorDigi.h:51
mps_fire.i
i
Definition: mps_fire.py:355
RPCGeomServ
Definition: RPCGeomServ.h:8
RPCDetId::station
int station() const
Definition: RPCDetId.h:78
RPCDetId::region
int region() const
Region id: 0 for Barrel, +/-1 For +/- Endcap.
Definition: RPCDetId.h:53
RPCMonitorDigi::NumberOfRecHitMuon_
MonitorElement * NumberOfRecHitMuon_
Definition: RPCMonitorDigi.h:58
reco::Track::recHitsBegin
trackingRecHit_iterator recHitsBegin() const
Iterator to first hit on the track.
Definition: Track.h:88
rpcdqm::RPCMEHelper::setNoAlphanumeric
static void setNoAlphanumeric(MonitorElement *myMe)
Definition: utils.h:18
RPCMonitorDigi::muEtaCut_
float muEtaCut_
Definition: RPCMonitorDigi.h:53
printsummarytable.folder
folder
Definition: printsummarytable.py:7
relativeConstraints.station
station
Definition: relativeConstraints.py:67
RPCMonitorDigi::performSourceOperation
void performSourceOperation(std::map< RPCDetId, std::vector< RPCRecHit > > &, std::string)
Definition: RPCMonitorDigi.cc:214
RPCDetId
Definition: RPCDetId.h:16
edm::LogInfo
Definition: MessageLogger.h:254
l1GtPatternGenerator_cfi.bx
bx
Definition: l1GtPatternGenerator_cfi.py:18
RPCMonitorDigi::NumberOfMuon_
MonitorElement * NumberOfMuon_
Definition: RPCMonitorDigi.h:59
RPCMonitorDigi::sectorRingNoiseCollection
std::map< std::string, MonitorElement * > sectorRingNoiseCollection
Definition: RPCMonitorDigi.h:71
RPCGeometry::roll
const RPCRoll * roll(RPCDetId id) const
Return a roll given its id.
Definition: RPCGeometry.cc:50
rpcdqm::utils::labelYAxisRoll
void labelYAxisRoll(MonitorElement *myMe, int region, int ring, bool useRollInfo)
Definition: utils.h:265
RPCMonitorDigi::subsystemFolder_
std::string subsystemFolder_
Definition: RPCMonitorDigi.h:74
reco::LeafCandidate::pt
double pt() const final
transverse momentum
Definition: LeafCandidate.h:146
RPCChamber::rolls
const std::vector< const RPCRoll * > & rolls() const
Return the Rolls.
Definition: RPCChamber.cc:40
RPCMonitorDigi::numberOfDisks_
int numberOfDisks_
Definition: RPCMonitorDigi.h:61
edm::Handle
Definition: AssociativeIterator.h:50
RPCMonitorDigi::noiseFolder_
std::string noiseFolder_
Definition: RPCMonitorDigi.h:50
RPCChamber
Definition: RPCChamber.h:19
rpcPointValidation_cfi.recHit
recHit
Definition: rpcPointValidation_cfi.py:7
RPCMonitorDigi::meMuonCollection
std::map< std::string, std::map< std::string, MonitorElement * > > meMuonCollection
Definition: RPCMonitorDigi.h:63
reco::Muon
Definition: Muon.h:27
RPCBookFolderStructure::folderStructure
std::string folderStructure(RPCDetId detId)
Definition: RPCBookFolderStructure.h:18
RPCMonitorDigi::bookRollME
void bookRollME(DQMStore::IBooker &, const RPCDetId &, const RPCGeometry *rpcGeo, const std::string &, std::map< std::string, MonitorElement * > &)
Booking of MonitoringElement for one RPCDetId (= roll)
Definition: RPCBookDetUnitME.cc:8
alignCSCRings.s
s
Definition: alignCSCRings.py:92
RPCMonitorDigi::wheelDiskNoiseCollection
std::map< std::string, MonitorElement * > wheelDiskNoiseCollection
Definition: RPCMonitorDigi.h:69
RPCMonitorDigi::regionMuonCollection
std::map< std::string, MonitorElement * > regionMuonCollection
Definition: RPCMonitorDigi.h:65
rpcdqm::utils
Definition: utils.h:29
RPCMonitorDigi::muonLabel_
edm::EDGetTokenT< reco::CandidateView > muonLabel_
Definition: RPCMonitorDigi.h:76
RPCRecHit
Definition: RPCRecHit.h:14
dqm::impl::MonitorElement::Fill
void Fill(long long x)
Definition: MonitorElement.h:290
reco::Track::recHitsEnd
trackingRecHit_iterator recHitsEnd() const
Iterator to last hit on the track.
Definition: Track.h:91
reco::Track
Definition: Track.h:27
reco::Muon::outerTrack
virtual TrackRef outerTrack() const
reference to Track reconstructed in the muon detector only
Definition: Muon.h:48
edm::ESHandle< RPCGeometry >
RPCMonitorDigi::muPtCut_
float muPtCut_
Definition: RPCMonitorDigi.h:53
RPCGeometry::dets
const DetContainer & dets() const override
Returm a vector of all GeomDet (including all GeomDetUnits)
Definition: RPCGeometry.cc:24
RPCMonitorDigi::scalersRawToDigiLabel_
edm::EDGetTokenT< DcsStatusCollection > scalersRawToDigiLabel_
Definition: RPCMonitorDigi.h:78
edm::OwnVector::const_iterator
Definition: OwnVector.h:41
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
edm::View::size
size_type size() const
RPCMonitorDigi::regionNames_
static const std::array< std::string, 3 > regionNames_
Definition: RPCMonitorDigi.h:48
FastTrackerRecHitMaskProducer_cfi.recHits
recHits
Definition: FastTrackerRecHitMaskProducer_cfi.py:8
edm::LogWarning
Definition: MessageLogger.h:141
reco::Muon::isGlobalMuon
bool isGlobalMuon() const override
Definition: Muon.h:299
RPCBookFolderStructure
Definition: RPCBookFolderStructure.h:13
RPCDetId::roll
int roll() const
Definition: RPCDetId.h:92
RPCMonitorDigi::bookWheelDiskME
void bookWheelDiskME(DQMStore::IBooker &, const std::string &, std::map< std::string, MonitorElement * > &)
Booking of MonitoringElemnt at Wheel/Disk level.
Definition: RPCBookDetUnitME.cc:197
edm::LogError
Definition: MessageLogger.h:183
EgHLTOffHistBins_cfi.nr
nr
Definition: EgHLTOffHistBins_cfi.py:4
RPCMonitorDigi::useMuonDigis_
bool useMuonDigis_
Definition: RPCMonitorDigi.h:43
reco::LeafCandidate::eta
double eta() const final
momentum pseudorapidity
Definition: LeafCandidate.h:152
RPCMonitorDigi::stripsInRoll
int stripsInRoll(const RPCDetId &id, const RPCGeometry *rpcGeo) const
Definition: RPCBookDetUnitME.cc:279
RPCMonitorDigi::meNoiseCollection
std::map< std::string, std::map< std::string, MonitorElement * > > meNoiseCollection
Definition: RPCMonitorDigi.h:68
makeMuonMisalignmentScenario.wheel
wheel
Definition: makeMuonMisalignmentScenario.py:319
createfilelist.int
int
Definition: createfilelist.py:10
RPCMonitorDigi::numberOfInnerRings_
int numberOfInnerRings_
Definition: RPCMonitorDigi.h:61
RPCRoll::nstrips
int nstrips() const
Definition: RPCRoll.cc:24
rpcdqm::utils::labelYAxisRing
void labelYAxisRing(MonitorElement *myMe, int numberOfRings, bool useRollInfo)
Definition: utils.h:291
RPCMonitorDigi::noiseRPCEvents_
MonitorElement * noiseRPCEvents_
Definition: RPCMonitorDigi.h:55
RPCMonitorDigi::bookRegionME
void bookRegionME(DQMStore::IBooker &, const std::string &, std::map< std::string, MonitorElement * > &)
Booking of MonitoringElemnt at region (Barrel/Endcap) level.
Definition: RPCBookDetUnitME.cc:287
rpcdqm::utils::detId2RollNr
int detId2RollNr(const RPCDetId &_id)
Definition: utils.h:31
get
#define get
TrackingRecHit::clone
virtual TrackingRecHit * clone() const =0
reco::Candidate
Definition: Candidate.h:27
RPCDetId::ring
int ring() const
Definition: RPCDetId.h:59
TrackingRecHit
Definition: TrackingRecHit.h:21
RPCMonitorDigi::sectorRingMuonCollection
std::map< std::string, MonitorElement * > sectorRingMuonCollection
Definition: RPCMonitorDigi.h:66
alignCSCRings.r
r
Definition: alignCSCRings.py:93
newFWLiteAna.bin
bin
Definition: newFWLiteAna.py:161
overlapproblemtsosanalyzer_cfi.title
title
Definition: overlapproblemtsosanalyzer_cfi.py:7
RPCMonitorDigi::globalFolder_
std::string globalFolder_
Definition: RPCMonitorDigi.h:73
RPCMonitorDigi::regionNoiseCollection
std::map< std::string, MonitorElement * > regionNoiseCollection
Definition: RPCMonitorDigi.h:70
RPCMonitorDigi::bookSectorRingME
void bookSectorRingME(DQMStore::IBooker &, const std::string &, std::map< std::string, MonitorElement * > &)
Booking of MonitoringElement at Sector/Ring level.
Definition: RPCBookDetUnitME.cc:76
MuonSubdetId::RPC
static constexpr int RPC
Definition: MuonSubdetId.h:13
RPCMonitorDigi::useRollInfo_
bool useRollInfo_
Definition: RPCMonitorDigi.h:54
RPCDetId::sector
int sector() const
Sector id: the group of chambers at same phi (and increasing r)
Definition: RPCDetId.h:81
RPCMonitorDigi::muonFolder_
std::string muonFolder_
Definition: RPCMonitorDigi.h:49
rpcdqm::utils::labelXAxisSector
void labelXAxisSector(MonitorElement *myMe)
Definition: utils.h:231
relativeConstraints.ring
ring
Definition: relativeConstraints.py:68
HLT_2018_cff.region
region
Definition: HLT_2018_cff.py:81479
Skims_PA_cff.name
name
Definition: Skims_PA_cff.py:17
RPCMonitorDigi::wheelDiskMuonCollection
std::map< std::string, MonitorElement * > wheelDiskMuonCollection
Definition: RPCMonitorDigi.h:64
RPCGeometry
Definition: RPCGeometry.h:20
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
genParticles_cff.map
map
Definition: genParticles_cff.py:11
RPCMonitorDigi::rpcRecHitLabel_
edm::EDGetTokenT< RPCRecHitCollection > rpcRecHitLabel_
Definition: RPCMonitorDigi.h:77
RPCRecHit::rpcId
RPCDetId rpcId() const
Return the rpcId.
Definition: RPCRecHit.h:71
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:70
RPCDetId::layer
int layer() const
Definition: RPCDetId.h:85
patZpeak.numMuons
numMuons
Definition: patZpeak.py:41
MuonGeometryRecord
Definition: MuonGeometryRecord.h:34
edm::InputTag
Definition: InputTag.h:15
label
const char * label
Definition: PFTauDecayModeTools.cc:11
RPCMonitorDigi::muonRPCEvents_
MonitorElement * muonRPCEvents_
Definition: RPCMonitorDigi.h:56
muonDTDigis_cfi.pset
pset
Definition: muonDTDigis_cfi.py:27
Generated for CMSSW Reference Manual by doxygen 1.8.16