#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=default

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_

Additional Inherited Members
Public Types inherited from RPCClient
typedef dqm::harvesting::DQMStore	DQMStore

typedef dqm::harvesting::MonitorElement	MonitorElement

Detailed Description

Definition at line 12 of file RPCOccupancyTest.h.

Constructor & Destructor Documentation

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

Definition at line 11 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 ( )

overridedefault

Member Function Documentation

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

overridevirtual

Implements RPCClient.

Definition at line 26 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 48 of file RPCOccupancyTest.cc.

References Active_Dead, Active_Fraction, fillGlobalME(), mps_fire::i, myDetIds_, myOccupancyMe_, dqm::impl::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 106 of file RPCOccupancyTest.cc.

References AsyMeDisk, AsyMeWheel, rpcdqm::utils::detId2RollNr(), dqm::impl::MonitorElement::getBinContent(), dqm::impl::MonitorElement::getEntries(), dqm::impl::MonitorElement::getNbinsX(), numberOfDisks_, numberOfRings_, RPCDetId::region(), RPCDetId::ring(), RPCDetId::roll(), RPCDetId::sector(), RPCGeomServ::segment(), dqm::impl::MonitorElement::setBinContent(), RPCDetId::station(), digitizers_cfi::strip, totalActive_, totalStrips_, and cuy::yBin.

Referenced by clientOperation().

                                                                          {
   if (!myMe)
     return;
 
   MonitorElement* AsyMe = nullptr;  //Left Right Asymetry
 
   if (detId.region() == 0) {
     AsyMe = AsyMeWheel[detId.ring() + 2];
 
   } else {
     if (-detId.station() + numberOfDisks_ >= 0) {
       if (detId.region() < 0) {
         AsyMe = AsyMeDisk[-detId.station() + numberOfDisks_];
       } else {
         AsyMe = AsyMeDisk[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);
 }

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

overridevirtual

Implements RPCClient.

Definition at line 34 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 66 of file RPCOccupancyTest.cc.

References Active_Dead, Active_Fraction, AsyMeDisk, AsyMeWheel, dqm::implementation::IBooker::book1D(), RPCRollMapHisto::bookBarrel(), RPCRollMapHisto::bookEndcap(), ztail::d, globalFolder_, hlt_dqm_clientPB-live_cfg::me, numberOfDisks_, hltrates_dqm_sourceclient-live_cfg::offset, dqm::impl::MonitorElement::setBinLabel(), dqm::implementation::NavigatorBase::setCurrentFolder(), useRollInfo_, and w().

                                                         {
   ibooker.setCurrentFolder(globalFolder_);
 
   std::stringstream histoName;
 
   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);
 
   for (int w = -2; w <= 2; w++) {  //loop on wheels
 
     histoName.str("");
     histoName << "AsymmetryLeftRight_Roll_vs_Sector_Wheel" << w;
 
     auto me = RPCRollMapHisto::bookBarrel(ibooker, w, histoName.str(), histoName.str(), useRollInfo_);
     AsyMeWheel[w + 2] = dynamic_cast<MonitorElement*>(me);
   }  //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;
     auto me = RPCRollMapHisto::bookEndcap(ibooker, d, histoName.str(), histoName.str(), useRollInfo_);
     AsyMeDisk[d + offset] = dynamic_cast<MonitorElement*>(me);
   }  //End loop on Endcap
 }