RPCMonitorDigi Class Reference

#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
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final

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

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

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

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

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

Detailed Description

Definition at line 21 of file RPCMonitorDigi.h.

Constructor & Destructor Documentation

RPCMonitorDigi()

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

explicit

Definition at line 18 of file RPCMonitorDigi.cc.

    : 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");
}

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

~RPCMonitorDigi()

RPCMonitorDigi::~RPCMonitorDigi ( )

overridedefault

Member Function Documentation

analyze()

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

overrideprotectedvirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 116 of file RPCMonitorDigi.cc.

                                                                              {
  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_);
}

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

bookHistograms()

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

overrideprotectedvirtual

Implements DQMEDAnalyzer.

Definition at line 43 of file RPCMonitorDigi.cc.

                                                                                                          {
  edm::LogInfo("rpcmonitordigi") << "[RPCMonitorDigi]: Begin Run ";
 
  std::set<int> disk_set, ring_set;
  edm::ESHandle<RPCGeometry> rpcGeoHandle;
  iSetup.get<MuonGeometryRecord>().get(rpcGeoHandle);
  const RPCGeometry* rpcGeo = rpcGeoHandle.product();
 
  //loop on geometry to book all MEs
  edm::LogInfo("rpcmonitordigi") << "[RPCMonitorDigi]: Booking histograms per roll. ";
  for (TrackingGeometry::DetContainer::const_iterator it = rpcGeo->dets().begin(); it < rpcGeo->dets().end(); it++) {
    if (dynamic_cast<const RPCChamber*>(*it) != nullptr) {
      const RPCChamber* ch = dynamic_cast<const RPCChamber*>(*it);
      std::vector<const RPCRoll*> roles = (ch->rolls());
      if (useRollInfo_) {
        for (std::vector<const RPCRoll*>::const_iterator r = roles.begin(); r != roles.end(); ++r) {
          RPCDetId rpcId = (*r)->id();
 
          //get station and inner ring
          if (rpcId.region() != 0) {
            disk_set.insert(rpcId.station());
            ring_set.insert(rpcId.ring());
          }
 
          //booking all histograms
          RPCGeomServ rpcsrv(rpcId);
          std::string nameID = rpcsrv.name();
          if (useMuonDigis_)
            bookRollME(ibooker, rpcId, rpcGeo, muonFolder_, meMuonCollection[nameID]);
          bookRollME(ibooker, rpcId, rpcGeo, noiseFolder_, meNoiseCollection[nameID]);
        }
      } else {
        RPCDetId rpcId = roles[0]->id();  //any roll would do - here I just take the first one
        RPCGeomServ rpcsrv(rpcId);
        std::string nameID = rpcsrv.chambername();
        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());
          ring_set.insert(rpcId.ring());
        }
      }
    }
  }  //end loop on geometry to book all MEs
 
  numberOfDisks_ = disk_set.size();
  numberOfInnerRings_ = (*ring_set.begin());
 
  //Book
  this->bookRegionME(ibooker, noiseFolder_, regionNoiseCollection);
  this->bookSectorRingME(ibooker, noiseFolder_, sectorRingNoiseCollection);
  this->bookWheelDiskME(ibooker, noiseFolder_, wheelDiskNoiseCollection);
 
  std::string currentFolder = subsystemFolder_ + "/" + noiseFolder_;
  ibooker.setCurrentFolder(currentFolder);
 
  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);
 
    currentFolder = subsystemFolder_ + "/" + muonFolder_;
    ibooker.setCurrentFolder(currentFolder);
 
    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);
  }
}

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

bookRegionME()

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

protected

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

Definition at line 287 of file RPCBookDetUnitME.cc.

                                                                             {
  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);
    }
  }
}

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

Referenced by bookHistograms().

bookRollME()

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

protected

Booking of MonitoringElement for one RPCDetId (= roll)

Name components common to current RPCDetId

Definition at line 8 of file RPCBookDetUnitME.cc.

                                                                           {
  RPCBookFolderStructure folderStr;
  std::string folder = subsystemFolder_ + "/" + recHitType + "/" + folderStr.folderStructure(detId);
 
  ibooker.setCurrentFolder(folder);
 
  //get number of strips in current roll
  int nstrips = this->stripsInRoll(detId, rpcGeo);
  if (nstrips == 0) {
    nstrips = 1;
  }
 
  RPCGeomServ RPCname(detId);
  std::string nameRoll = "";
 
  if (RPCMonitorDigi::useRollInfo_) {
    nameRoll = RPCname.name();
  } else {
    nameRoll = RPCname.chambername();
 
    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::stringstream os;
  os.str("");
  os << "Occupancy_" << nameRoll;
  meMap[os.str()] = ibooker.book1D(os.str(), os.str(), nstrips, 0.5, nstrips + 0.5);
 
  os.str("");
  os << "BXDistribution_" << nameRoll;
  meMap[os.str()] = ibooker.book1D(os.str(), os.str(), 7, -3.5, 3.5);
 
  if (detId.region() == 0) {
    os.str("");
    os << "ClusterSize_" << nameRoll;
    meMap[os.str()] = ibooker.book1D(os.str(), os.str(), 15, 0.5, 15.5);
 
    os.str("");
    os << "Multiplicity_" << nameRoll;
    meMap[os.str()] = ibooker.book1D(os.str(), os.str(), 30, 0.5, 30.5);
 
  } else {
    os.str("");
    os << "ClusterSize_" << nameRoll;
    meMap[os.str()] = ibooker.book1D(os.str(), os.str(), 10, 0.5, 10.5);
 
    os.str("");
    os << "Multiplicity_" << nameRoll;
    meMap[os.str()] = ibooker.book1D(os.str(), os.str(), 15, 0.5, 15.5);
  }
 
  os.str("");
  os << "NumberOfClusters_" << nameRoll;
  meMap[os.str()] = ibooker.book1D(os.str(), os.str(), 10, 0.5, 10.5);
}

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

Referenced by bookHistograms().

bookSectorRingME()

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

protected

Booking of MonitoringElement at Sector/Ring level.

Definition at line 76 of file RPCBookDetUnitME.cc.

                                                                                 {
  std::stringstream os;
 
  for (int wheel = -2; wheel <= 2; wheel++) {
    os.str("");
    os << subsystemFolder_ << "/" << recHitType << "/Barrel/Wheel_" << wheel << "/SummaryBySectors";
    ibooker.setCurrentFolder(os.str());
 
    for (int sector = 1; sector <= 12; sector++) {
      os.str("");
      os << "Occupancy_Wheel_" << wheel << "_Sector_" << sector;
 
      if (sector == 9 || sector == 11)
        meMap[os.str()] = ibooker.book2D(os.str(), os.str(), 91, 0.5, 91.5, 15, 0.5, 15.5);
      else if (sector == 4)
        meMap[os.str()] = ibooker.book2D(os.str(), os.str(), 91, 0.5, 91.5, 21, 0.5, 21.5);
      else
        meMap[os.str()] = ibooker.book2D(os.str(), os.str(), 91, 0.5, 91.5, 17, 0.5, 17.5);
 
      meMap[os.str()]->setAxisTitle("strip", 1);
      rpcdqm::utils rpcUtils;
      rpcUtils.labelYAxisRoll(meMap[os.str()], 0, wheel, 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++) {
      os.str("");
      os << subsystemFolder_ << "/" << recHitType << "/" << regionName << "/Disk_" << (region * disk)
         << "/SummaryByRings/";
 
      ibooker.setCurrentFolder(os.str());
 
      for (int ring = RPCMonitorDigi::numberOfInnerRings_; ring <= 3; ring++) {
        os.str("");
        os << "Occupancy_Disk_" << (region * disk) << "_Ring_" << ring << "_CH01-CH18";
 
        meMap[os.str()] = ibooker.book2D(os.str(), os.str(), 96, 0.5, 96.5, 18, 0.5, 18.5);
        meMap[os.str()]->setAxisTitle("strip", 1);
        rpcdqm::RPCMEHelper::setNoAlphanumeric(meMap[os.str()]);
 
        std::stringstream yLabel;
        for (int i = 1; i <= 18; i++) {
          yLabel.str("");
          yLabel << "R" << ring << "_CH" << std::setw(2) << std::setfill('0') << i;
          meMap[os.str()]->setBinLabel(i, yLabel.str(), 2);
        }
 
        for (int i = 1; i <= 96; i++) {
          if (i == 1)
            meMap[os.str()]->setBinLabel(i, "1", 1);
          else if (i == 16)
            meMap[os.str()]->setBinLabel(i, "RollA", 1);
          else if (i == 32)
            meMap[os.str()]->setBinLabel(i, "32", 1);
          else if (i == 33)
            meMap[os.str()]->setBinLabel(i, "1", 1);
          else if (i == 48)
            meMap[os.str()]->setBinLabel(i, "RollB", 1);
          else if (i == 64)
            meMap[os.str()]->setBinLabel(i, "32", 1);
          else if (i == 65)
            meMap[os.str()]->setBinLabel(i, "1", 1);
          else if (i == 80)
            meMap[os.str()]->setBinLabel(i, "RollC", 1);
          else if (i == 96)
            meMap[os.str()]->setBinLabel(i, "32", 1);
          else
            meMap[os.str()]->setBinLabel(i, "", 1);
        }
 
        os.str("");
        os << "Occupancy_Disk_" << (region * disk) << "_Ring_" << ring << "_CH19-CH36";
 
        meMap[os.str()] = ibooker.book2D(os.str(), os.str(), 96, 0.5, 96.5, 18, 18.5, 36.5);
        meMap[os.str()]->setAxisTitle("strip", 1);
        rpcdqm::RPCMEHelper::setNoAlphanumeric(meMap[os.str()]);
 
        for (int i = 1; i <= 18; i++) {
          yLabel.str("");
          yLabel << "R" << ring << "_CH" << i + 18;
          meMap[os.str()]->setBinLabel(i, yLabel.str(), 2);
        }
 
        for (int i = 1; i <= 96; i++) {
          if (i == 1)
            meMap[os.str()]->setBinLabel(i, "1", 1);
          else if (i == 16)
            meMap[os.str()]->setBinLabel(i, "RollA", 1);
          else if (i == 32)
            meMap[os.str()]->setBinLabel(i, "32", 1);
          else if (i == 33)
            meMap[os.str()]->setBinLabel(i, "1", 1);
          else if (i == 48)
            meMap[os.str()]->setBinLabel(i, "RollB", 1);
          else if (i == 64)
            meMap[os.str()]->setBinLabel(i, "32", 1);
          else if (i == 65)
            meMap[os.str()]->setBinLabel(i, "1", 1);
          else if (i == 80)
            meMap[os.str()]->setBinLabel(i, "RollC", 1);
          else if (i == 96)
            meMap[os.str()]->setBinLabel(i, "32", 1);
          else
            meMap[os.str()]->setBinLabel(i, "", 1);
        }
 
      }  //loop ring
    }    //loop disk
  }      //loop region
}

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

Referenced by bookHistograms().

bookWheelDiskME()

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

protected

Booking of MonitoringElemnt at Wheel/Disk level.

Definition at line 197 of file RPCBookDetUnitME.cc.

                                                                                {
  ibooker.setCurrentFolder(subsystemFolder_ + "/" + recHitType + "/" + globalFolder_);
 
  std::stringstream os, label, name, title;
  rpcdqm::utils rpcUtils;
 
  for (int wheel = -2; wheel <= 2; wheel++) {  //Loop on wheel
    os.str("");
    os << "1DOccupancy_Wheel_" << wheel;
    meMap[os.str()] = ibooker.book1D(os.str(), os.str(), 12, 0.5, 12.5);
    for (int i = 1; i < 12; i++) {
      label.str("");
      label << "Sec" << i;
      meMap[os.str()]->setBinLabel(i, label.str(), 1);
    }
 
    os.str("");
    os << "Occupancy_Roll_vs_Sector_Wheel_" << wheel;
    meMap[os.str()] = ibooker.book2D(os.str(), os.str(), 12, 0.5, 12.5, 21, 0.5, 21.5);
    rpcUtils.labelXAxisSector(meMap[os.str()]);
    rpcUtils.labelYAxisRoll(meMap[os.str()], 0, wheel, true);
 
    os.str("");
    os << "BxDistribution_Wheel_" << wheel;
    meMap[os.str()] = ibooker.book1D(os.str(), os.str(), 9, -4.5, 4.5);
 
    for (int layer = 1; layer <= 6; layer++) {
      name.str("");
      title.str("");
      name << "ClusterSize_Wheel_" << wheel << "_Layer" << layer;
      title << "ClusterSize - Wheel " << wheel << " Layer" << layer;
      meMap[name.str()] = ibooker.book1D(name.str(), title.str(), 16, 0.5, 16.5);
    }
 
  }  //end loop on wheel
 
  for (int disk = -RPCMonitorDigi::numberOfDisks_; disk <= RPCMonitorDigi::numberOfDisks_; disk++) {
    if (disk == 0)
      continue;
 
    os.str("");
    os << "Occupancy_Ring_vs_Segment_Disk_" << disk;
    meMap[os.str()] = ibooker.book2D(os.str(), os.str(), 36, 0.5, 36.5, 6, 0.5, 6.5);
 
    rpcUtils.labelXAxisSegment(meMap[os.str()]);
    rpcUtils.labelYAxisRing(meMap[os.str()], 2, true);
 
    os.str("");
    os << "BxDistribution_Disk_" << disk;
    meMap[os.str()] = ibooker.book1D(os.str(), os.str(), 9, -4.5, 4.5);
 
    for (int ring = RPCMonitorDigi::numberOfInnerRings_; ring <= 3; ring++) {
      name.str("");
      title.str("");
      name << "ClusterSize_Disk_" << disk << "_Ring" << ring;
      title << "ClusterSize - Disk" << disk << " Ring" << ring;
      meMap[name.str()] = ibooker.book1D(name.str(), title.str(), 16, 0.5, 16.5);
    }
  }
 
  for (int ring = RPCMonitorDigi::numberOfInnerRings_; ring <= 3; ring++) {
    os.str("");
    os << "1DOccupancy_Ring_" << ring;
    meMap[os.str()] = ibooker.book1D(os.str(),
                                     os.str(),
                                     RPCMonitorDigi::numberOfDisks_ * 2,
                                     0.5,
                                     ((double)RPCMonitorDigi::numberOfDisks_ * 2.0) + 0.5);
    for (int xbin = 1; xbin <= RPCMonitorDigi::numberOfDisks_ * 2; xbin++) {
      label.str("");
      if (xbin < RPCMonitorDigi::numberOfDisks_ + 1)
        label << "Disk " << (xbin - (RPCMonitorDigi::numberOfDisks_ + 1));
      else
        label << "Disk " << (xbin - RPCMonitorDigi::numberOfDisks_);
      meMap[os.str()]->setBinLabel(xbin, label.str(), 1);
    }
  }
}

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

Referenced by bookHistograms().

performSourceOperation()

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

private

Definition at line 214 of file RPCMonitorDigi.cc.

                                                                  {
  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};
  std::stringstream os;
 
  //Loop on Rolls
  for (std::map<RPCDetId, std::vector<RPCRecHit> >::const_iterator detIdIter = recHitMap.begin();
       detIdIter != recHitMap.end();
       detIdIter++) {
    RPCDetId detId = (*detIdIter).first;
 
    //get roll number
    rpcdqm::utils rpcUtils;
    int nr = rpcUtils.detId2RollNr(detId);
 
    RPCGeomServ geoServ(detId);
    std::string nameRoll = "";
 
    if (useRollInfo_)
      nameRoll = geoServ.name();
    else
      nameRoll = geoServ.chambername();
 
    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;
    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
    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  #################################
 
      os.str("");
      os << "Occupancy_" << nameRoll;
      if (meMap[os.str()]) {
        for (int s = firstStrip; s <= lastStrip; s++) {
          if (useRollInfo_) {
            meMap[os.str()]->Fill(s);
          } else {
            int nstrips = meMap[os.str()]->getNbinsX() / totalRolls;
            meMap[os.str()]->Fill(s + nstrips * (roll - 1));
          }
        }
      }
 
      os.str("");
      os << "BXDistribution_" << nameRoll;
      if (meMap[os.str()])
        meMap[os.str()]->Fill(bx);
 
      os.str("");
      os << "ClusterSize_" << nameRoll;
      if (meMap[os.str()])
        meMap[os.str()]->Fill(clusterSize);
 
      // ###################### Sector- Ring Level #################################
 
      os.str("");
      os << "Occupancy_" << wheelOrDiskType << "_" << wheelOrDiskNumber << "_Sector_" << sector;
      if (meSectorRing[os.str()]) {
        for (int s = firstStrip; s <= lastStrip; s++) {  //Loop on digis
          meSectorRing[os.str()]->Fill(s, nr);
        }
      }
 
      os.str("");
      if (geoServ.segment() > 0 && geoServ.segment() < 19) {
        os << "Occupancy_" << wheelOrDiskType << "_" << wheelOrDiskNumber << "_Ring_" << ring << "_CH01-CH18";
      } else if (geoServ.segment() > 18) {
        os << "Occupancy_" << wheelOrDiskType << "_" << wheelOrDiskNumber << "_Ring_" << ring << "_CH19-CH36";
      }
 
      if (meSectorRing[os.str()]) {
        for (int s = firstStrip; s <= lastStrip; s++) {  //Loop on digis
          meSectorRing[os.str()]->Fill(s + 32 * (detId.roll() - 1), geoServ.segment());
        }
      }
 
      // ###################### 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]);
  }
}

References funct::abs(), l1GtPatternGenerator_cfi::bx, RPCGeomServ::chambername(), rpcdqm::utils::detId2RollNr(), mps_fire::i, createfilelist::int, RPCDetId::layer(), genParticles_cff::map, meMuonCollection, meNoiseCollection, muonFolder_, RPCGeomServ::name(), noiseFolder_, EgHLTOffHistBins_cfi::nr, numberOfDisks_, rpcPointValidation_cfi::recHit, FastTrackerRecHitMaskProducer_cfi::recHits, RPCDetId::region(), HLT_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().

stripsInRoll()

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

private

Definition at line 279 of file RPCBookDetUnitME.cc.

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

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

Referenced by bookRollME().

Member Data Documentation

counter

int RPCMonitorDigi::counter

private

Definition at line 51 of file RPCMonitorDigi.h.

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

globalFolder_

std::string RPCMonitorDigi::globalFolder_

private

Definition at line 73 of file RPCMonitorDigi.h.

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

meMuonCollection

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

private

Definition at line 63 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and performSourceOperation().

meNoiseCollection

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

private

Definition at line 68 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and performSourceOperation().

muEtaCut_

float RPCMonitorDigi::muEtaCut_

private

Definition at line 53 of file RPCMonitorDigi.h.

Referenced by analyze(), and RPCMonitorDigi().

muonFolder_

std::string RPCMonitorDigi::muonFolder_

private

Definition at line 49 of file RPCMonitorDigi.h.

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

muonLabel_

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

private

Definition at line 76 of file RPCMonitorDigi.h.

Referenced by analyze(), and RPCMonitorDigi().

muonRPCEvents_

MonitorElement* RPCMonitorDigi::muonRPCEvents_

private

Definition at line 56 of file RPCMonitorDigi.h.

Referenced by analyze(), and bookHistograms().

muPtCut_

float RPCMonitorDigi::muPtCut_

private

Definition at line 53 of file RPCMonitorDigi.h.

Referenced by analyze(), and RPCMonitorDigi().

noiseFolder_

std::string RPCMonitorDigi::noiseFolder_

private

Definition at line 50 of file RPCMonitorDigi.h.

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

noiseRPCEvents_

MonitorElement* RPCMonitorDigi::noiseRPCEvents_

private

Definition at line 55 of file RPCMonitorDigi.h.

Referenced by analyze(), and bookHistograms().

numberOfDisks_

int RPCMonitorDigi::numberOfDisks_

private

Definition at line 61 of file RPCMonitorDigi.h.

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

numberOfInnerRings_

int RPCMonitorDigi::numberOfInnerRings_

private

Definition at line 61 of file RPCMonitorDigi.h.

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

NumberOfMuon_

MonitorElement* RPCMonitorDigi::NumberOfMuon_

private

Definition at line 59 of file RPCMonitorDigi.h.

Referenced by analyze(), and bookHistograms().

NumberOfRecHitMuon_

MonitorElement* RPCMonitorDigi::NumberOfRecHitMuon_

private

Definition at line 58 of file RPCMonitorDigi.h.

Referenced by analyze(), and bookHistograms().

regionMuonCollection

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

private

Definition at line 65 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and performSourceOperation().

regionNames_

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

staticprivate

Definition at line 48 of file RPCMonitorDigi.h.

Referenced by bookRegionME(), and performSourceOperation().

regionNoiseCollection

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

private

Definition at line 70 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and performSourceOperation().

rpcRecHitLabel_

edm::EDGetTokenT<RPCRecHitCollection> RPCMonitorDigi::rpcRecHitLabel_

private

Definition at line 77 of file RPCMonitorDigi.h.

Referenced by analyze(), and RPCMonitorDigi().

scalersRawToDigiLabel_

edm::EDGetTokenT<DcsStatusCollection> RPCMonitorDigi::scalersRawToDigiLabel_

private

Definition at line 78 of file RPCMonitorDigi.h.

Referenced by RPCMonitorDigi().

sectorRingMuonCollection

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

private

Definition at line 66 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and performSourceOperation().

sectorRingNoiseCollection

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

private

Definition at line 71 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and performSourceOperation().

subsystemFolder_

std::string RPCMonitorDigi::subsystemFolder_

private

Definition at line 74 of file RPCMonitorDigi.h.

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

useMuonDigis_

bool RPCMonitorDigi::useMuonDigis_

private

Definition at line 43 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and RPCMonitorDigi().

useRollInfo_

bool RPCMonitorDigi::useRollInfo_

private

Definition at line 54 of file RPCMonitorDigi.h.

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

wheelDiskMuonCollection

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

private

Definition at line 64 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and performSourceOperation().

wheelDiskNoiseCollection

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

private

Definition at line 69 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and performSourceOperation().