RPCMonitorDigi Class Reference

Data Format. More...

#include <RPCMonitorDigi.h>

Inheritance diagram for RPCMonitorDigi:

Public Member Functions
	RPCMonitorDigi (const edm::ParameterSet &)
	~RPCMonitorDigi ()
Public Member Functions inherited from DQMEDAnalyzer
virtual void	beginRun (edm::Run const &, edm::EventSetup const &) final
virtual void	beginStream (edm::StreamID id) final
virtual void	dqmBeginRun (edm::Run const &, edm::EventSetup const &)
	DQMEDAnalyzer (void)
virtual void	endLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, dqmDetails::NoCache *) const final
virtual void	endRunSummary (edm::Run const &, edm::EventSetup const &, dqmDetails::NoCache *) const final
uint32_t	streamId () const
Public Member Functions inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
	EDAnalyzer ()=default
Public Member Functions inherited from edm::stream::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
	EDAnalyzerBase ()
ModuleDescription const &	moduleDescription () const
virtual	~EDAnalyzerBase ()
Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const
	EDConsumerBase ()
ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const
void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const
void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const
std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const
void	labelsForToken (EDGetToken iToken, Labels &oLabels) const
void	modulesDependentUpon (std::string const &iProcessName, std::string const &iModuleLabel, bool iPrint, std::vector< char const * > &oModuleLabels) const
void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const
bool	registeredToConsumeMany (TypeID const &, BranchType) const
void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)
virtual	~EDConsumerBase ()

Protected Member Functions
virtual void	analyze (const edm::Event &, const edm::EventSetup &)
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 &, RPCDetId &, const edm::EventSetup &, 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 Types
enum	detectorRegions { EM = 0, B = 1, EP = 2, ALL =3 }

Private Member Functions
void	performSourceOperation (std::map< RPCDetId, std::vector< RPCRecHit > > &, std::string)
int	stripsInRoll (RPCDetId &, const edm::EventSetup &)

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
std::string	RootFileName
edm::EDGetTokenT < RPCRecHitCollection >	rpcRecHitLabel_
bool	saveRootFile
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::string	regionNames_ [3] = {"Endcap-", "Barrel", "Endcap+"}
	Geometry. More...

Additional Inherited Members
Public Types inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
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
Public Types inherited from edm::stream::EDAnalyzerBase
typedef EDAnalyzerAdaptorBase	ModuleType
Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels
Static Public Member Functions inherited from DQMEDAnalyzer
static std::shared_ptr < dqmDetails::NoCache >	globalBeginLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const *)
static std::shared_ptr < dqmDetails::NoCache >	globalBeginRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const *)
static void	globalEndLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const *, dqmDetails::NoCache *)
static void	globalEndRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const *, dqmDetails::NoCache *)
Static Public Member Functions inherited from edm::stream::EDAnalyzerBase
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &descriptions)

Detailed Description

Data Format.

Definition at line 25 of file RPCMonitorDigi.h.

Member Enumeration Documentation

enum RPCMonitorDigi::detectorRegions

private

Enumerator
EM
B
EP
ALL

Definition at line 46 of file RPCMonitorDigi.h.

{EM = 0, B = 1, EP= 2, ALL=3};

Constructor & Destructor Documentation

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

explicit

Definition at line 19 of file RPCMonitorDigi.cc.

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

 : counter(0),
   numberOfDisks_(0),
   numberOfInnerRings_(0){

  saveRootFile  = pset.getUntrackedParameter<bool>("SaveRootFile", false); 
  RootFileName  = pset.getUntrackedParameter<std::string>("RootFileName", "RPCMonitorDigiDQM.root"); 

  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

(

)

Definition at line 46 of file RPCMonitorDigi.cc.

{}

Member Function Documentation

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

protectedvirtual

Implements edm::stream::EDAnalyzerBase.

Definition at line 121 of file RPCMonitorDigi.cc.

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

                                                                             {

  counter++;
  edm::LogInfo ("rpcmonitordigi") <<"[RPCMonitorDigi]: Beginning analyzing event " << counter;
 
  //Muons
  edm::Handle<reco::CandidateView> muonCands;
  event.getByToken(muonLabel_, muonCands);

  std::map<RPCDetId  , std::vector<RPCRecHit> > rechitMuon;

  int  numMuons = 0;
  int  numRPCRecHit = 0 ;

  if(muonCands.isValid()){

    int nStaMuons = muonCands->size();
    
    for( int i = 0; i < nStaMuons; i++ ) {
      
      const reco::Candidate & goodMuon = (*muonCands)[i];
      const reco::Muon * muCand = dynamic_cast<const reco::Muon*>(&goodMuon);
    
      if(!muCand->isGlobalMuon())continue;
      if(muCand->pt() < muPtCut_  ||  fabs(muCand->eta())>muEtaCut_) continue;
      numMuons++;
      reco::Track muTrack = (*(muCand->outerTrack()));
      std::vector<TrackingRecHitRef > rpcTrackRecHits;
      //loop on mu rechits
      for ( trackingRecHit_iterator it= muTrack.recHitsBegin(); it !=  muTrack.recHitsEnd() ; it++) {
    if (!(*it)->isValid ())continue;
    int muSubDetId = (*it)->geographicalId().subdetId();
    if(muSubDetId == MuonSubdetId::RPC)  {
      numRPCRecHit ++;
      TrackingRecHit * tkRecHit = (*it)->clone();
      RPCRecHit* rpcRecHit = dynamic_cast<RPCRecHit*>(tkRecHit);
      int detId = (int)rpcRecHit->rpcId();
      if(rechitMuon.find(detId) == rechitMuon.end() || rechitMuon[detId].size() == 0){
        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_ != 0 && 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].size() == 0){
    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_ != 0 &&  !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 49 of file RPCMonitorDigi.cc.

References DQMStore::IBooker::book1D(), bookRegionME(), bookRollME(), bookSectorRingME(), bookWheelDiskME(), RPCGeomServ::chambername(), edm::EventSetup::get(), meMuonCollection, meNoiseCollection, muonFolder_, muonRPCEvents_, RPCGeomServ::name(), noiseFolder_, noiseRPCEvents_, numberOfDisks_, numberOfInnerRings_, NumberOfMuon_, NumberOfRecHitMuon_, 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> rpcGeo;
  iSetup.get<MuonGeometryRecord>().get(rpcGeo);

  //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 ) != 0 ){
      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 ,iSetup, muonFolder_, meMuonCollection[nameID]);
      bookRollME(ibooker, rpcId, iSetup, 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,iSetup, muonFolder_, meMuonCollection[nameID]);
    bookRollME(ibooker, rpcId, iSetup, 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 314 of file RPCBookDetUnitME.cc.

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

Referenced by bookHistograms().

                                                                                                                                    {
  //std::map<std::string, MonitorElement*>   RPCMonitorDigi::bookRegionME(std::string recHitType) {

  //  std::map<std::string, MonitorElement*> meMap;  

  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);
    }
  }
  //  return meMap; 

}

void RPCMonitorDigi::bookRollME ( DQMStore::IBooker &  ibooker, RPCDetId &  detId, const edm::EventSetup &  iSetup, 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 9 of file RPCBookDetUnitME.cc.

References funct::abs(), DQMStore::IBooker::book1D(), rpcdqm::BX, RPCGeomServ::chambername(), rpcdqm::CLUSTERSIZE, 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 = new RPCBookFolderStructure();
  std::string folder = subsystemFolder_+ "/"+ recHitType +"/"+folderStr->folderStructure(detId);

  ibooker.setCurrentFolder(folder);
  
  //get number of strips in current roll
  int nstrips = this->stripsInRoll(detId, iSetup);
  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);
  

  delete folderStr;
  //  return meMap;
}

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

References DQMStore::IBooker::book2D(), i, rpcdqm::utils::labelYAxisRoll(), numberOfDisks_, numberOfInnerRings_, HLT_25ns10e33_v2_cff::region, relativeConstraints::ring, MonitorElement::setAxisTitle(), DQMStore::IBooker::setCurrentFolder(), AlCaHLTBitMon_QueryRunRegistry::string, and subsystemFolder_.

Referenced by bookHistograms().

                                                                                                                                        {  
  //std::map<std::string, MonitorElement*> RPCMonitorDigi::bookSectorRingME(std::string recHitType) {  

  //  std::map<std::string, MonitorElement*> meMap;  
  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);
    
//  os.str("");
//  os<<"BxDistribution_Wheel_"<<wheel<<"_Sector_"<<sector;
//  meMap[os.str()] = ibooker.book1D(os.str(), os.str(), 11, -5.5, 5.5);

      }
  }


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

    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);
    
    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);
    }
   
        
//  os.str("");
//  os<<"BxDistribution_Disk_"<<(region * disk)<<"_Ring_"<<ring;
//  meMap[os.str()] = ibooker.book1D(os.str(), os.str(), 11, -5.5, 5.5);
    
      }  //loop ring
    } //loop disk
  } //loop region

  // return meMap;
} 

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

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

Referenced by bookHistograms().

                                                                                                                                     {  
  //std::map<std::string, MonitorElement*> RPCMonitorDigi::bookWheelDiskME(std::string recHitType) {  

  //  std::map<std::string, MonitorElement*> meMap;  
  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<<"OccupancyXY_"<<ringType<<"_"<<ring;
    //    meMap[os.str()] = ibooker.book2D(os.str(), os.str(),63, -800, 800, 63, -800, 800);
    //    meMap[os.str()] = ibooker.book2D(os.str(), os.str(),1000, -800, 800, 1000, -800, 800);
    
    
    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); 
     }
   }



      
  //  return meMap; 
}

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

private

Definition at line 220 of file RPCMonitorDigi.cc.

References funct::abs(), RPCRecHit::BunchX(), RPCGeomServ::chambername(), RPCRecHit::clusterSize(), rpcdqm::utils::detId2RollNr(), HcalObjRepresent::Fill(), RPCRecHit::firstClusterStrip(), i, RPCDetId::layer(), meMuonCollection, meNoiseCollection, muonFolder_, RPCGeomServ::name(), noiseFolder_, numberOfDisks_, HLT_25ns10e33_v2_cff::recHits, RPCDetId::region(), HLT_25ns10e33_v2_cff::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.size()==0) {return;} //if  

  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;
    // int id=detId();
    
    //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]);
  }

}

int RPCMonitorDigi::stripsInRoll ( RPCDetId &  id, const edm::EventSetup &  iSetup  )

private

Definition at line 299 of file RPCBookDetUnitME.cc.

References edm::EventSetup::get(), and RPCRoll::nstrips().

Referenced by bookRollME().

                                                                             {
  edm::ESHandle<RPCGeometry> rpcgeo;
  iSetup.get<MuonGeometryRecord>().get(rpcgeo);

  const RPCRoll * rpcRoll = rpcgeo->roll(id);

  if (!rpcRoll) return 1;

  return  rpcRoll->nstrips();

  

}

Member Data Documentation

int RPCMonitorDigi::counter

private

Definition at line 56 of file RPCMonitorDigi.h.

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

std::string RPCMonitorDigi::globalFolder_

private

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

Referenced by bookHistograms(), and performSourceOperation().

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

private

Definition at line 74 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and performSourceOperation().

float RPCMonitorDigi::muEtaCut_

private

Definition at line 58 of file RPCMonitorDigi.h.

Referenced by analyze(), and RPCMonitorDigi().

std::string RPCMonitorDigi::muonFolder_

private

Definition at line 54 of file RPCMonitorDigi.h.

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

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

private

Definition at line 85 of file RPCMonitorDigi.h.

Referenced by analyze(), and RPCMonitorDigi().

MonitorElement* RPCMonitorDigi::muonRPCEvents_

private

Definition at line 61 of file RPCMonitorDigi.h.

Referenced by analyze(), and bookHistograms().

float RPCMonitorDigi::muPtCut_

private

Definition at line 58 of file RPCMonitorDigi.h.

Referenced by analyze(), and RPCMonitorDigi().

std::string RPCMonitorDigi::noiseFolder_

private

Definition at line 55 of file RPCMonitorDigi.h.

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

MonitorElement* RPCMonitorDigi::noiseRPCEvents_

private

Definition at line 60 of file RPCMonitorDigi.h.

Referenced by analyze(), and bookHistograms().

int RPCMonitorDigi::numberOfDisks_

private

Definition at line 66 of file RPCMonitorDigi.h.

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

int RPCMonitorDigi::numberOfInnerRings_

private

Definition at line 66 of file RPCMonitorDigi.h.

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

MonitorElement* RPCMonitorDigi::NumberOfMuon_

private

Definition at line 64 of file RPCMonitorDigi.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* RPCMonitorDigi::NumberOfRecHitMuon_

private

Definition at line 63 of file RPCMonitorDigi.h.

Referenced by analyze(), and bookHistograms().

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

private

Definition at line 71 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and performSourceOperation().

const std::string RPCMonitorDigi::regionNames_ = {"Endcap-", "Barrel", "Endcap+"}

staticprivate

Geometry.

Definition at line 53 of file RPCMonitorDigi.h.

Referenced by bookRegionME(), and performSourceOperation().

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

private

Definition at line 76 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and performSourceOperation().

std::string RPCMonitorDigi::RootFileName

private

Definition at line 83 of file RPCMonitorDigi.h.

Referenced by RPCMonitorDigi().

edm::EDGetTokenT<RPCRecHitCollection> RPCMonitorDigi::rpcRecHitLabel_

private

Definition at line 86 of file RPCMonitorDigi.h.

Referenced by analyze(), and RPCMonitorDigi().

bool RPCMonitorDigi::saveRootFile

private

Definition at line 82 of file RPCMonitorDigi.h.

Referenced by RPCMonitorDigi().

edm::EDGetTokenT<DcsStatusCollection> RPCMonitorDigi::scalersRawToDigiLabel_

private

Definition at line 87 of file RPCMonitorDigi.h.

Referenced by RPCMonitorDigi().

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

private

Definition at line 72 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and performSourceOperation().

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

private

Definition at line 77 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and performSourceOperation().

std::string RPCMonitorDigi::subsystemFolder_

private

Definition at line 80 of file RPCMonitorDigi.h.

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

bool RPCMonitorDigi::useMuonDigis_

private

Definition at line 48 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and RPCMonitorDigi().

bool RPCMonitorDigi::useRollInfo_

private

Definition at line 59 of file RPCMonitorDigi.h.

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

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

private

Definition at line 70 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and performSourceOperation().

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

private

Definition at line 75 of file RPCMonitorDigi.h.

Referenced by bookHistograms(), and performSourceOperation().