#include <RPCMonitorDigi.h>

Inheritance diagram for RPCMonitorDigi:

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

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

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::ESGetToken< RPCGeometry, MuonGeometryRecord >	rpcGeomToken_

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 >
using	CacheTypes = CacheContexts< T...>

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T...>

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::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 20 of file RPCMonitorDigi.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 17 of file RPCMonitorDigi.cc.

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

     : counter(0),
       muonRPCEvents_(nullptr),
       NumberOfRecHitMuon_(nullptr),
       NumberOfMuon_(nullptr),
       numberOfDisks_(0),
       numberOfInnerRings_(0) {
   useMuonDigis_ = pset.getUntrackedParameter<bool>("UseMuon", true);
   useRollInfo_ = pset.getUntrackedParameter<bool>("UseRollInfo", false);
 
   muPtCut_ = pset.getUntrackedParameter<double>("MuonPtCut", 3.0);
   muEtaCut_ = pset.getUntrackedParameter<double>("MuonEtaCut", 1.9);
 
   subsystemFolder_ = pset.getUntrackedParameter<std::string>("RPCFolder", "RPC");
   globalFolder_ = pset.getUntrackedParameter<std::string>("GlobalFolder", "SummaryHistograms");
 
   //Parametersets for tokens
   muonLabel_ = consumes<reco::CandidateView>(pset.getParameter<edm::InputTag>("MuonLabel"));
   rpcRecHitLabel_ = consumes<RPCRecHitCollection>(pset.getParameter<edm::InputTag>("RecHitLabel"));
   scalersRawToDigiLabel_ = consumes<DcsStatusCollection>(pset.getParameter<edm::InputTag>("ScalersRawToDigiLabel"));
 
   noiseFolder_ = pset.getUntrackedParameter<std::string>("NoiseFolder", "AllHits");
   muonFolder_ = pset.getUntrackedParameter<std::string>("MuonFolder", "Muon");
 
   rpcGeomToken_ = esConsumes<edm::Transition::BeginRun>();
 }

RPCMonitorDigi::~RPCMonitorDigi ( )

overridedefault

Member Function Documentation

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

overrideprotectedvirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 113 of file RPCMonitorDigi.cc.

References TrackingRecHit::clone(), counter, reco::LeafCandidate::eta(), dqm::impl::MonitorElement::Fill(), mps_fire::i, 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(), and rpcRecHitLabel_.

                                                                               {
   counter++;
   edm::LogInfo("rpcmonitordigi") << "[RPCMonitorDigi]: Beginning analyzing event " << counter;
 
   //Muons
   edm::Handle<reco::CandidateView> muonCands;
   event.getByToken(muonLabel_, muonCands);
 
   std::map<RPCDetId, std::vector<RPCRecHit> > rechitMuon;
 
   int numMuons = 0;
   int numRPCRecHit = 0;
 
   if (muonCands.isValid()) {
     int nStaMuons = muonCands->size();
 
     for (int i = 0; i < nStaMuons; i++) {
       const reco::Candidate& goodMuon = (*muonCands)[i];
       const reco::Muon* muCand = dynamic_cast<const reco::Muon*>(&goodMuon);
 
       if (!muCand->isGlobalMuon())
         continue;
       if (muCand->pt() < muPtCut_ || fabs(muCand->eta()) > muEtaCut_)
         continue;
       numMuons++;
       reco::Track muTrack = (*(muCand->outerTrack()));
       std::vector<TrackingRecHitRef> rpcTrackRecHits;
       //loop on mu rechits
       for (trackingRecHit_iterator it = muTrack.recHitsBegin(); it != muTrack.recHitsEnd(); it++) {
         if (!(*it)->isValid())
           continue;
         int muSubDetId = (*it)->geographicalId().subdetId();
         if (muSubDetId == MuonSubdetId::RPC) {
           numRPCRecHit++;
           TrackingRecHit* tkRecHit = (*it)->clone();
           RPCRecHit* rpcRecHit = dynamic_cast<RPCRecHit*>(tkRecHit);
           int detId = (int)rpcRecHit->rpcId();
           if (rechitMuon.find(detId) == rechitMuon.end() || rechitMuon[detId].empty()) {
             std::vector<RPCRecHit> myVect(1, *rpcRecHit);
             rechitMuon[detId] = myVect;
           } else {
             rechitMuon[detId].push_back(*rpcRecHit);
           }
         }
       }  // end loop on mu rechits
     }
 
     //Fill muon counter
     if (NumberOfMuon_) {
       NumberOfMuon_->Fill(numMuons);
     }
 
     //Fill rechit counter for muons
     if (NumberOfRecHitMuon_ && numMuons > 0) {
       NumberOfRecHitMuon_->Fill(numRPCRecHit);
     }
 
     //Fill counter of RPC events with rechits associated in with a muon
     if (muonRPCEvents_ != nullptr && numRPCRecHit > 0) {
       muonRPCEvents_->Fill(1);
     }
 
     //Perform client operation
     this->performSourceOperation(rechitMuon, muonFolder_);
 
   } else {
     edm::LogError("rpcmonitordigi") << "[RPCMonitorDigi]: Muons - Product not valid for event" << counter;
   }
 
   //RecHits
   edm::Handle<RPCRecHitCollection> rpcHits;
   event.getByToken(rpcRecHitLabel_, rpcHits);
   std::map<RPCDetId, std::vector<RPCRecHit> > rechitNoise;
 
   if (rpcHits.isValid()) {
     //    RPC rec hits NOT associated to a muon
     for (auto rpcRecHitIter = rpcHits->begin(); rpcRecHitIter != rpcHits->end(); rpcRecHitIter++) {
       RPCRecHit rpcRecHit = (*rpcRecHitIter);
       int detId = (int)rpcRecHit.rpcId();
       if (rechitNoise.find(detId) == rechitNoise.end() || rechitNoise[detId].empty()) {
         std::vector<RPCRecHit> myVect(1, rpcRecHit);
         rechitNoise[detId] = myVect;
       } else {
         rechitNoise[detId].push_back(rpcRecHit);
       }
     }
   } else {
     edm::LogError("rpcmonitordigi") << "[RPCMonitorDigi]: RPCRecHits - Product not valid for event" << counter;
   }
 
   //Fill counter for all RPC events
   if (noiseRPCEvents_ != nullptr && !rechitNoise.empty()) {
     noiseRPCEvents_->Fill(1);
   }
   //Perform client operation
   this->performSourceOperation(rechitNoise, noiseFolder_);
 }

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

overrideprotectedvirtual

Implements DQMEDAnalyzer.

Definition at line 44 of file RPCMonitorDigi.cc.

References dqm::implementation::IBooker::book1D(), bookRegionME(), bookRollME(), bookSectorRingME(), bookWheelDiskME(), RPCNameHelper::chamberName(), edm::EventSetup::getData(), meMuonCollection, meNoiseCollection, min(), muonFolder_, muonRPCEvents_, noiseFolder_, noiseRPCEvents_, numberOfDisks_, numberOfInnerRings_, NumberOfMuon_, NumberOfRecHitMuon_, RPCDetId::region(), regionMuonCollection, regionNoiseCollection, RPCDetId::ring(), RPCNameHelper::rollName(), RPCChamber::rolls(), rpcGeomToken_, sectorRingMuonCollection, sectorRingNoiseCollection, dqm::implementation::NavigatorBase::setCurrentFolder(), RPCDetId::station(), AlCaHLTBitMon_QueryRunRegistry::string, subsystemFolder_, useMuonDigis_, useRollInfo_, wheelDiskMuonCollection, and wheelDiskNoiseCollection.

                                                                                                           {
   edm::LogInfo("rpcmonitordigi") << "[RPCMonitorDigi]: Begin Run ";
 
   numberOfInnerRings_ = 4;  // set default value
 
   std::set<int> disk_set;
   const auto& rpcGeo = iSetup.getData(rpcGeomToken_);
 
   //loop on geometry to book all MEs
   edm::LogInfo("rpcmonitordigi") << "[RPCMonitorDigi]: Booking histograms per roll. ";
   for (auto ich : rpcGeo.dets()) {
     const RPCChamber* ch = dynamic_cast<const RPCChamber*>(ich);
     if (!ch)
       continue;
     const auto& roles = ch->rolls();
 
     if (useRollInfo_) {
       for (auto roll : roles) {
         const RPCDetId& rpcId = roll->id();
 
         //get station and inner ring
         if (rpcId.region() != 0) {
           disk_set.insert(rpcId.station());
           numberOfInnerRings_ = std::min(numberOfInnerRings_, rpcId.ring());
         }
 
         //booking all histograms
         const std::string nameID = RPCNameHelper::rollName(rpcId);
         if (useMuonDigis_)
           bookRollME(ibooker, rpcId, &rpcGeo, muonFolder_, meMuonCollection[nameID]);
         bookRollME(ibooker, rpcId, &rpcGeo, noiseFolder_, meNoiseCollection[nameID]);
       }
     } else {
       const RPCDetId& rpcId = roles[0]->id();  //any roll would do - here I just take the first one
       const std::string nameID = RPCNameHelper::chamberName(rpcId);
       if (useMuonDigis_)
         bookRollME(ibooker, rpcId, &rpcGeo, muonFolder_, meMuonCollection[nameID]);
       bookRollME(ibooker, rpcId, &rpcGeo, noiseFolder_, meNoiseCollection[nameID]);
       if (rpcId.region() != 0) {
         disk_set.insert(rpcId.station());
         numberOfInnerRings_ = std::min(numberOfInnerRings_, rpcId.ring());
       }
     }
   }  //end loop on geometry to book all MEs
 
   numberOfDisks_ = disk_set.size();
 
   //Book
   this->bookRegionME(ibooker, noiseFolder_, regionNoiseCollection);
   this->bookSectorRingME(ibooker, noiseFolder_, sectorRingNoiseCollection);
   this->bookWheelDiskME(ibooker, noiseFolder_, wheelDiskNoiseCollection);
 
   ibooker.setCurrentFolder(subsystemFolder_ + "/" + noiseFolder_);
 
   noiseRPCEvents_ = ibooker.book1D("RPCEvents", "RPCEvents", 1, 0.5, 1.5);
 
   if (useMuonDigis_) {
     this->bookRegionME(ibooker, muonFolder_, regionMuonCollection);
     this->bookSectorRingME(ibooker, muonFolder_, sectorRingMuonCollection);
     this->bookWheelDiskME(ibooker, muonFolder_, wheelDiskMuonCollection);
 
     ibooker.setCurrentFolder(subsystemFolder_ + "/" + muonFolder_);
 
     muonRPCEvents_ = ibooker.book1D("RPCEvents", "RPCEvents", 1, 0.5, 1.5);
     NumberOfMuon_ = ibooker.book1D("NumberOfMuons", "Number of Muons", 11, -0.5, 10.5);
     NumberOfRecHitMuon_ = ibooker.book1D("NumberOfRecHitMuons", "Number of RPC RecHits per Muon", 8, -0.5, 7.5);
   }
 }

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 213 of file RPCBookDetUnitME.cc.

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

Referenced by bookHistograms().

                                                                              {
   std::string currentFolder = subsystemFolder_ + "/" + recHitType + "/" + globalFolder_;
   ibooker.setCurrentFolder(currentFolder);
 
   std::stringstream name;
   std::stringstream title;
   for (int r = 0; r < 3; r++) {  //RPC regions are E-, B, and E+
 
     std::string regionName = RPCMonitorDigi::regionNames_[r];
     //Cluster size
     name.str("");
     title.str("");
     name << "ClusterSize_" << regionName;
     title << "ClusterSize - " << regionName;
     meMap[name.str()] = ibooker.book1D(name.str(), title.str(), 16, 0.5, 16.5);
   }
 
   //Number of Cluster
   name.str("");
   title.str("");
   name << "NumberOfClusters_Barrel";
   title << "Number of Clusters per Event - Barrel";
   meMap[name.str()] = ibooker.book1D(name.str(), title.str(), 30, 0.5, 30.5);
 
   name.str("");
   title.str("");
   name << "NumberOfClusters_Endcap+";
   title << "Number of Clusters per Event - Endcap+";
   meMap[name.str()] = ibooker.book1D(name.str(), title.str(), 15, 0.5, 15.5);
 
   name.str("");
   title.str("");
   name << "NumberOfClusters_Endcap-";
   title << "Number of Clusters per Event - Endcap-";
   meMap[name.str()] = ibooker.book1D(name.str(), title.str(), 15, 0.5, 15.5);
 
   //Number of Digis
   name.str("");
   title.str("");
   name << "Multiplicity_Barrel";
   title << "Multiplicity per Event per Roll - Barrel";
   meMap[name.str()] = ibooker.book1D(name.str(), title.str(), 50, 0.5, 50.5);
 
   name.str("");
   title.str("");
   name << "Multiplicity_Endcap+";
   title << "Multiplicity per Event per Roll - Endcap+";
   meMap[name.str()] = ibooker.book1D(name.str(), title.str(), 32, 0.5, 32.5);
 
   name.str("");
   title.str("");
   name << "Multiplicity_Endcap-";
   title << "Multiplicity per Event per Roll - Endcap-";
   meMap[name.str()] = ibooker.book1D(name.str(), title.str(), 32, 0.5, 32.5);
 
   for (int layer = 1; layer <= 6; layer++) {
     name.str("");
     title.str("");
     name << "ClusterSize_Layer" << layer;
     title << "ClusterSize - Layer" << layer;
     meMap[name.str()] = ibooker.book1D(name.str(), title.str(), 16, 0.5, 16.5);
   }
 
   for (int ring = RPCMonitorDigi::numberOfInnerRings_; ring <= 3; ring++) {
     name.str("");
     title.str("");
     name << "ClusterSize_Ring" << ring;
     title << "ClusterSize - Ring" << ring;
     meMap[name.str()] = ibooker.book1D(name.str(), title.str(), 16, 0.5, 16.5);
   }
 
   meMap["Occupancy_for_Endcap"] = ibooker.book2D("Occupancy_for_Endcap",
                                                  "Occupancy Endcap",
                                                  (int)RPCMonitorDigi::numberOfDisks_ * 2.0,
                                                  0.5,
                                                  ((float)RPCMonitorDigi::numberOfDisks_ * 2.0) + 0.5,
                                                  2,
                                                  1.5,
                                                  3.5);
   meMap["Occupancy_for_Endcap"]->setAxisTitle("Disk", 1);
   meMap["Occupancy_for_Endcap"]->setAxisTitle("Ring", 2);
 
   std::stringstream binlabel;
   for (int bin = 1; bin <= RPCMonitorDigi::numberOfDisks_ * 2; bin++) {
     binlabel.str("");
     if (bin < (RPCMonitorDigi::numberOfDisks_ + 1)) {  //negative endcap
       binlabel << (bin - (RPCMonitorDigi::numberOfDisks_ + 1));
     } else {  //positive endcaps
       binlabel << (bin - RPCMonitorDigi::numberOfDisks_);
     }
     meMap["Occupancy_for_Endcap"]->setBinLabel(bin, binlabel.str(), 1);
   }
 
   meMap["Occupancy_for_Endcap"]->setBinLabel(1, "2", 2);
   meMap["Occupancy_for_Endcap"]->setBinLabel(2, "3", 2);
 
   meMap["Occupancy_for_Barrel"] =
       ibooker.book2D("Occupancy_for_Barrel", "Occupancy Barrel", 12, 0.5, 12.5, 5, -2.5, 2.5);
   meMap["Occupancy_for_Barrel"]->setAxisTitle("Sec", 1);
   meMap["Occupancy_for_Barrel"]->setAxisTitle("Wheel", 2);
 
   for (int bin = 1; bin <= 12; bin++) {
     binlabel.str("");
     binlabel << bin;
     meMap["Occupancy_for_Barrel"]->setBinLabel(bin, binlabel.str(), 1);
     if (bin <= 5) {
       binlabel.str("");
       binlabel << (bin - 3);
       meMap["Occupancy_for_Barrel"]->setBinLabel(bin, binlabel.str(), 2);
     }
   }
 }

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 7 of file RPCBookDetUnitME.cc.

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

Referenced by bookHistograms().

                                                                            {
   ibooker.setCurrentFolder(
       fmt::format("{}/{}/{}", subsystemFolder_, recHitType, RPCBookFolderStructure::folderStructure(detId)));
 
   //get number of strips in current roll
   int nstrips = this->stripsInRoll(detId, rpcGeo);
   if (nstrips == 0) {
     nstrips = 1;
   }
 
   const std::string nameRoll = RPCNameHelper::name(detId, useRollInfo_);
 
   if (!RPCMonitorDigi::useRollInfo_) {
     if (detId.region() != 0 ||                                                     //Endcaps
         (abs(detId.ring()) == 2 && detId.station() == 2 && detId.layer() != 1) ||  //Wheel -/+2 RB2out
         (abs(detId.ring()) != 2 && detId.station() == 2 && detId.layer() == 1)) {
       nstrips *= 3;
     }  //Wheel -1,0,+1 RB2in
     else {
       nstrips *= 2;
     }
   }
 
   std::string tmpStr;
 
   tmpStr = "Occupancy_" + nameRoll;
   meMap[tmpStr] = ibooker.book1D(tmpStr, tmpStr, nstrips, 0.5, nstrips + 0.5);
 
   tmpStr = "BXDistribution_" + nameRoll;
   meMap[tmpStr] = ibooker.book1D(tmpStr, tmpStr, 7, -3.5, 3.5);
 
   if (detId.region() == 0) {
     tmpStr = "ClusterSize_" + nameRoll;
     meMap[tmpStr] = ibooker.book1D(tmpStr, tmpStr, 15, 0.5, 15.5);
 
     tmpStr = "Multiplicity_" + nameRoll;
     meMap[tmpStr] = ibooker.book1D(tmpStr, tmpStr, 30, 0.5, 30.5);
 
   } else {
     tmpStr = "ClusterSize_" + nameRoll;
     meMap[tmpStr] = ibooker.book1D(tmpStr, tmpStr, 10, 0.5, 10.5);
 
     tmpStr = "Multiplicity_" + nameRoll;
     meMap[tmpStr] = ibooker.book1D(tmpStr, tmpStr, 15, 0.5, 15.5);
   }
 
   tmpStr = "NumberOfClusters_" + nameRoll;
   meMap[tmpStr] = ibooker.book1D(tmpStr, tmpStr, 10, 0.5, 10.5);
 }

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 62 of file RPCBookDetUnitME.cc.

References dqm::implementation::IBooker::book2D(), diffTreeTool::format(), mps_fire::i, hlt_dqm_clientPB-live_cfg::me1, hlt_dqm_clientPB-live_cfg::me2, numberOfDisks_, numberOfInnerRings_, HLT_FULL_cff::region, relativeConstraints::ring, dqm::impl::MonitorElement::setAxisTitle(), RPCRollMapHisto::setBarrelRollAxis(), dqm::implementation::NavigatorBase::setCurrentFolder(), AlCaHLTBitMon_QueryRunRegistry::string, and subsystemFolder_.

Referenced by bookHistograms().

                                                                                  {
   for (int wheel = -2; wheel <= 2; wheel++) {
     ibooker.setCurrentFolder(
         fmt::format("{}/{}/Barrel/Wheel_{}/SummaryBySectors", subsystemFolder_, recHitType, wheel));
 
     for (int sector = 1; sector <= 12; sector++) {
       const std::string meName = fmt::format("Occupancy_Wheel_{}_Sector_{}", wheel, sector);
 
       if (sector == 9 || sector == 11)
         meMap[meName] = ibooker.book2D(meName, meName, 91, 0.5, 91.5, 15, 0.5, 15.5);
       else if (sector == 4)
         meMap[meName] = ibooker.book2D(meName, meName, 91, 0.5, 91.5, 21, 0.5, 21.5);
       else
         meMap[meName] = ibooker.book2D(meName, meName, 91, 0.5, 91.5, 17, 0.5, 17.5);
 
       meMap[meName]->setAxisTitle("strip", 1);
       RPCRollMapHisto::setBarrelRollAxis(meMap[meName], wheel, 2, true);
     }
   }
 
   for (int region = -1; region <= 1; region++) {
     if (region == 0)
       continue;
 
     std::string regionName = "Endcap-";
     if (region == 1)
       regionName = "Endcap+";
 
     for (int disk = 1; disk <= RPCMonitorDigi::numberOfDisks_; disk++) {
       ibooker.setCurrentFolder(
           fmt::format("{}/{}/{}/Disk_{}/SummaryByRings/", subsystemFolder_, recHitType, regionName, region * disk));
 
       for (int ring = RPCMonitorDigi::numberOfInnerRings_; ring <= 3; ring++) {
         const std::string meName1 = fmt::format("Occupancy_Disk_{}_Ring_{}_CH01-CH18", (region * disk), ring);
 
         auto me1 = ibooker.book2D(meName1, meName1, 96, 0.5, 96.5, 18, 0.5, 18.5);
         me1->setAxisTitle("strip", 1);
 
         for (int i = 1; i <= 18; i++) {
           const std::string ylabel = fmt::format("R{}_CH{:02d}", ring, i);
           me1->setBinLabel(i, ylabel, 2);
         }
 
         me1->setBinLabel(1, "1", 1);
         me1->setBinLabel(16, "RollA", 1);
         me1->setBinLabel(32, "32", 1);
         me1->setBinLabel(33, "1", 1);
         me1->setBinLabel(48, "RollB", 1);
         me1->setBinLabel(64, "32", 1);
         me1->setBinLabel(65, "1", 1);
         me1->setBinLabel(80, "RollC", 1);
         me1->setBinLabel(96, "32", 1);
 
         const std::string meName2 = fmt::format("Occupancy_Disk_{}_Ring_{}_CH19-CH36", (region * disk), ring);
 
         auto me2 = ibooker.book2D(meName2, meName2, 96, 0.5, 96.5, 18, 18.5, 36.5);
         me2->setAxisTitle("strip", 1);
 
         for (int i = 1; i <= 18; i++) {
           const std::string ylabel = fmt::format("R{}_CH{:02d}", ring, i + 18);
           me2->setBinLabel(i, ylabel, 2);
         }
 
         me2->setBinLabel(1, "1", 1);
         me2->setBinLabel(16, "RollA", 1);
         me2->setBinLabel(32, "32", 1);
         me2->setBinLabel(33, "1", 1);
         me2->setBinLabel(48, "RollB", 1);
         me2->setBinLabel(64, "32", 1);
         me2->setBinLabel(65, "1", 1);
         me2->setBinLabel(80, "RollC", 1);
         me2->setBinLabel(96, "32", 1);
 
         meMap[meName1] = me1;
         meMap[meName2] = me2;
       }  //loop ring
     }    //loop disk
   }      //loop region
 }

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 144 of file RPCBookDetUnitME.cc.

References dqm::implementation::IBooker::book1D(), RPCRollMapHisto::bookBarrel(), RPCRollMapHisto::bookEndcap(), diffTreeTool::format(), globalFolder_, mps_fire::i, label, phase1PixelTopology::layer, mergeVDriftHistosByStation::name, numberOfDisks_, numberOfInnerRings_, relativeConstraints::ring, dqm::impl::MonitorElement::setBinLabel(), dqm::implementation::NavigatorBase::setCurrentFolder(), AlCaHLTBitMon_QueryRunRegistry::string, subsystemFolder_, and runGCPTkAlMap::title.

Referenced by bookHistograms().

                                                                                 {
   ibooker.setCurrentFolder(subsystemFolder_ + "/" + recHitType + "/" + globalFolder_);
 
   std::string tmpStr;
 
   for (int wheel = -2; wheel <= 2; wheel++) {  //Loop on wheel
     tmpStr = fmt::format("1DOccupancy_Wheel_{}", wheel);
     meMap[tmpStr] = ibooker.book1D(tmpStr, tmpStr, 12, 0.5, 12.5);
     for (int i = 1; i <= 12; ++i) {
       meMap[tmpStr]->setBinLabel(i, fmt::format("Sec{}", i), 1);
     }
 
     tmpStr = fmt::format("Occupancy_Roll_vs_Sector_Wheel_{}", wheel);
     meMap[tmpStr] = RPCRollMapHisto::bookBarrel(ibooker, wheel, tmpStr, tmpStr, true);
 
     tmpStr = fmt::format("BxDistribution_Wheel_{}", wheel);
     meMap[tmpStr] = ibooker.book1D(tmpStr, tmpStr, 9, -4.5, 4.5);
 
     for (int layer = 1; layer <= 6; layer++) {
       const std::string name = fmt::format("ClusterSize_Wheel_{}_Layer{}", wheel, layer);
       const std::string title = fmt::format("ClusterSize - Wheel {} Layer{}", wheel, layer);
       meMap[name] = ibooker.book1D(name, title, 16, 0.5, 16.5);
     }
 
   }  //end loop on wheel
 
   for (int disk = -RPCMonitorDigi::numberOfDisks_; disk <= RPCMonitorDigi::numberOfDisks_; disk++) {
     if (disk == 0)
       continue;
 
     tmpStr = fmt::format("Occupancy_Ring_vs_Segment_Disk_{}", disk);
     meMap[tmpStr] = RPCRollMapHisto::bookEndcap(ibooker, disk, tmpStr, tmpStr, true);
 
     tmpStr = fmt::format("BxDistribution_Disk_{}", disk);
     meMap[tmpStr] = ibooker.book1D(tmpStr, tmpStr, 9, -4.5, 4.5);
 
     for (int ring = RPCMonitorDigi::numberOfInnerRings_; ring <= 3; ring++) {
       const std::string name = fmt::format("ClusterSize_Disk_{}_Ring{}", disk, ring);
       const std::string title = fmt::format("ClusterSize - Disk{} Ring{}", disk, ring);
       meMap[name] = ibooker.book1D(name, title, 16, 0.5, 16.5);
     }
   }
 
   for (int ring = RPCMonitorDigi::numberOfInnerRings_; ring <= 3; ring++) {
     const std::string meName = fmt::format("1DOccupancy_Ring_{}", ring);
     meMap[meName] = ibooker.book1D(
         meName, meName, RPCMonitorDigi::numberOfDisks_ * 2, 0.5, (RPCMonitorDigi::numberOfDisks_ * 2.0) + 0.5);
     for (int xbin = 1; xbin <= RPCMonitorDigi::numberOfDisks_ * 2; xbin++) {
       std::string label;
       if (xbin < RPCMonitorDigi::numberOfDisks_ + 1)
         label = fmt::format("Disk {}", (xbin - (RPCMonitorDigi::numberOfDisks_ + 1)));
       else
         label = fmt::format("Disk {}", (xbin - RPCMonitorDigi::numberOfDisks_));
       meMap[meName]->setBinLabel(xbin, label, 1);
     }
   }
 }

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

private

Definition at line 211 of file RPCMonitorDigi.cc.

References funct::abs(), RPCRecHit::BunchX(), makePileupJSON::bx, RPCRecHit::clusterSize(), rpcdqm::utils::detId2RollNr(), RPCRecHit::firstClusterStrip(), diffTreeTool::format(), mps_fire::i, RPCDetId::layer(), phase1PixelTopology::layer, meMuonCollection, meNoiseCollection, muonFolder_, RPCNameHelper::name(), noiseFolder_, numberOfDisks_, HLT_FULL_cff::recHits, RPCDetId::region(), HLT_FULL_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().

                                                                   {
   edm::LogInfo("rpcmonitordigi") << "[RPCMonitorDigi]: Performing DQM source operations for ";
 
   if (recHitMap.empty())
     return;
 
   std::map<std::string, std::map<std::string, MonitorElement*> > meRollCollection;
   std::map<std::string, MonitorElement*> meWheelDisk;
   std::map<std::string, MonitorElement*> meRegion;
   std::map<std::string, MonitorElement*> meSectorRing;
 
   if (recHittype == muonFolder_) {
     meRollCollection = meMuonCollection;
     meWheelDisk = wheelDiskMuonCollection;
     meRegion = regionMuonCollection;
     meSectorRing = sectorRingMuonCollection;
   } else if (recHittype == noiseFolder_) {
     meRollCollection = meNoiseCollection;
     meWheelDisk = wheelDiskNoiseCollection;
     meRegion = regionNoiseCollection;
     meSectorRing = sectorRingNoiseCollection;
   } else {
     edm::LogWarning("rpcmonitordigi") << "[RPCMonitorDigi]: RecHit type not valid.";
     return;
   }
 
   int totalNumberOfRecHits[3] = {0, 0, 0};
 
   //Loop on Rolls
   for (std::map<RPCDetId, std::vector<RPCRecHit> >::const_iterator detIdIter = recHitMap.begin();
        detIdIter != recHitMap.end();
        detIdIter++) {
     RPCDetId detId = (*detIdIter).first;
     RPCGeomServ geoServ(detId);
 
     //get roll number
     rpcdqm::utils rpcUtils;
     int nr = rpcUtils.detId2RollNr(detId);
 
     const std::string nameRoll = RPCNameHelper::name(detId, useRollInfo_);
 
     int region = (int)detId.region();
     int wheelOrDiskNumber;
     std::string wheelOrDiskType;
     int ring = 0;
     int sector = detId.sector();
     int layer = 0;
     int totalRolls = 3;
     int roll = detId.roll();
     if (region == 0) {
       wheelOrDiskType = "Wheel";
       wheelOrDiskNumber = (int)detId.ring();
       int station = detId.station();
 
       if (station == 1) {
         if (detId.layer() == 1) {
           layer = 1;  //RB1in
           totalRolls = 2;
         } else {
           layer = 2;  //RB1out
           totalRolls = 2;
         }
         if (roll == 3)
           roll = 2;  // roll=3 is Forward
       } else if (station == 2) {
         if (detId.layer() == 1) {
           layer = 3;  //RB2in
           if (abs(wheelOrDiskNumber) == 2 && roll == 3) {
             roll = 2;  //W -2, +2 RB2in has only 2 rolls
             totalRolls = 2;
           }
         } else {
           layer = 4;  //RB2out
           if (abs(wheelOrDiskNumber) != 2 && roll == 3) {
             roll = 2;  //W -1, 0, +1 RB2out has only 2 rolls
             totalRolls = 2;
           }
         }
       } else if (station == 3) {
         layer = 5;  //RB3
         totalRolls = 2;
         if (roll == 3)
           roll = 2;
       } else {
         layer = 6;  //RB4
         totalRolls = 2;
         if (roll == 3)
           roll = 2;
       }
 
     } else {
       wheelOrDiskType = "Disk";
       wheelOrDiskNumber = region * (int)detId.station();
       ring = detId.ring();
     }
 
     std::vector<RPCRecHit> recHits = (*detIdIter).second;
     const int numberOfRecHits = recHits.size();
     totalNumberOfRecHits[region + 1] += numberOfRecHits;
 
     std::set<int> bxSet;
     int numDigi = 0;
 
     std::map<std::string, MonitorElement*> meMap = meRollCollection[nameRoll];
 
     //Loop on recHits
     std::string tmpName;
     for (std::vector<RPCRecHit>::const_iterator recHitIter = recHits.begin(); recHitIter != recHits.end();
          recHitIter++) {
       RPCRecHit recHit = (*recHitIter);
 
       int bx = recHit.BunchX();
       bxSet.insert(bx);
       int clusterSize = (int)recHit.clusterSize();
       numDigi += clusterSize;
       int firstStrip = recHit.firstClusterStrip();
       int lastStrip = clusterSize + firstStrip - 1;
 
       // ###################### Roll Level  #################################
 
       tmpName = "Occupancy_" + nameRoll;
       if (meMap[tmpName]) {
         for (int s = firstStrip; s <= lastStrip; s++) {
           if (useRollInfo_) {
             meMap[tmpName]->Fill(s);
           } else {
             const int nstrips = meMap[tmpName]->getNbinsX() / totalRolls;
             meMap[tmpName]->Fill(s + nstrips * (roll - 1));
           }
         }
       }
 
       tmpName = "BXDistribution_" + nameRoll;
       if (meMap[tmpName])
         meMap[tmpName]->Fill(bx);
 
       tmpName = "ClusterSize_" + nameRoll;
       if (meMap[tmpName])
         meMap[tmpName]->Fill(clusterSize);
 
       // ###################### Sector- Ring Level #################################
 
       tmpName = fmt::format("Occupancy_{}_{}_Sector_{}", wheelOrDiskType, wheelOrDiskNumber, sector);
       if (meSectorRing[tmpName]) {
         for (int s = firstStrip; s <= lastStrip; s++) {  //Loop on digis
           meSectorRing[tmpName]->Fill(s, nr);
         }
       }
 
       tmpName = fmt::format("Occupancy_{}_{}_Ring_{}", wheelOrDiskType, wheelOrDiskNumber, ring);
       if (geoServ.segment() > 0 && geoServ.segment() <= 18) {
         tmpName += "_CH01-CH18";
       } else if (geoServ.segment() >= 19) {
         tmpName += "_CH19-CH36";
       }
 
       if (meSectorRing[tmpName]) {
         for (int s = firstStrip; s <= lastStrip; s++) {  //Loop on digis
           meSectorRing[tmpName]->Fill(s + 32 * (detId.roll() - 1), geoServ.segment());
         }
       }
 
       // ###################### Wheel/Disk Level #########################
       if (region == 0) {
         tmpName = fmt::format("1DOccupancy_Wheel_{}", wheelOrDiskNumber);
         if (meWheelDisk[tmpName])
           meWheelDisk[tmpName]->Fill(sector, clusterSize);
 
         tmpName = fmt::format("Occupancy_Roll_vs_Sector_{}_{}", wheelOrDiskType, wheelOrDiskNumber);
         if (meWheelDisk[tmpName])
           meWheelDisk[tmpName]->Fill(sector, nr, clusterSize);
 
       } else {
         tmpName = fmt::format("1DOccupancy_Ring_{}", ring);
         if ((meWheelDisk[tmpName])) {
           if (wheelOrDiskNumber > 0) {
             meWheelDisk[tmpName]->Fill(wheelOrDiskNumber + numberOfDisks_, clusterSize);
           } else {
             meWheelDisk[tmpName]->Fill(wheelOrDiskNumber + numberOfDisks_ + 1, clusterSize);
           }
         }
 
         tmpName = fmt::format("Occupancy_Ring_vs_Segment_{}_{}", wheelOrDiskType, wheelOrDiskNumber);
         if (meWheelDisk[tmpName])
           meWheelDisk[tmpName]->Fill(geoServ.segment(), (ring - 1) * 3 - detId.roll() + 1, clusterSize);
       }
 
       tmpName = fmt::format("BxDistribution_{}_{}", wheelOrDiskType, wheelOrDiskNumber);
       if (meWheelDisk[tmpName])
         meWheelDisk[tmpName]->Fill(bx);
 
       tmpName = fmt::format("ClusterSize_{}_{}_Layer{}", wheelOrDiskType, wheelOrDiskNumber, layer);
       if (meWheelDisk[tmpName])
         meWheelDisk[tmpName]->Fill(clusterSize);
 
       tmpName = fmt::format("ClusterSize_{}_{}_Ring{}", wheelOrDiskType, wheelOrDiskNumber, ring);
       if (meWheelDisk[tmpName])
         meWheelDisk[tmpName]->Fill(clusterSize);
 
       // ######################  Global  ##################################
       tmpName = "ClusterSize_" + RPCMonitorDigi::regionNames_[region + 1];
       if (meRegion[tmpName])
         meRegion[tmpName]->Fill(clusterSize);
 
       tmpName = "";
       if (region == 0) {
         tmpName = fmt::format("ClusterSize_Layer{}", layer);
       } else {
         tmpName = fmt::format("ClusterSize_Ring{}", ring);
       }
       if (meRegion[tmpName])
         meRegion[tmpName]->Fill(clusterSize);
 
     }  //end loop on recHits
 
     tmpName = "BXWithData_" + nameRoll;
     if (meMap[tmpName])
       meMap[tmpName]->Fill(bxSet.size());
 
     tmpName = "NumberOfClusters_" + nameRoll;
     if (meMap[tmpName])
       meMap[tmpName]->Fill(numberOfRecHits);
 
     tmpName = "Multiplicity_" + RPCMonitorDigi::regionNames_[region + 1];
     if (meRegion[tmpName])
       meRegion[tmpName]->Fill(numDigi);
 
     if (region == 0) {
       if (meRegion["Occupancy_for_Barrel"])
         meRegion["Occupancy_for_Barrel"]->Fill(sector, wheelOrDiskNumber, numDigi);
     } else {
       int xbin = wheelOrDiskNumber + numberOfDisks_;
       if (region == -1) {
         xbin = wheelOrDiskNumber + numberOfDisks_ + 1;
       }
       if (meRegion["Occupancy_for_Endcap"]) {
         meRegion["Occupancy_for_Endcap"]->Fill(xbin, ring, numDigi);
       }
     }
 
     tmpName = "Multiplicity_" + nameRoll;
     if (meMap[tmpName])
       meMap[tmpName]->Fill(numDigi);
 
   }  //end loop on rolls
 
   for (int i = 0; i < 3; i++) {
     const std::string tmpName = "NumberOfClusters_" + RPCMonitorDigi::regionNames_[i];
     if (meRegion[tmpName])
       meRegion[tmpName]->Fill(totalNumberOfRecHits[i]);
   }
 }

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

private

Definition at line 205 of file RPCBookDetUnitME.cc.

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

Referenced by bookRollME().

                                                                                     {
   const RPCRoll* rpcRoll = rpcGeo->roll(id);
   if (!rpcRoll)
     return 1;
 
   return rpcRoll->nstrips();
 }