CMS 3D CMS Logo
Public Member Functions | Private Types | Private Member Functions | Private Attributes | Static Private Attributes

RPCMonitorDigi Class Reference

#include <RPCMonitorDigi.h>

Inheritance diagram for RPCMonitorDigi:
edm::EDAnalyzer

List of all members.

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", "Noise");
  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 146 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_, cmsCodeRules::cppFunctionSkipper::operator, csvReporter::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 

  //regionNoiseCollection = this->bookRegionME(noiseFolder_);
  //sectorRingNoiseCollection = this->bookSectorRingME(noiseFolder_);
  //wheelDiskNoiseCollection = this->bookWheelDiskME(noiseFolder_);
  
  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_ ){
  //   regionMuonCollection = this->bookRegionME(muonFolder_);
//     sectorRingMuonCollection = this->bookSectorRingME(muonFolder_);
//     wheelDiskMuonCollection = this->bookWheelDiskME(muonFolder_);
    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]);
          
          //    if(useMuonDigis_) meMuonCollection[(uint32_t)rpcId] = bookRollME(rpcId,iSetup,  muonFolder_);
          //    meNoiseCollection[(uint32_t)rpcId] = bookRollME(rpcId,iSetup,  noiseFolder_);
        }
      }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 DQMStore::book1D(), dbe, DQMStore::get(), MonitorElement::getName(), globalFolder_, mergeVDriftHistosByStation::name, NULL, numberOfInnerRings_, csvReporter::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);



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


  //  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);
        
//      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, 12 , 18.5,  36.5);
        meMap[os.str()]->setAxisTitle("strip", 1);
        
        for (int i = 1 ; i<= 12; i++) {
          yLabel.str("");
          yLabel<<"R"<<ring<<"_CH"<<i+12;
          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);

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

    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 138 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 143 of file RPCMonitorDigi.cc.

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

Definition at line 514 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 242 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(), asciidump::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();

  

}

Member Data Documentation

int RPCMonitorDigi::counter [private]

Definition at line 65 of file RPCMonitorDigi.h.

Referenced by analyze().

DQMStore* RPCMonitorDigi::dbe [private]

DQM store.

Definition at line 68 of file RPCMonitorDigi.h.

Referenced by beginRun(), bookRegionME(), bookRollME(), bookSectorRingME(), bookWheelDiskME(), and endJob().

bool RPCMonitorDigi::dcs_ [private]

Definition at line 69 of file RPCMonitorDigi.h.

Referenced by analyze(), beginRun(), and makeDcsInfo().

std::string RPCMonitorDigi::globalFolder_ [private]

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

Referenced by beginRun(), and performSourceOperation().

std::map<std::string, std::map<std::string, MonitorElement*> > RPCMonitorDigi::meNoiseCollection [private]

Definition at line 86 of file RPCMonitorDigi.h.

Referenced by beginRun(), and performSourceOperation().

float RPCMonitorDigi::muEtaCut_ [private]

Definition at line 70 of file RPCMonitorDigi.h.

Referenced by analyze(), and RPCMonitorDigi().

std::string RPCMonitorDigi::muonFolder_ [private]

Definition at line 63 of file RPCMonitorDigi.h.

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

edm::InputTag RPCMonitorDigi::muonLabel_ [private]

Definition at line 98 of file RPCMonitorDigi.h.

Referenced by analyze(), and RPCMonitorDigi().

MonitorElement* RPCMonitorDigi::muonRPCEvents_ [private]

Definition at line 73 of file RPCMonitorDigi.h.

Referenced by analyze(), and beginRun().

float RPCMonitorDigi::muPtCut_ [private]

Definition at line 70 of file RPCMonitorDigi.h.

Referenced by analyze(), and RPCMonitorDigi().

std::string RPCMonitorDigi::noiseFolder_ [private]

Definition at line 64 of file RPCMonitorDigi.h.

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

MonitorElement* RPCMonitorDigi::noiseRPCEvents_ [private]

Definition at line 72 of file RPCMonitorDigi.h.

Referenced by analyze(), and beginRun().

int RPCMonitorDigi::numberOfDisks_ [private]

Definition at line 78 of file RPCMonitorDigi.h.

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

int RPCMonitorDigi::numberOfInnerRings_ [private]

Definition at line 78 of file RPCMonitorDigi.h.

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

MonitorElement* RPCMonitorDigi::NumberOfMuon_ [private]

Definition at line 76 of file RPCMonitorDigi.h.

Referenced by analyze(), and beginRun().

MonitorElement* RPCMonitorDigi::NumberOfRecHitMuon_ [private]

Definition at line 75 of file RPCMonitorDigi.h.

Referenced by analyze(), and beginRun().

std::map<std::string, MonitorElement*> RPCMonitorDigi::regionMuonCollection [private]

Definition at line 83 of file RPCMonitorDigi.h.

Referenced by beginRun(), and performSourceOperation().

const std::string RPCMonitorDigi::regionNames_ = {"Endcap-", "Barrel", "Endcap+"} [static, private]

Data Format.

Geometry

Definition at line 62 of file RPCMonitorDigi.h.

Referenced by bookRegionME(), and performSourceOperation().

std::map<std::string, MonitorElement*> RPCMonitorDigi::regionNoiseCollection [private]

Definition at line 88 of file RPCMonitorDigi.h.

Referenced by beginRun(), and performSourceOperation().

std::string RPCMonitorDigi::RootFileName [private]

Definition at line 95 of file RPCMonitorDigi.h.

Referenced by endJob(), and RPCMonitorDigi().

edm::InputTag RPCMonitorDigi::rpcRecHitLabel_ [private]

Definition at line 97 of file RPCMonitorDigi.h.

Referenced by analyze(), and RPCMonitorDigi().

bool RPCMonitorDigi::saveRootFile [private]

Definition at line 94 of file RPCMonitorDigi.h.

Referenced by endJob(), and RPCMonitorDigi().

std::map<std::string, MonitorElement*> RPCMonitorDigi::sectorRingMuonCollection [private]

Definition at line 84 of file RPCMonitorDigi.h.

Referenced by beginRun(), and performSourceOperation().

std::map<std::string, MonitorElement*> RPCMonitorDigi::sectorRingNoiseCollection [private]

Definition at line 89 of file RPCMonitorDigi.h.

Referenced by beginRun(), and performSourceOperation().

std::string RPCMonitorDigi::subsystemFolder_ [private]

Definition at line 92 of file RPCMonitorDigi.h.

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

bool RPCMonitorDigi::useMuonDigis_ [private]

Definition at line 56 of file RPCMonitorDigi.h.

Referenced by analyze(), beginRun(), and RPCMonitorDigi().

bool RPCMonitorDigi::useRollInfo_ [private]

Definition at line 71 of file RPCMonitorDigi.h.

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

std::map<std::string, MonitorElement*> RPCMonitorDigi::wheelDiskMuonCollection [private]

Definition at line 82 of file RPCMonitorDigi.h.

Referenced by beginRun(), and performSourceOperation().

std::map<std::string, MonitorElement*> RPCMonitorDigi::wheelDiskNoiseCollection [private]

Definition at line 87 of file RPCMonitorDigi.h.

Referenced by beginRun(), and performSourceOperation().

Generated for CMSSW Reference Manual by doxygen 1.7.3