#include <RPCMultiplicityTest.h>

Inheritance diagram for RPCMultiplicityTest:

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

	RPCMultiplicityTest (const edm::ParameterSet &ps)
	Constructor. More...

	~RPCMultiplicityTest () override
	Destructor. More...

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

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

Private Attributes
std::string	globalFolder_

MonitorElement *	MULTDDisk [10]

MonitorElement *	MULTDisk [10]

MonitorElement *	MULTDWheel [5]

MonitorElement *	MULTWheel [5]

std::vector< RPCDetId >	myDetIds_

std::vector< MonitorElement * >	myNumDigiMe_

int	numberOfDisks_

int	numberOfRings_

int	prescaleFactor_

bool	testMode_

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 7 of file RPCMultiplicityTest.h.

Constructor & Destructor Documentation

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

Constructor.

Definition at line 16 of file RPCMultiplicityTest.cc.

References edm::ParameterSet::getUntrackedParameter(), numberOfDisks_, numberOfRings_, prescaleFactor_, testMode_, and useRollInfo_.

                                                                   {
   edm::LogVerbatim("multiplicity") << "[RPCMultiplicityTest]: Constructor";
   useRollInfo_ = ps.getUntrackedParameter<bool>("UseRollInfo", false);
   prescaleFactor_ = ps.getUntrackedParameter<int>("DiagnosticPrescale", 1);
   numberOfDisks_ = ps.getUntrackedParameter<int>("NumberOfEndcapDisks", 4);
   numberOfRings_ = ps.getUntrackedParameter<int>("NumberOfEndcapRings", 2);
   testMode_ = ps.getUntrackedParameter<bool>("testMode", false);
 }

RPCMultiplicityTest::~RPCMultiplicityTest ( )

override

Destructor.

Definition at line 25 of file RPCMultiplicityTest.cc.

25 {}

Member Function Documentation

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

overridevirtual

Implements RPCClient.

Definition at line 27 of file RPCMultiplicityTest.cc.

References globalFolder_.

                                                            {
   edm::LogVerbatim("multiplicity") << "[RPCMultiplicityTest]: Begin job";
   globalFolder_ = workingFolder;
 }

void RPCMultiplicityTest::clientOperation ( )

overridevirtual

Implements RPCClient.

Definition at line 99 of file RPCMultiplicityTest.cc.

References fillGlobalME(), mps_fire::i, myDetIds_, and myNumDigiMe_.

                                           {
   edm::LogVerbatim("multiplicity") << "[RPCMultiplicityTest]: Client Operation";
 
   //Loop on MEs
   for (unsigned int i = 0; i < myNumDigiMe_.size(); i++) {
     this->fillGlobalME(myDetIds_[i], myNumDigiMe_[i]);
   }  //End loop on MEs
 }

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

protected

Definition at line 108 of file RPCMultiplicityTest.cc.

References rpcdqm::utils::detId2RollNr(), dqm::impl::MonitorElement::Fill(), dqm::impl::MonitorElement::getMean(), SiStripPI::mean, MULTDDisk, MULTDisk, MULTDWheel, MULTWheel, numberOfDisks_, numberOfRings_, RPCDetId::region(), RPCDetId::ring(), RPCDetId::roll(), RPCDetId::sector(), RPCGeomServ::segment(), dqm::impl::MonitorElement::setBinContent(), RPCDetId::station(), testMode_, photonAnalyzer_cfi::xBin, and photonAnalyzer_cfi::yBin.

Referenced by clientOperation().

                                                                             {
   MonitorElement* MULT = nullptr;
   MonitorElement* MULTD = nullptr;
 
   if (detId.region() == 0) {
     MULT = MULTWheel[detId.ring() + 2];
     if (testMode_) {
       MULTD = MULTDWheel[detId.ring() + 2];
     }
   } else {
     if (-detId.station() + numberOfDisks_ >= 0) {
       if (detId.region() < 0) {
         MULT = MULTDisk[-detId.station() + numberOfDisks_];
         if (testMode_) {
           MULTD = MULTDDisk[-detId.station() + numberOfDisks_];
         }
       } else {
         MULT = MULTDisk[detId.station() + numberOfDisks_ - 1];
         if (testMode_) {
           MULTD = MULTDDisk[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);
   }
 
   float mean = myMe->getMean();
 
   if (MULT) {
     MULT->setBinContent(xBin, yBin, mean);
   }
   if (testMode_ && MULTD) {
     MULTD->Fill(mean);
   }
 }

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

overridevirtual

Implements RPCClient.

Definition at line 85 of file RPCMultiplicityTest.cc.

References mps_fire::i, myDetIds_, myNumDigiMe_, 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) {
       myNumDigiMe_.push_back(meVector[i]);
       myDetIds_.push_back(detIdVector[i]);
     }
   }
 }

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

overridevirtual

Implements RPCClient.

Definition at line 32 of file RPCMultiplicityTest.cc.

References dqm::dqmstoreimpl::DQMStore::IBooker::book1D(), dqm::dqmstoreimpl::DQMStore::IBooker::book2D(), ztail::d, globalFolder_, HltBtagPostValidation_cff::histoName, mps_fire::i, rpcdqm::utils::labelXAxisSector(), rpcdqm::utils::labelXAxisSegment(), rpcdqm::utils::labelYAxisRing(), rpcdqm::utils::labelYAxisRoll(), MULTDDisk, MULTDisk, MULTDWheel, MULTWheel, numberOfDisks_, numberOfRings_, hltrates_dqm_sourceclient-live_cfg::offset, dqm::dqmstoreimpl::DQMStore::IBooker::setCurrentFolder(), testMode_, and useRollInfo_.

                                                            {
   ibooker.setCurrentFolder(globalFolder_);
 
   std::stringstream histoName;
   rpcdqm::utils rpcUtils;
 
   for (int i = -2; i <= 2; i++) {  //loop on wheels and disks
 
     histoName.str("");
     histoName << "NumberOfDigi_Mean_Roll_vs_Sector_Wheel" << i;
 
     MULTWheel[i + 2] = ibooker.book2D(histoName.str().c_str(), histoName.str().c_str(), 12, 0.5, 12.5, 21, 0.5, 21.5);
 
     rpcUtils.labelXAxisSector(MULTWheel[i + 2]);
     rpcUtils.labelYAxisRoll(MULTWheel[i + 2], 0, i, useRollInfo_);
 
     if (testMode_) {
       histoName.str("");
       histoName << "NumberOfDigi_Mean_Distribution_Wheel" << i;
       MULTDWheel[i + 2] = ibooker.book1D(histoName.str().c_str(), histoName.str().c_str(), 100, 0.5, 50.5);
     }
 
   }  //end wheels
 
   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 << "NumberOfDigi_Mean_Ring_vs_Segment_Disk" << d;
     MULTDisk[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(MULTDisk[d + offset]);
     rpcUtils.labelYAxisRing(MULTDisk[d + offset], numberOfRings_, useRollInfo_);
 
     if (testMode_) {
       histoName.str("");
       histoName << "NumberOfDigi_Mean_Distribution_Disk" << d;
       MULTDDisk[d + offset] = ibooker.book1D(histoName.str().c_str(), histoName.str().c_str(), 100, 0.5, 50.5);
     }
   }  //end loop on wheels and disks
 }