#include <RPCOccupancyTest.h>

Inheritance diagram for RPCOccupancyTest:

Public Member Functions
void	beginJob (std::string &) override

void	clientOperation () override

void	getMonitorElements (std::vector< MonitorElement * > &, std::vector< RPCDetId > &, std::string &) override

void	myBooker (DQMStore::IBooker &) override

	RPCOccupancyTest (const edm::ParameterSet &ps)

	~RPCOccupancyTest () override

Public Member Functions inherited from RPCClient
virtual	~RPCClient (void)

Protected Member Functions
void	fillGlobalME (RPCDetId &, MonitorElement *)

Private Attributes
MonitorElement *	Active_Dead

MonitorElement *	Active_Fraction

MonitorElement *	AsyMeDisk [10]

MonitorElement *	AsyMeWheel [5]

MonitorElement *	Barrel_OccBySt

MonitorElement *	EndCap_OccByDisk

MonitorElement *	EndCap_OccByRng

std::string	globalFolder_

std::vector< RPCDetId >	myDetIds_

std::vector< MonitorElement * >	myOccupancyMe_

MonitorElement *	NormOccupDDisk [10]

MonitorElement *	NormOccupDisk [10]

MonitorElement *	NormOccupDWheel [5]

MonitorElement *	NormOccupWheel [5]

int	numberOfDisks_

int	numberOfRings_

std::string	prefixDir_

int	prescaleFactor_

float	rpcevents_

float	totalActive_

float	totalStrips_

bool	useNormalization_

bool	useRollInfo_

Detailed Description

Definition at line 13 of file RPCOccupancyTest.h.

Constructor & Destructor Documentation

RPCOccupancyTest::RPCOccupancyTest ( const edm::ParameterSet & ps )

Definition at line 12 of file RPCOccupancyTest.cc.

References edm::ParameterSet::getUntrackedParameter(), numberOfDisks_, numberOfRings_, prefixDir_, prescaleFactor_, AlCaHLTBitMon_QueryRunRegistry::string, useNormalization_, and useRollInfo_.

                                                             {
   edm::LogVerbatim ("rpceventsummary") << "[RPCOccupancyTest]: Constructor";
   
   prescaleFactor_ = ps.getUntrackedParameter<int>("DiagnosticPrescale", 1);
   numberOfDisks_ = ps.getUntrackedParameter<int>("NumberOfEndcapDisks", 4);
   numberOfRings_ = ps.getUntrackedParameter<int>("NumberOfEndcapRings", 2);
   useNormalization_ = ps.getUntrackedParameter<bool>("testMode", true);
   useRollInfo_ = ps.getUntrackedParameter<bool>("useRollInfo_", false);
 
   std::string subsystemFolder = ps.getUntrackedParameter<std::string>("RPCFolder", "RPC");
   std::string recHitTypeFolder= ps.getUntrackedParameter<std::string>("RecHitTypeFolder", "AllHits");
 
   prefixDir_ =   subsystemFolder+ "/"+ recHitTypeFolder;
  
 }

RPCOccupancyTest::~RPCOccupancyTest ( )

override

Definition at line 28 of file RPCOccupancyTest.cc.

28 {}

Member Function Documentation

void RPCOccupancyTest::beginJob ( std::string & workingFolder )

overridevirtual

Implements RPCClient.

Definition at line 30 of file RPCOccupancyTest.cc.

References globalFolder_, totalActive_, and totalStrips_.

                                                         {
  edm::LogVerbatim ("rpceventsummary") << "[RPCOccupancyTest]: Begin job ";
  globalFolder_ =  workingFolder;
 
  totalStrips_ = 0.;
  totalActive_ = 0.;   
 }

void RPCOccupancyTest::clientOperation ( )

overridevirtual

Implements RPCClient.

Definition at line 52 of file RPCOccupancyTest.cc.

References Active_Dead, Active_Fraction, fillGlobalME(), mps_fire::i, myDetIds_, myOccupancyMe_, MonitorElement::setBinContent(), totalActive_, and totalStrips_.

                                        {
 
   edm::LogVerbatim ("rpceventsummary") <<"[RPCOccupancyTest]: Client Operation";
 
  //Loop on MEs
   for (unsigned int  i = 0 ; i<myOccupancyMe_.size();i++){
     this->fillGlobalME(myDetIds_[i],myOccupancyMe_[i]);
   }//End loop on MEs
 
   //Active Channels
   if(Active_Fraction && totalStrips_!=0.){    
     Active_Fraction->setBinContent(1, (totalActive_/totalStrips_));
   }
   if(Active_Dead){    
     Active_Dead->setBinContent( 1, totalActive_ );
     Active_Dead->setBinContent( 2, (totalStrips_ - totalActive_ ));
   }
 
 }

void RPCOccupancyTest::fillGlobalME	(	RPCDetId &	detId,
		MonitorElement *	myMe
	)

protected

Definition at line 168 of file RPCOccupancyTest.cc.

References AsyMeDisk, AsyMeWheel, Barrel_OccBySt, rpcdqm::utils::detId2RollNr(), EndCap_OccByRng, MonitorElement::Fill(), HcalObjRepresent::Fill(), objects.autophobj::float, MonitorElement::getBinContent(), MonitorElement::getEntries(), MonitorElement::getNbinsX(), NormOccupDDisk, NormOccupDisk, NormOccupDWheel, NormOccupWheel, numberOfDisks_, numberOfRings_, RPCDetId::region(), RPCDetId::ring(), RPCDetId::roll(), rpcevents_, RPCDetId::sector(), RPCGeomServ::segment(), MonitorElement::setBinContent(), RPCDetId::station(), digitizers_cfi::strip, totalActive_, totalStrips_, useNormalization_, and cuy::yBin.

Referenced by clientOperation().

                                                                           {
   
 
 if (!myMe) return;
     
     MonitorElement * AsyMe=nullptr;      //Left Right Asymetry 
     MonitorElement * NormOccup=nullptr;
     MonitorElement * NormOccupD=nullptr;
        
     if(detId.region() ==0){
       AsyMe= AsyMeWheel[detId.ring()+2];
       if(useNormalization_){
     NormOccup=NormOccupWheel[detId.ring()+2];
     NormOccupD=NormOccupDWheel[detId.ring()+2];
       }
 
     }else{
 
       if( -detId.station() +  numberOfDisks_ >= 0 ){
     
     if(detId.region()<0){
       AsyMe= AsyMeDisk[-detId.station()  + numberOfDisks_];
       if(useNormalization_){
         NormOccup=NormOccupDisk[-detId.station() + numberOfDisks_];
         NormOccupD=NormOccupDDisk[-detId.station() + numberOfDisks_];
       }
     }else{
       AsyMe= AsyMeDisk[detId.station() + numberOfDisks_-1];
       if(useNormalization_){
         NormOccup=NormOccupDisk[detId.station() + numberOfDisks_-1];
         NormOccupD=NormOccupDDisk[detId.station() + numberOfDisks_-1];
       }
     }
       }
     }
 
  
     int xBin,yBin;
     if(detId.region()==0){//Barrel
       xBin= detId.sector();
       rpcdqm::utils rollNumber;
       yBin = rollNumber.detId2RollNr(detId);
     }else{//Endcap
       //get segment number
       RPCGeomServ RPCServ(detId);
       xBin = RPCServ.segment();
       (numberOfRings_ == 3 ? yBin= detId.ring()*3-detId.roll()+1 : yBin= (detId.ring()-1)*3-detId.roll()+1);
     }
     
     
     int stripInRoll=myMe->getNbinsX();
     totalStrips_ += (float)stripInRoll;
     float FOccupancy=0;
     float BOccupancy=0;
     
     float  totEnt =  myMe->getEntries();
     for(int strip = 1 ; strip<=stripInRoll; strip++){
       float stripEntries = myMe->getBinContent(strip);
       if(stripEntries > 0) {totalActive_++;}
       if(strip<=stripInRoll/2) {FOccupancy+=myMe->getBinContent(strip);}
       else  {BOccupancy+=myMe->getBinContent(strip);}
     }
         
 
     float asym = 0;
     if(totEnt != 0 ) asym =  fabs((FOccupancy - BOccupancy )/totEnt);
     
     if(AsyMe)  AsyMe->setBinContent(xBin,yBin,asym);
 
 
     
     float normoccup = 1;
     if(rpcevents_ != 0){ normoccup = (totEnt/rpcevents_);}
    
     if(useNormalization_){
       if(NormOccup)  NormOccup->setBinContent(xBin,yBin, normoccup);
       if(NormOccupD) NormOccupD->Fill(normoccup);
     }    
    
 
     if(detId.region()==0) {
       if(Barrel_OccBySt)Barrel_OccBySt -> Fill(detId.station(), normoccup);
     }else if(detId.region()==1) {
       if(detId.ring()==3) {
     EndCap_OccByRng -> Fill(1, normoccup);
       } else {
     EndCap_OccByRng -> Fill(2, normoccup);
       }
     } else {
       if(detId.ring()==3) {
     EndCap_OccByRng -> Fill(4, normoccup);
       }else {
     EndCap_OccByRng -> Fill(3, normoccup);
       }
     }
 
 }

void RPCOccupancyTest::getMonitorElements	(	std::vector< MonitorElement * > &	meVector,
		std::vector< RPCDetId > &	detIdVector,
		std::string &	clientHistoName
	)

overridevirtual

Implements RPCClient.

Definition at line 39 of file RPCOccupancyTest.cc.

References mps_fire::i, myDetIds_, myOccupancyMe_, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                                                                {
   //Get NumberOfDigi ME for each roll
   for(unsigned int i = 0 ; i<meVector.size(); i++){
     
     std::string meName =  meVector[i]->getName();
 
     if(meName.find(clientHistoName) != std::string::npos){
       myOccupancyMe_.push_back(meVector[i]);
       myDetIds_.push_back(detIdVector[i]);
     }
   }
 }

void RPCOccupancyTest::myBooker ( DQMStore::IBooker & ibooker )

overridevirtual

Implements RPCClient.

Definition at line 73 of file RPCOccupancyTest.cc.

References Active_Dead, Active_Fraction, AsyMeDisk, AsyMeWheel, Barrel_OccBySt, DQMStore::IBooker::book1D(), DQMStore::IBooker::book2D(), edmIntegrityCheck::d, EndCap_OccByRng, globalFolder_, rpcdqm::utils::labelXAxisSector(), rpcdqm::utils::labelXAxisSegment(), rpcdqm::utils::labelYAxisRing(), rpcdqm::utils::labelYAxisRoll(), NormOccupDDisk, NormOccupDisk, NormOccupDWheel, NormOccupWheel, numberOfDisks_, numberOfRings_, PFRecoTauDiscriminationByIsolation_cfi::offset, DQMStore::IBooker::setCurrentFolder(), useNormalization_, useRollInfo_, and w.

                                                         {
 
   ibooker.setCurrentFolder( globalFolder_);
   
   std::stringstream histoName;
   rpcdqm::utils rpcUtils;
   
   histoName.str("");
   histoName<<"RPC_Active_Channel_Fractions";
   Active_Fraction = ibooker.book1D(histoName.str().c_str(), histoName.str().c_str(),  1, 0.5, 1.5);
   Active_Fraction -> setBinLabel(1, "Active Fraction", 1);
 
   histoName.str("");
   histoName<<"RPC_Active_Inactive_Strips";
   Active_Dead = ibooker.book1D(histoName.str().c_str(), histoName.str().c_str(),  2, 0.5, 2.5);
   Active_Dead -> setBinLabel(1, "Active Strips", 1);
   Active_Dead -> setBinLabel(2, "Inactive Strips", 1);
 
   histoName.str("");
   histoName<<"Barrel_OccupancyByStations_Normalized";
   Barrel_OccBySt = ibooker.book1D(histoName.str().c_str(), histoName.str().c_str(),  4, 0.5, 4.5);
   Barrel_OccBySt -> setBinLabel(1, "St1", 1);
   Barrel_OccBySt -> setBinLabel(2, "St2", 1);
   Barrel_OccBySt -> setBinLabel(3, "St3", 1);
   Barrel_OccBySt -> setBinLabel(4, "St4", 1);
   
   
   histoName.str("");
   histoName<<"EndCap_OccupancyByRings_Normalized";
   EndCap_OccByRng = ibooker.book1D(histoName.str().c_str(), histoName.str().c_str(),  4, 0.5, 4.5);
   EndCap_OccByRng -> setBinLabel(1, "E+/R3", 1);
   EndCap_OccByRng -> setBinLabel(2, "E+/R2", 1);
   EndCap_OccByRng -> setBinLabel(3, "E-/R2", 1);
   EndCap_OccByRng -> setBinLabel(4, "E-/R3", 1);
   
  for (int w = -2; w<=2; w++ ){//loop on wheels
  
     histoName.str("");
     histoName<<"AsymmetryLeftRight_Roll_vs_Sector_Wheel"<<w;
     
     AsyMeWheel[w+2] = ibooker.book2D(histoName.str().c_str(), histoName.str().c_str(),  12, 0.5, 12.5, 21, 0.5, 21.5);
     
     rpcUtils.labelXAxisSector(AsyMeWheel[w+2]);
     rpcUtils.labelYAxisRoll(AsyMeWheel[w+2], 0, w,  useRollInfo_);
   
     
     if(useNormalization_){
   
       histoName.str("");
       histoName<<"OccupancyNormByEvents_Wheel"<<w;
       NormOccupWheel[w+2] = ibooker.book2D(histoName.str().c_str(), histoName.str().c_str(),  12, 0.5, 12.5, 21, 0.5, 21.5);
       
       rpcUtils.labelXAxisSector(  NormOccupWheel[w+2]);
       rpcUtils.labelYAxisRoll(  NormOccupWheel[w+2], 0, w,  useRollInfo_);
             
       histoName.str("");
       histoName<<"OccupancyNormByEvents_Distribution_Wheel"<<w;   
     
       NormOccupDWheel[w+2] = ibooker.book1D(histoName.str().c_str(), histoName.str().c_str(),  100, 0.0, 0.205);
     }
   }//end Barrel
   
   for(int d = -numberOfDisks_; d<=numberOfDisks_; d++ ){
 
     if (d == 0)continue;
     
     int offset = numberOfDisks_;
     if (d>0) offset --; //used to skip case equale to zero
     
     histoName.str("");
     histoName<<"AsymmetryLeftRight_Ring_vs_Segment_Disk"<<d;
     AsyMeDisk[d+offset] = ibooker.book2D(histoName.str().c_str(), histoName.str().c_str(), 36, 0.5, 36.5, 3*numberOfRings_, 0.5,3*numberOfRings_+ 0.5);
     
     rpcUtils.labelXAxisSegment(AsyMeDisk[d+offset]);
     rpcUtils.labelYAxisRing(AsyMeDisk[d+offset], numberOfRings_,  useRollInfo_);
     
    
     
     if(useNormalization_){
    
       histoName.str("");
       histoName<<"OccupancyNormByEvents_Disk"<<d;
       NormOccupDisk[d+offset] = ibooker.book2D(histoName.str().c_str(), histoName.str().c_str(), 36, 0.5, 36.5, 3*numberOfRings_, 0.5,3*numberOfRings_+ 0.5);
       
       rpcUtils.labelXAxisSegment(NormOccupDisk[d+offset]);
       rpcUtils.labelYAxisRing( NormOccupDisk[d+offset],numberOfRings_,  useRollInfo_);
       
       histoName.str("");
       histoName<<"OccupancyNormByEvents_Distribution_Disk"<<d;  
       NormOccupDDisk[d+offset] = ibooker.book1D(histoName.str().c_str(), histoName.str().c_str(),  100, 0.0, 0.205);
     }
   }//End loop on Endcap
 }