CMS 3D CMS Logo

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
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::one::EDProducer< edm::EndRunProducer, edm::one::WatchRuns, edm::EndLuminosityBlockProducer, edm::one::WatchLuminosityBlocks, edm::Accumulator > edm::one::EDProducerBase edm::ProducerBase edm::EDConsumerBase edm::ProductRegistryHelper

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
 
virtual void analyze (edm::Event const &, edm::EventSetup const &)
 
void beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final
 
void beginRun (edm::Run const &run, edm::EventSetup const &setup) final
 
virtual void dqmBeginLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &)
 
virtual void dqmBeginRun (edm::Run const &, edm::EventSetup const &)
 
 DQMEDAnalyzer ()
 
virtual void dqmEndLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &)
 
virtual void dqmEndRun (edm::Run const &, edm::EventSetup const &)
 
void endLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &) final
 
void endLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &setup) final
 
void endRun (edm::Run const &, edm::EventSetup const &) final
 
void endRunProduce (edm::Run &run, edm::EventSetup const &setup) final
 
virtual bool getCanSaveByLumi ()
 
- Public Member Functions inherited from edm::one::EDProducer< edm::EndRunProducer, edm::one::WatchRuns, edm::EndLuminosityBlockProducer, edm::one::WatchLuminosityBlocks, edm::Accumulator >
 EDProducer ()=default
 
SerialTaskQueueglobalLuminosityBlocksQueue () final
 
SerialTaskQueueglobalRunsQueue () final
 
bool hasAbilityToProduceInBeginLumis () const final
 
bool hasAbilityToProduceInBeginRuns () const final
 
bool hasAbilityToProduceInEndLumis () const final
 
bool hasAbilityToProduceInEndRuns () const final
 
bool wantsGlobalLuminosityBlocks () const final
 
bool wantsGlobalRuns () const final
 
- Public Member Functions inherited from edm::one::EDProducerBase
 EDProducerBase ()
 
ModuleDescription const & moduleDescription () const
 
bool wantsStreamLuminosityBlocks () const
 
bool wantsStreamRuns () const
 
 ~EDProducerBase () override
 
- Public Member Functions inherited from edm::ProducerBase
void callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
 
std::vector< edm::ProductResolverIndex > const & indiciesForPutProducts (BranchType iBranchType) const
 
 ProducerBase ()
 
std::vector< edm::ProductResolverIndex > const & putTokenIndexToProductResolverIndex () const
 
void registerProducts (ProducerBase *, ProductRegistry *, ModuleDescription const &)
 
std::function< void(BranchDescription const &)> registrationCallback () const
 used by the fwk to register list of products More...
 
void resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)
 
 ~ProducerBase () noexcept(false) override
 
- Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfoconsumesInfo () const
 
void convertCurrentProcessAlias (std::string const &processName)
 Convert "@currentProcess" in InputTag process names to the actual current process name. More...
 
 EDConsumerBase ()
 
 EDConsumerBase (EDConsumerBase const &)=delete
 
 EDConsumerBase (EDConsumerBase &&)=default
 
ESProxyIndex const * esGetTokenIndices (edm::Transition iTrans) const
 
ProductResolverIndexAndSkipBit indexFrom (EDGetToken, BranchType, TypeID const &) const
 
void itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
 
void itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
 
std::vector< ProductResolverIndexAndSkipBit > const & itemsToGetFrom (BranchType iType) const
 
void labelsForToken (EDGetToken iToken, Labels &oLabels) const
 
void modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
 
EDConsumerBase const & operator= (EDConsumerBase const &)=delete
 
EDConsumerBaseoperator= (EDConsumerBase &&)=default
 
bool registeredToConsume (ProductResolverIndex, bool, BranchType) const
 
bool registeredToConsumeMany (TypeID const &, BranchType) const
 
ProductResolverIndexAndSkipBit uncheckedIndexFrom (EDGetToken) const
 
void updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
 
void updateLookup (eventsetup::ESRecordsToProxyIndices const &)
 
virtual ~EDConsumerBase () noexcept(false)
 

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 edm::ProducerBase
ProducesCollector producesCollector ()
 
- Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType > consumes (edm::InputTag const &tag)
 
EDGetToken consumes (const TypeToGet &id, edm::InputTag const &tag)
 
template<BranchType B>
EDGetToken consumes (TypeToGet const &id, edm::InputTag const &tag)
 
ConsumesCollector consumesCollector ()
 Use a ConsumesCollector to gather consumes information from helper functions. More...
 
template<typename ProductType , BranchType B = InEvent>
void consumesMany ()
 
void consumesMany (const TypeToGet &id)
 
template<BranchType B>
void consumesMany (const TypeToGet &id)
 
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto esConsumes ()
 
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto esConsumes (ESInputTag const &tag)
 
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType > mayConsume (edm::InputTag const &tag)
 
EDGetToken mayConsume (const TypeToGet &id, edm::InputTag const &tag)
 
template<BranchType B>
EDGetToken mayConsume (const TypeToGet &id, edm::InputTag const &tag)
 

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::CandidateViewmuonLabel_
 
MonitorElementmuonRPCEvents_
 
float muPtCut_
 
std::string noiseFolder_
 
MonitorElementnoiseRPCEvents_
 
int numberOfDisks_
 
int numberOfInnerRings_
 
MonitorElementNumberOfMuon_
 
MonitorElementNumberOfRecHitMuon_
 
std::map< std::string, MonitorElement * > regionMuonCollection
 
std::map< std::string, MonitorElement * > regionNoiseCollection
 
edm::EDGetTokenT< RPCRecHitCollectionrpcRecHitLabel_
 
edm::EDGetTokenT< DcsStatusCollectionscalersRawToDigiLabel_
 
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::one::EDProducerBase
typedef EDProducerBase ModuleType
 
- Public Types inherited from edm::ProducerBase
using ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const *, const char *, edm::ProductResolverIndex >>
 
typedef ProductRegistryHelper::TypeLabelList TypeLabelList
 
- Public Types inherited from edm::EDConsumerBase
typedef ProductLabels Labels
 
- Static Public Member Functions inherited from edm::one::EDProducerBase
static const std::string & baseType ()
 
static void fillDescriptions (ConfigurationDescriptions &descriptions)
 
static void prevalidate (ConfigurationDescriptions &descriptions)
 
- Protected Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMTokenlumiToken_
 
edm::EDPutTokenT< DQMTokenrunToken_
 

Detailed Description

Definition at line 21 of file RPCMonitorDigi.h.

Constructor & Destructor Documentation

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

Definition at line 18 of file RPCMonitorDigi.cc.

References edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), globalFolder_, muEtaCut_, muonFolder_, muonLabel_, muPtCut_, noiseFolder_, rpcRecHitLabel_, scalersRawToDigiLabel_, AlCaHLTBitMon_QueryRunRegistry::string, subsystemFolder_, useMuonDigis_, and useRollInfo_.

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 }
T getParameter(std::string const &) const
T getUntrackedParameter(std::string const &, T const &) const
std::string globalFolder_
std::string muonFolder_
std::string noiseFolder_
edm::EDGetTokenT< RPCRecHitCollection > rpcRecHitLabel_
edm::EDGetTokenT< DcsStatusCollection > scalersRawToDigiLabel_
std::string subsystemFolder_
edm::EDGetTokenT< reco::CandidateView > muonLabel_
RPCMonitorDigi::~RPCMonitorDigi ( )
overridedefault

Member Function Documentation

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

Definition at line 110 of file RPCMonitorDigi.cc.

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().

110  {
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 }
double eta() const final
momentum pseudorapidity
std::string muonFolder_
size_type size() const
double pt() const final
transverse momentum
MonitorElement * muonRPCEvents_
std::string noiseFolder_
void Fill(long long x)
RPCDetId rpcId() const
Return the rpcId.
Definition: RPCRecHit.h:71
bool isGlobalMuon() const override
Definition: Muon.h:298
virtual TrackingRecHit * clone() const =0
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_
static constexpr int RPC
Definition: MuonSubdetId.h:13
edm::EDGetTokenT< RPCRecHitCollection > rpcRecHitLabel_
void performSourceOperation(std::map< RPCDetId, std::vector< RPCRecHit > > &, std::string)
MonitorElement * noiseRPCEvents_
MonitorElement * NumberOfMuon_
edm::EDGetTokenT< reco::CandidateView > muonLabel_
trackingRecHit_iterator recHitsEnd() const
Iterator to last hit on the track.
Definition: Track.h:91
void RPCMonitorDigi::bookHistograms ( DQMStore::IBooker ibooker,
edm::Run const &  r,
edm::EventSetup const &  iSetup 
)
overrideprotectedvirtual

Implements DQMEDAnalyzer.

Definition at line 37 of file RPCMonitorDigi.cc.

References dqm::dqmstoreimpl::DQMStore::IBooker::book1D(), bookRegionME(), bookRollME(), bookSectorRingME(), bookWheelDiskME(), RPCGeomServ::chambername(), RPCGeometry::dets(), edm::EventSetup::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::dqmstoreimpl::DQMStore::IBooker::setCurrentFolder(), RPCDetId::station(), AlCaHLTBitMon_QueryRunRegistry::string, subsystemFolder_, useMuonDigis_, useRollInfo_, wheelDiskMuonCollection, and wheelDiskNoiseCollection.

37  {
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 }
std::map< std::string, std::map< std::string, MonitorElement * > > meMuonCollection
std::string muonFolder_
std::map< std::string, MonitorElement * > wheelDiskNoiseCollection
std::map< std::string, MonitorElement * > sectorRingMuonCollection
MonitorElement * muonRPCEvents_
void bookSectorRingME(DQMStore::IBooker &, const std::string &, std::map< std::string, MonitorElement * > &)
Booking of MonitoringElement at Sector/Ring level.
std::string noiseFolder_
int ring() const
Definition: RPCDetId.h:59
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
MonitorElement * NumberOfRecHitMuon_
std::map< std::string, MonitorElement * > regionMuonCollection
const DetContainer & dets() const override
Returm a vector of all GeomDet (including all GeomDetUnits)
Definition: RPCGeometry.cc:24
std::map< std::string, MonitorElement * > sectorRingNoiseCollection
std::map< std::string, std::map< std::string, MonitorElement * > > meNoiseCollection
std::map< std::string, MonitorElement * > wheelDiskMuonCollection
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
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_
int region() const
Region id: 0 for Barrel, +/-1 For +/- Endcap.
Definition: RPCDetId.h:53
int station() const
Definition: RPCDetId.h:78
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.

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

Referenced by bookHistograms().

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 
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",
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 }
std::string globalFolder_
static const std::array< std::string, 3 > regionNames_
std::string subsystemFolder_
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.

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

Referenced by bookHistograms().

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 
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 }
int stripsInRoll(const RPCDetId &id, const RPCGeometry *rpcGeo) const
int ring() const
Definition: RPCDetId.h:59
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
int layer() const
Definition: RPCDetId.h:85
std::string folderStructure(RPCDetId detId)
std::string subsystemFolder_
int region() const
Region id: 0 for Barrel, +/-1 For +/- Endcap.
Definition: RPCDetId.h:53
int station() const
Definition: RPCDetId.h:78
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.

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

Referenced by bookHistograms().

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);
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);
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 }
void labelYAxisRoll(MonitorElement *myMe, int region, int ring, bool useRollInfo)
Definition: utils.h:265
static void setNoAlphanumeric(MonitorElement *myMe)
Definition: utils.h:18
std::string subsystemFolder_
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.

References dqm::dqmstoreimpl::DQMStore::IBooker::book1D(), dqm::dqmstoreimpl::DQMStore::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::dqmstoreimpl::DQMStore::IBooker::setCurrentFolder(), subsystemFolder_, overlapproblemtsosanalyzer_cfi::title, and makeMuonMisalignmentScenario::wheel.

Referenced by bookHistograms().

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(),
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 }
std::string globalFolder_
void labelXAxisSegment(MonitorElement *myMe)
Definition: utils.h:247
void labelYAxisRoll(MonitorElement *myMe, int region, int ring, bool useRollInfo)
Definition: utils.h:265
char const * label
void labelYAxisRing(MonitorElement *myMe, int numberOfRings, bool useRollInfo)
Definition: utils.h:291
void labelXAxisSector(MonitorElement *myMe)
Definition: utils.h:231
std::string subsystemFolder_
void RPCMonitorDigi::performSourceOperation ( std::map< RPCDetId, std::vector< RPCRecHit > > &  recHitMap,
std::string  recHittype 
)
private

Definition at line 208 of file RPCMonitorDigi.cc.

References funct::abs(), RPCRecHit::BunchX(), l1GtPatternGenerator_cfi::bx, RPCGeomServ::chambername(), RPCRecHit::clusterSize(), rpcdqm::utils::detId2RollNr(), RPCRecHit::firstClusterStrip(), 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().

209  {
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 }
int firstClusterStrip() const
Definition: RPCRecHit.h:75
std::map< std::string, std::map< std::string, MonitorElement * > > meMuonCollection
std::string muonFolder_
std::map< std::string, MonitorElement * > wheelDiskNoiseCollection
std::map< std::string, MonitorElement * > sectorRingMuonCollection
std::string noiseFolder_
int clusterSize() const
Definition: RPCRecHit.h:77
int roll() const
Definition: RPCDetId.h:92
int ring() const
Definition: RPCDetId.h:59
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
static const std::array< std::string, 3 > regionNames_
std::map< std::string, MonitorElement * > regionMuonCollection
int layer() const
Definition: RPCDetId.h:85
int detId2RollNr(const RPCDetId &_id)
Definition: utils.h:31
std::map< std::string, MonitorElement * > sectorRingNoiseCollection
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
std::map< std::string, MonitorElement * > wheelDiskMuonCollection
std::map< std::string, MonitorElement * > regionNoiseCollection
int BunchX() const
Definition: RPCRecHit.h:73
int region() const
Region id: 0 for Barrel, +/-1 For +/- Endcap.
Definition: RPCDetId.h:53
int station() const
Definition: RPCDetId.h:78
int RPCMonitorDigi::stripsInRoll ( const RPCDetId id,
const RPCGeometry rpcGeo 
) const
private

Definition at line 279 of file RPCBookDetUnitME.cc.

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

Referenced by bookRollME().

279  {
280  const RPCRoll* rpcRoll = rpcGeo->roll(id);
281  if (!rpcRoll)
282  return 1;
283 
284  return rpcRoll->nstrips();
285 }
int nstrips() const
Definition: RPCRoll.cc:24
const RPCRoll * roll(RPCDetId id) const
Return a roll given its id.
Definition: RPCGeometry.cc:50

Member Data Documentation

int RPCMonitorDigi::counter
private

Definition at line 51 of file RPCMonitorDigi.h.

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

std::string RPCMonitorDigi::globalFolder_
private

Definition at line 73 of file RPCMonitorDigi.h.

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

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().

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().

float RPCMonitorDigi::muEtaCut_
private

Definition at line 53 of file RPCMonitorDigi.h.

Referenced by analyze(), and RPCMonitorDigi().

std::string RPCMonitorDigi::muonFolder_
private

Definition at line 49 of file RPCMonitorDigi.h.

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

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

Definition at line 76 of file RPCMonitorDigi.h.

Referenced by analyze(), and RPCMonitorDigi().

MonitorElement* RPCMonitorDigi::muonRPCEvents_
private

Definition at line 56 of file RPCMonitorDigi.h.

Referenced by analyze(), and bookHistograms().

float RPCMonitorDigi::muPtCut_
private

Definition at line 53 of file RPCMonitorDigi.h.

Referenced by analyze(), and RPCMonitorDigi().

std::string RPCMonitorDigi::noiseFolder_
private

Definition at line 50 of file RPCMonitorDigi.h.

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

MonitorElement* RPCMonitorDigi::noiseRPCEvents_
private

Definition at line 55 of file RPCMonitorDigi.h.

Referenced by analyze(), and bookHistograms().

int RPCMonitorDigi::numberOfDisks_
private
int RPCMonitorDigi::numberOfInnerRings_
private

Definition at line 61 of file RPCMonitorDigi.h.

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

MonitorElement* RPCMonitorDigi::NumberOfMuon_
private

Definition at line 59 of file RPCMonitorDigi.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* RPCMonitorDigi::NumberOfRecHitMuon_
private

Definition at line 58 of file RPCMonitorDigi.h.

Referenced by analyze(), and bookHistograms().

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

Definition at line 65 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and performSourceOperation().

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().

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

Definition at line 70 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and performSourceOperation().

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

Definition at line 77 of file RPCMonitorDigi.h.

Referenced by analyze(), and RPCMonitorDigi().

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

Definition at line 78 of file RPCMonitorDigi.h.

Referenced by RPCMonitorDigi().

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

Definition at line 66 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and performSourceOperation().

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

Definition at line 71 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and performSourceOperation().

std::string RPCMonitorDigi::subsystemFolder_
private
bool RPCMonitorDigi::useMuonDigis_
private

Definition at line 43 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and RPCMonitorDigi().

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

Definition at line 64 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and performSourceOperation().

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

Definition at line 69 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and performSourceOperation().