#include <RPCMonitorDigi.h>

Inheritance diagram for RPCMonitorDigi:

Public Member Functions
virtual void	analyze (const edm::Event &, const edm::EventSetup &)
virtual void	beginJob ()
void	beginRun (const edm::Run &r, const edm::EventSetup &c)
void	bookRegionME (const std::string &, std::map< std::string, MonitorElement * > &)
	Booking of MonitoringElemnt at region (Barrel/Endcap) level.
void	bookRollME (RPCDetId &, const edm::EventSetup &, const std::string &, std::map< std::string, MonitorElement * > &)
	Booking of MonitoringElement for one RPCDetId (= roll)
void	bookSectorRingME (const std::string &, std::map< std::string, MonitorElement * > &)
	Booking of MonitoringElement at Sector/Ring level.
void	bookWheelDiskME (const std::string &, std::map< std::string, MonitorElement * > &)
	Booking of MonitoringElemnt at Wheel/Disk level.
virtual void	endJob (void)
void	endLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &)
	RPCMonitorDigi (const edm::ParameterSet &)
	~RPCMonitorDigi ()
Private Types
enum	detectorRegions { EM = 0, B = 1, EP = 2, ALL = 3 }
Private Member Functions
void	makeDcsInfo (const edm::Event &)
void	performSourceOperation (std::map< RPCDetId, std::vector< RPCRecHit > > &, std::string)
int	stripsInRoll (RPCDetId &, const edm::EventSetup &)
Private Attributes
int	counter
DQMStore *	dbe
	DQM store.
bool	dcs_
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::InputTag	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::InputTag	rpcRecHitLabel_
bool	saveRootFile
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+"}
	Data Format.

Detailed Description

Definition at line 20 of file RPCMonitorDigi.h.

Member Enumeration Documentation

enum RPCMonitorDigi::detectorRegions [private]

Enumerator:

EM
B
EP
ALL

Definition at line 54 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 22 of file RPCMonitorDigi.cc.

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

                                                           :counter(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);
  muonLabel_ = pset.getParameter<edm::InputTag>("MuonLabel");
  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");

  rpcRecHitLabel_ = pset.getParameter<edm::InputTag>("RecHitLabel");

  numberOfDisks_ = pset.getUntrackedParameter<int>("NumberOfEndcapDisks", 3);
  numberOfInnerRings_ = pset.getUntrackedParameter<int>("NumberOfInnermostEndcapRings", 2);

  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
	)		`[virtual]`

Implements edm::EDAnalyzer.

Definition at line 135 of file RPCMonitorDigi.cc.

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

                                                                             {
  dcs_ = true;
  //Check HV status
  this->makeDcsInfo(event);
  if( !dcs_){
    edm::LogWarning ("rpcmonitordigi") <<"[RPCMonitorDigi]: DCS bit OFF" ;  
    return;//if RPC not ON there's no need to continue
  }

  counter++;
  edm::LogInfo ("rpcmonitordigi") <<"[RPCMonitorDigi]: Beginning analyzing event " << counter;
 
  //Muons
  edm::Handle<reco::CandidateView> muonCands;
  event.getByLabel(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
    
    }

    if( NumberOfMuon_)  NumberOfMuon_->Fill(numMuons);
    if( NumberOfRecHitMuon_)  NumberOfRecHitMuon_->Fill( numRPCRecHit);
    
  }else{
    edm::LogError ("rpcmonitordigi") <<"[RPCMonitorDigi]: Muons - Product not valid for event" << counter;
  }
  
 //RecHits
  edm::Handle<RPCRecHitCollection> rpcHits;
  event.getByLabel( 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;
  }

 
  if( useMuonDigis_ && muonRPCEvents_ != 0 )  muonRPCEvents_->Fill(1);
  if( noiseRPCEvents_ != 0)  noiseRPCEvents_->Fill(1);

  if(useMuonDigis_ ) this->performSourceOperation(rechitMuon, muonFolder_);
  this->performSourceOperation(rechitNoise, noiseFolder_);
}

void RPCMonitorDigi::beginJob ( void ) [virtual]

Reimplemented from edm::EDAnalyzer.

Definition at line 47 of file RPCMonitorDigi.cc.

{}

void RPCMonitorDigi::beginRun	(	const edm::Run &	r,
		const edm::EventSetup &	c
	)		`[virtual]`

get hold of back-end interface

Reimplemented from edm::EDAnalyzer.

Definition at line 49 of file RPCMonitorDigi.cc.

References DQMStore::book1D(), bookRegionME(), bookRollME(), bookSectorRingME(), bookWheelDiskME(), RPCGeomServ::chambername(), dbe, dcs_, edm::EventSetup::get(), DQMStore::get(), MonitorElement::getName(), meMuonCollection, meNoiseCollection, muonFolder_, muonRPCEvents_, RPCGeomServ::name(), noiseFolder_, noiseRPCEvents_, NumberOfMuon_, NumberOfRecHitMuon_, cppFunctionSkipper::operator, alignCSCRings::r, regionMuonCollection, regionNoiseCollection, DQMStore::removeElement(), RPCChamber::rolls(), sectorRingMuonCollection, sectorRingNoiseCollection, DQMStore::setCurrentFolder(), subsystemFolder_, useMuonDigis_, useRollInfo_, wheelDiskMuonCollection, and wheelDiskNoiseCollection.

                                                                         {

  edm::LogInfo ("rpcmonitordigi") <<"[RPCMonitorDigi]: Begin Run " ;
  
  dbe = edm::Service<DQMStore>().operator->();

  //Book 
  this->bookRegionME(noiseFolder_, regionNoiseCollection);
  this->bookSectorRingME(noiseFolder_, sectorRingNoiseCollection);
  this->bookWheelDiskME(noiseFolder_, wheelDiskNoiseCollection);



  std::string currentFolder = subsystemFolder_ +"/"+noiseFolder_;
  dbe->setCurrentFolder(currentFolder);
  
  noiseRPCEvents_= dbe->get(currentFolder +"/RPCEvents");
  if(noiseRPCEvents_) dbe->removeElement(noiseRPCEvents_->getName());
  noiseRPCEvents_ = dbe->book1D("RPCEvents","RPCEvents", 1, 0.5, 1.5);
  
  
  if(useMuonDigis_ ){
    this->bookRegionME(muonFolder_, regionMuonCollection);
    this->bookSectorRingME(muonFolder_, sectorRingMuonCollection);
    this->bookWheelDiskME(muonFolder_, wheelDiskMuonCollection);
    
    currentFolder = subsystemFolder_ +"/"+muonFolder_;
    dbe->setCurrentFolder(currentFolder); 
   
    muonRPCEvents_= dbe->get(currentFolder +"/RPCEvents");
    if(muonRPCEvents_) dbe->removeElement(muonRPCEvents_->getName());
    muonRPCEvents_ =  dbe->book1D("RPCEvents", "RPCEvents", 1, 0.5, 1.5);

    NumberOfMuon_ = dbe->get(currentFolder+"/NumberOfMuons");
    if(NumberOfMuon_) dbe->removeElement(NumberOfMuon_->getName());
    NumberOfMuon_ = dbe->book1D("NumberOfMuons", "Number of Muons", 11, -0.5, 10.5);


    NumberOfRecHitMuon_ = dbe->get(currentFolder+"/NumberOfRPCRecHitsMuons");
    if(NumberOfRecHitMuon_) dbe->removeElement(NumberOfRecHitMuon_->getName());
    NumberOfRecHitMuon_ = dbe->book1D("NumberOfRecHitMuons", "Number of RPC RecHits per Muon", 8, -0.5, 7.5);
  }
   

  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< RPCChamber* >( *it ) != 0 ){
      RPCChamber* ch = dynamic_cast< 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();
          //booking all histograms
          RPCGeomServ rpcsrv(rpcId);
          std::string nameID = rpcsrv.name();
          if(useMuonDigis_) bookRollME(rpcId ,iSetup, muonFolder_, meMuonCollection[nameID]);
          bookRollME(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(rpcId,iSetup, muonFolder_, meMuonCollection[nameID]);
        bookRollME(rpcId, iSetup, noiseFolder_, meNoiseCollection[nameID]);
        
      }
    }
  }//end loop on geometry to book all MEs


  //Clear flags;
  dcs_ = true;
}

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

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

Definition at line 319 of file RPCBookDetUnitME.cc.

References newFWLiteAna::bin, DQMStore::book1D(), dbe, DQMStore::get(), MonitorElement::getName(), globalFolder_, mergeVDriftHistosByStation::name, NULL, numberOfInnerRings_, alignCSCRings::r, regionNames_, DQMStore::removeElement(), relativeConstraints::ring, DQMStore::setCurrentFolder(), subsystemFolder_, and indexGen::title.

Referenced by beginRun().

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

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

  std::string currentFolder = subsystemFolder_ +"/"+recHitType+"/"+ globalFolder_;
  dbe->setCurrentFolder(currentFolder);  
  
  MonitorElement * me = NULL;
  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;
    me = dbe->get(currentFolder+ "/" + name.str());
    if (me) dbe->removeElement(me->getName());
     meMap[name.str()] = dbe->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";
  me = dbe->get(currentFolder+ "/" + name.str());
  if (me) dbe->removeElement(me->getName());
  meMap[name.str()]  = dbe->book1D(name.str(), title.str(),  30, 0.5, 30.5);

  name.str("");
  title.str("");
  name<<"NumberOfClusters_Endcap+";
  title<< "Number of Clusters per Event - Endcap+";
  me = dbe->get(currentFolder+ "/" + name.str());
  if (me) dbe->removeElement(me->getName());
  meMap[name.str()]  = dbe->book1D(name.str(), title.str(),  15, 0.5, 15.5);
 
  name.str("");
  title.str("");
  name<<"NumberOfClusters_Endcap-";
  title<< "Number of Clusters per Event - Endcap-";
  me = dbe->get(currentFolder+ "/" + name.str());
  if (me) dbe->removeElement(me->getName());
  meMap[name.str()]  = dbe->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";
  me = dbe->get(currentFolder+ "/" + name.str());
  if (me) dbe->removeElement(me->getName());
  meMap[name.str()] = dbe->book1D(name.str(), title.str(), 50, 0.5, 50.5);   
  
  
  name.str("");
  title.str("");
  name<<"Multiplicity_Endcap+";
  title<< "Multiplicity per Event per Roll - Endcap+";
  me = dbe->get(currentFolder+ "/" + name.str());
  if (me) dbe->removeElement(me->getName());
  meMap[name.str()] = dbe->book1D(name.str(), title.str(), 32, 0.5, 32.5);  
  
  name.str("");
  title.str("");
  name<<"Multiplicity_Endcap-";
  title<< "Multiplicity per Event per Roll - Endcap-";
  me = dbe->get(currentFolder+ "/" + name.str());
  if (me) dbe->removeElement(me->getName());
  meMap[name.str()] = dbe->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;
    me = dbe->get(currentFolder+ "/" + name.str());
    if (me) dbe->removeElement(me->getName());
    meMap[name.str()] = dbe->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;
    me = dbe->get(currentFolder+ "/" + name.str());
    if (me) dbe->removeElement(me->getName());
    meMap[name.str()] = dbe->book1D(name.str(), title.str(),  16, 0.5, 16.5);
  
  }


  me = dbe->get(currentFolder+ "/Occupancy_for_Endcap");
  if (me) dbe->removeElement(me->getName());
  meMap["Occupancy_for_Endcap"] = dbe -> book2D("Occupancy_for_Endcap", "Occupancy Endcap", 6, 0.5, 6.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 <= 6 ; bin++){
    binlabel.str("");
    if(bin<4) {//negative endcap
      binlabel<<(bin-4); 
    }else{//positive endcaps
      binlabel<<(bin-3); 
    }
    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);


  me = dbe->get(currentFolder+ "/Occupancy_for_Barrel");
  if (me) dbe->removeElement(me->getName());
  meMap["Occupancy_for_Barrel"]  = dbe -> 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	(	RPCDetId &	detId,
		const edm::EventSetup &	iSetup,
		const std::string &	recHitType,
		std::map< std::string, MonitorElement * > &	meMap
	)

Booking of MonitoringElement for one RPCDetId (= roll)

Name components common to current RPCDetId

Definition at line 9 of file RPCBookDetUnitME.cc.

References abs, DQMStore::book1D(), RPCGeomServ::chambername(), rpcdqm::CLUSTERSIZE, dbe, RPCBookFolderStructure::folderStructure(), RPCDetId::layer(), rpcdqm::MULTIPLICITY, RPCGeomServ::name(), rpcdqm::OCCUPANCY, RPCDetId::region(), RPCDetId::ring(), DQMStore::setCurrentFolder(), RPCDetId::station(), stripsInRoll(), subsystemFolder_, DQMStore::tag(), and useRollInfo_.

Referenced by beginRun().

                                                                                                                                                         {
  //std::map<std::string, MonitorElement*> RPCMonitorDigi::bookRollME(RPCDetId & detId, const edm::EventSetup & iSetup, std::string recHitType) {
  //std::map<std::string, MonitorElement*> meMap;  

  RPCBookFolderStructure *  folderStr = new RPCBookFolderStructure();
  std::string folder = subsystemFolder_+ "/"+ recHitType +"/"+folderStr->folderStructure(detId);

  dbe->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()] = dbe->book1D(os.str(), os.str(), nstrips, 0.5, nstrips+0.5);
  dbe->tag( meMap[os.str()],  rpcdqm::OCCUPANCY);

  os.str("");
  os<<"BXDistribution_"<<nameRoll;
  meMap[os.str()] = dbe->book1D(os.str(), os.str(), 7, -3.5, 3.5);
   

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

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


//   os.str("");
//   os<<"BXWithData_"<<nameRoll;
//   meMap[os.str()] = dbe->book1D(os.str(), os.str(), 10, 0.5, 10.5);
  
  os.str("");
  os<<"NumberOfClusters_"<<nameRoll;
  meMap[os.str()] = dbe->book1D(os.str(), os.str(),10,0.5,10.5);
  

  delete folderStr;
  //  return meMap;
}

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

Booking of MonitoringElement at Sector/Ring level.

Definition at line 89 of file RPCBookDetUnitME.cc.

References DQMStore::book2D(), dbe, i, rpcdqm::utils::labelYAxisRoll(), numberOfDisks_, numberOfInnerRings_, relativeConstraints::ring, MonitorElement::setAxisTitle(), DQMStore::setCurrentFolder(), and subsystemFolder_.

Referenced by beginRun().

                                                                                                             {  
  //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";
      dbe->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()] = dbe->book2D(os.str(), os.str(),  90, 0.5,  90.5, 15, 0.5, 15.5);
        else  if (sector==4) 
          meMap[os.str()] = dbe->book2D(os.str(), os.str(),  90, 0.5,  90.5, 21, 0.5, 21.5);
        else
          meMap[os.str()] = dbe->book2D(os.str(), os.str(),  90, 0.5,  90.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()] = dbe->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/";
     
      dbe->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()] = dbe->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()] = dbe->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()] = dbe->book1D(os.str(), os.str(), 11, -5.5, 5.5);
        
      }  //loop ring
    } //loop disk
  } //loop region

  // return meMap;
}

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

Booking of MonitoringElemnt at Wheel/Disk level.

Definition at line 205 of file RPCBookDetUnitME.cc.

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

Referenced by beginRun().

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

  //  std::map<std::string, MonitorElement*> meMap;  
  dbe->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()] = dbe->book2D(os.str(), os.str(),63, -800, 800, 63, -800, 800);
    //    meMap[os.str()] = dbe->book2D(os.str(), os.str(),1000, -800, 800, 1000, -800, 800);
    
    
    os.str("");
    os<<"1DOccupancy_Wheel_"<<wheel;
    meMap[os.str()] = dbe->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()] = dbe->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()] = dbe->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()] = dbe->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()] = dbe->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()] = dbe->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()] = dbe->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()] = dbe->book1D(os.str(), os.str(), 6 , 0.5, 6.5);
     for(int xbin= 1 ; xbin<= 6 ; xbin++) {
       label.str("");
       if (xbin < 4) label<<"Disk "<< (xbin - 4);
       else label<<"Disk "<< (xbin - 3);
       meMap[os.str()] ->setBinLabel(xbin, label.str(), 1); 
     }
   }



      
  //  return meMap; 
}

void RPCMonitorDigi::endJob ( void ) [virtual]

Reimplemented from edm::EDAnalyzer.

Definition at line 127 of file RPCMonitorDigi.cc.

References dbe, RootFileName, DQMStore::save(), and saveRootFile.

                               {
  if(saveRootFile) dbe->save(RootFileName); 
  dbe = 0;
}

void RPCMonitorDigi::endLuminosityBlock	(	edm::LuminosityBlock const &	L,
		edm::EventSetup const &	E
	)		`[virtual]`

Reimplemented from edm::EDAnalyzer.

Definition at line 132 of file RPCMonitorDigi.cc.

{}

void RPCMonitorDigi::makeDcsInfo ( const edm::Event & e ) [private]

Definition at line 503 of file RPCMonitorDigi.cc.

References dcs_, edm::Event::getByLabel(), edm::HandleBase::isValid(), and DcsStatus::RPC.

Referenced by analyze().

                                                   {

  edm::Handle<DcsStatusCollection> dcsStatus;

  if ( ! e.getByLabel("scalersRawToDigi", dcsStatus) ){
    dcs_ = true;
    return;
  }
  
  if ( ! dcsStatus.isValid() ) 
  {
    edm::LogWarning("RPCDcsInfo") << "scalersRawToDigi not found" ;
    dcs_ = true; // info not available: set to true
    return;
  }
    
  for (DcsStatusCollection::const_iterator dcsStatusItr = dcsStatus->begin(); 
                            dcsStatusItr != dcsStatus->end(); ++dcsStatusItr){

      if (!dcsStatusItr->ready(DcsStatus::RPC)) dcs_=false;
  }
      
  return ;
}

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

Definition at line 231 of file RPCMonitorDigi.cc.

References abs, RPCRecHit::BunchX(), RPCGeomServ::chambername(), RPCRecHit::clusterSize(), rpcdqm::utils::detId2RollNr(), HcalObjRepresent::Fill(), RPCRecHit::firstClusterStrip(), i, RPCDetId::layer(), Association::map, meMuonCollection, meNoiseCollection, muonFolder_, RPCGeomServ::name(), noiseFolder_, RPCDetId::region(), regionMuonCollection, regionNames_, regionNoiseCollection, RPCDetId::ring(), relativeConstraints::ring, RPCDetId::roll(), alignCSCRings::s, RPCDetId::sector(), sectorRingMuonCollection, sectorRingNoiseCollection, RPCGeomServ::segment(), relativeConstraints::station, RPCDetId::station(), useRollInfo_, wheelDiskMuonCollection, and wheelDiskNoiseCollection.

Referenced by analyze().

                                                                                                                       {

  edm::LogInfo ("rpcmonitordigi") <<"[RPCMonitorDigi]: Performing DQM source operations for "; 
  
  if(recHitMap.size()==0) 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;
    // 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("");
//       os<<"BxDistribution_"<<wheelOrDiskType<<"_"<<wheelOrDiskNumber<<"_Sector_"<<sector;
//       if( meSectorRing[os.str()])  meSectorRing[os.str()]->Fill(bx);

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

     //  os.str("");
//       os<<"BxDistribution_"<<wheelOrDiskType<<"_"<<wheelOrDiskNumber<<"_Ring_"<<ring;
//       if( meSectorRing[os.str()])  meSectorRing[os.str()]->Fill(bx);

      
      // ###################### 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 +3, clusterSize);
          else meWheelDisk[os.str()]->Fill(wheelOrDiskNumber + 4, 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+3;
      if (region==-1) xbin = wheelOrDiskNumber+4;
      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 304 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();

  

}