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 &ev, edm::EventSetup const &es) final
virtual void	analyze (edm::Event const &, edm::EventSetup const &)
void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) override
void	beginRun (edm::Run const &run, edm::EventSetup const &setup) final
virtual void	dqmBeginRun (edm::Run const &, edm::EventSetup const &)
	DQMEDAnalyzer ()
	DQMEDAnalyzer (DQMEDAnalyzer const &)=delete
	DQMEDAnalyzer (DQMEDAnalyzer &&)=delete
void	endLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &) override
void	endLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &setup) final
void	endRun (edm::Run const &run, edm::EventSetup const &setup) override
void	endRunProduce (edm::Run &run, edm::EventSetup const &setup) override
	~DQMEDAnalyzer () override=default
Public Member Functions inherited from edm::one::EDProducer< edm::Accumulator, edm::EndLuminosityBlockProducer, edm::EndRunProducer, edm::one::WatchLuminosityBlocks, edm::one::WatchRuns >
	EDProducer ()=default
SerialTaskQueue *	globalLuminosityBlocksQueue () final
SerialTaskQueue *	globalRunsQueue () final
bool	hasAbilityToProduceInLumis () const final
bool	hasAbilityToProduceInRuns () 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< ConsumesInfo >	consumesInfo () 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
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
EDConsumerBase &	operator= (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)
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::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 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::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 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< DQMToken >	lumiToken_
edm::EDPutTokenT< DQMToken >	runToken_

Detailed Description

Definition at line 22 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_.

 : counter(0),
   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");

}

RPCMonitorDigi::~RPCMonitorDigi ( )

overridedefault

Member Function Documentation

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

overrideprotected

Definition at line 115 of file RPCMonitorDigi.cc.

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

                                                                             {

  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
    RPCRecHitCollection::const_iterator rpcRecHitIter;
    std::vector<RPCRecHit>::const_iterator muonRecHitIter;
    
    for (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 42 of file RPCMonitorDigi.cc.

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

                                                                                                           {

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

}

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

References stringResolutionProvider_cfi::bin, DQMStore::IBooker::book1D(), DQMStore::IBooker::book2D(), globalFolder_, dataset::name, numberOfDisks_, numberOfInnerRings_, alignCSCRings::r, regionNames_, relativeConstraints::ring, MonitorElement::setAxisTitle(), DQMStore::IBooker::setCurrentFolder(), AlCaHLTBitMon_QueryRunRegistry::string, subsystemFolder_, and fftjetcommon_cfi::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 8 of file RPCBookDetUnitME.cc.

References funct::abs(), DQMStore::IBooker::book1D(), rpcdqm::BX, RPCGeomServ::chambername(), rpcdqm::CLUSTERSIZE, printsummarytable::folder, RPCBookFolderStructure::folderStructure(), RPCDetId::layer(), rpcdqm::MULTIPLICITY, RPCGeomServ::name(), rpcdqm::OCCUPANCY, RPCDetId::region(), RPCDetId::ring(), DQMStore::IBooker::setCurrentFolder(), RPCDetId::station(), AlCaHLTBitMon_QueryRunRegistry::string, stripsInRoll(), subsystemFolder_, DQMStore::IBooker::tag(), and useRollInfo_.

Referenced by bookHistograms().

{
  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);
  ibooker.tag( meMap[os.str()],  rpcdqm::OCCUPANCY);

  os.str("");
  os<<"BXDistribution_"<<nameRoll;
  meMap[os.str()] = ibooker.book1D(os.str(), os.str(), 7, -3.5, 3.5);
  ibooker.tag( meMap[os.str()],  rpcdqm::BX);

  if(detId.region() == 0){
    os.str("");
    os<<"ClusterSize_"<<nameRoll;
    meMap[os.str()] = ibooker.book1D(os.str(), os.str(), 15, 0.5, 15.5);
    ibooker.tag( meMap[os.str()],  rpcdqm::CLUSTERSIZE);
    
    os.str("");
    os<<"Multiplicity_"<<nameRoll;
    meMap[os.str()] = ibooker.book1D(os.str(), os.str(), 30, 0.5, 30.5);
    ibooker.tag( meMap[os.str()],  rpcdqm::MULTIPLICITY);

  }else{
    os.str("");
    os<<"ClusterSize_"<<nameRoll;
    meMap[os.str()] = ibooker.book1D(os.str(), os.str(), 10, 0.5, 10.5);
    ibooker.tag( meMap[os.str()],  rpcdqm::CLUSTERSIZE);
    
    os.str("");
    os<<"Multiplicity_"<<nameRoll;
    meMap[os.str()] = ibooker.book1D(os.str(), os.str(), 15, 0.5, 15.5);
    ibooker.tag( meMap[os.str()],  rpcdqm::MULTIPLICITY);
  }

  
  os.str("");
  os<<"NumberOfClusters_"<<nameRoll;
  meMap[os.str()] = ibooker.book1D(os.str(), os.str(),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 77 of file RPCBookDetUnitME.cc.

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

Referenced by bookHistograms().

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

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

References DQMStore::IBooker::book1D(), DQMStore::IBooker::book2D(), globalFolder_, mps_fire::i, diffTwoXMLs::label, rpcdqm::utils::labelXAxisSector(), rpcdqm::utils::labelXAxisSegment(), rpcdqm::utils::labelYAxisRing(), rpcdqm::utils::labelYAxisRoll(), dataset::name, numberOfDisks_, numberOfInnerRings_, relativeConstraints::ring, DQMStore::IBooker::setCurrentFolder(), subsystemFolder_, fftjetcommon_cfi::title, and makeMuonMisalignmentScenario::wheel.

Referenced by bookHistograms().

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


}

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

private

Definition at line 214 of file RPCMonitorDigi.cc.

References funct::abs(), RPCRecHit::BunchX(), RPCGeomServ::chambername(), RPCRecHit::clusterSize(), rpcdqm::utils::detId2RollNr(), HcalObjRepresent::Fill(), RPCRecHit::firstClusterStrip(), mps_fire::i, createfilelist::int, RPCDetId::layer(), genParticles_cff::map, meMuonCollection, meNoiseCollection, muonFolder_, RPCGeomServ::name(), noiseFolder_, numberOfDisks_, rpcPointValidation_cfi::recHit, RPCDetId::region(), regionMuonCollection, regionNames_, regionNoiseCollection, relativeConstraints::ring, RPCDetId::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};
  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]);
  }

}

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

}

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

private

Definition at line 270 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();
}

Member Data Documentation

int RPCMonitorDigi::counter

private

Definition at line 50 of file RPCMonitorDigi.h.

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

std::string RPCMonitorDigi::globalFolder_

private

Definition at line 72 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 62 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and performSourceOperation().

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

private

Definition at line 67 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and performSourceOperation().

float RPCMonitorDigi::muEtaCut_

private

Definition at line 52 of file RPCMonitorDigi.h.

Referenced by analyze(), and RPCMonitorDigi().

std::string RPCMonitorDigi::muonFolder_

private

Definition at line 48 of file RPCMonitorDigi.h.

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

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

private

Definition at line 75 of file RPCMonitorDigi.h.

Referenced by analyze(), and RPCMonitorDigi().

MonitorElement* RPCMonitorDigi::muonRPCEvents_

private

Definition at line 55 of file RPCMonitorDigi.h.

Referenced by analyze(), and bookHistograms().

float RPCMonitorDigi::muPtCut_

private

Definition at line 52 of file RPCMonitorDigi.h.

Referenced by analyze(), and RPCMonitorDigi().

std::string RPCMonitorDigi::noiseFolder_

private

Definition at line 49 of file RPCMonitorDigi.h.

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

MonitorElement* RPCMonitorDigi::noiseRPCEvents_

private

Definition at line 54 of file RPCMonitorDigi.h.

Referenced by analyze(), and bookHistograms().

int RPCMonitorDigi::numberOfDisks_

private

Definition at line 60 of file RPCMonitorDigi.h.

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

int RPCMonitorDigi::numberOfInnerRings_

private

Definition at line 60 of file RPCMonitorDigi.h.

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

MonitorElement* RPCMonitorDigi::NumberOfMuon_

private

Definition at line 58 of file RPCMonitorDigi.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* RPCMonitorDigi::NumberOfRecHitMuon_

private

Definition at line 57 of file RPCMonitorDigi.h.

Referenced by analyze(), and bookHistograms().

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

private

Definition at line 64 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and performSourceOperation().

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

staticprivate

Definition at line 47 of file RPCMonitorDigi.h.

Referenced by bookRegionME(), and performSourceOperation().

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

private

Definition at line 69 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and performSourceOperation().

edm::EDGetTokenT<RPCRecHitCollection> RPCMonitorDigi::rpcRecHitLabel_

private

Definition at line 76 of file RPCMonitorDigi.h.

Referenced by analyze(), and RPCMonitorDigi().

edm::EDGetTokenT<DcsStatusCollection> RPCMonitorDigi::scalersRawToDigiLabel_

private

Definition at line 77 of file RPCMonitorDigi.h.

Referenced by RPCMonitorDigi().

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

private

Definition at line 65 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and performSourceOperation().

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

private

Definition at line 70 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and performSourceOperation().

std::string RPCMonitorDigi::subsystemFolder_

private

Definition at line 73 of file RPCMonitorDigi.h.

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

bool RPCMonitorDigi::useMuonDigis_

private

Definition at line 42 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and RPCMonitorDigi().

bool RPCMonitorDigi::useRollInfo_

private

Definition at line 53 of file RPCMonitorDigi.h.

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

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

private

Definition at line 63 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and performSourceOperation().

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

private

Definition at line 68 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and performSourceOperation().