#include <RPCNoisyStripTest.h>

Inheritance diagram for RPCNoisyStripTest:

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

	RPCNoisyStripTest (const edm::ParameterSet &ps)

	~RPCNoisyStripTest () override=default

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

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

Private Attributes
MonitorElement *	DEVDDisk [10]

MonitorElement *	DEVDWheel [5]

std::string	globalFolder_

std::vector< RPCDetId >	myDetIds_

std::vector< MonitorElement * >	myOccupancyMe_

MonitorElement *	NOISEDDisk [10]

MonitorElement *	NOISEDisk [10]

MonitorElement *	NOISEDWheel [5]

MonitorElement *	NOISEWheel [5]

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

Constructor & Destructor Documentation

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

Definition at line 8 of file RPCNoisyStripTest.cc.

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

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

RPCNoisyStripTest::~RPCNoisyStripTest ( )

overridedefault

Member Function Documentation

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

overridevirtual

Implements RPCClient.

Definition at line 18 of file RPCNoisyStripTest.cc.

References globalFolder_.

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

void RPCNoisyStripTest::clientOperation ( )

overridevirtual

Implements RPCClient.

Definition at line 23 of file RPCNoisyStripTest.cc.

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

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

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

protected

Definition at line 95 of file RPCNoisyStripTest.cc.

References rpcdqm::utils::detId2RollNr(), DEVDDisk, DEVDWheel, dqm::impl::MonitorElement::Fill(), dqm::impl::MonitorElement::getBinContent(), dqm::impl::MonitorElement::getEntries(), dqm::impl::MonitorElement::getNbinsX(), mps_fire::i, sistrip::NOISE, NOISEDDisk, NOISEDisk, NOISEDWheel, NOISEWheel, numberOfDisks_, numberOfRings_, RPCDetId::region(), RPCDetId::ring(), RPCDetId::roll(), RPCDetId::sector(), RPCGeomServ::segment(), dqm::impl::MonitorElement::setBinContent(), RPCDetId::station(), testMode_, and cuy::yBin.

Referenced by clientOperation().

                                                                           {
   std::stringstream meName;
 
   MonitorElement* NOISE = nullptr;
   MonitorElement* DEVD = nullptr;
   MonitorElement* NOISED = nullptr;
 
   if (detId.region() == 0) {  //BARREL
     NOISE = NOISEWheel[detId.ring() + 2];
     if (testMode_) {
       DEVD = DEVDWheel[detId.ring() + 2];
       NOISED = NOISEDWheel[detId.ring() + 2];
     }
   } else if (detId.region() < 0 && (-detId.station() + numberOfDisks_) >= 0) {  //ENDCAP-
     NOISE = NOISEDisk[-detId.station() + numberOfDisks_];
     if (testMode_) {
       DEVD = DEVDDisk[-detId.station() + numberOfDisks_];
       NOISED = NOISEDDisk[-detId.station() + numberOfDisks_];
     }
   } else if ((-detId.station() + numberOfDisks_) >= 0) {  //ENDCAP +
     NOISE = NOISEDisk[detId.station() + numberOfDisks_ - 1];
     if (testMode_) {
       DEVD = DEVDDisk[detId.station() + numberOfDisks_ - 1];
       NOISED = NOISEDDisk[detId.station() + numberOfDisks_ - 1];
     }
   }
 
   int entries = (int)myMe->getEntries();
   int bins = (int)myMe->getNbinsX();
 
   std::vector<float> myvector;
 
   // count alive strips and alive strip values put in the vector
   for (int xbin = 1; xbin <= bins; xbin++) {
     float binContent = myMe->getBinContent(xbin);
     if (binContent > 0)
       myvector.push_back(binContent);
   }
 
   int noisyStrips = 0;
   // calculate mean on YAxis and check diff between bins and mean
   if (!myvector.empty()) {
     float ymean = entries / myvector.size();  //mean on Yaxis
     for (unsigned int i = 0; i < myvector.size(); i++) {
       float deviation = myvector[i] / ymean;
       if (deviation > 3.5)
         noisyStrips++;
       if (deviation > 5)
         deviation = 5;  //overflow
       if (DEVD)
         DEVD->Fill(deviation);
     }
 
     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);
     }
 
     if (NOISE)
       NOISE->setBinContent(xBin, yBin, noisyStrips);
     if (NOISED)
       NOISED->Fill(noisyStrips);
   }
 }

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

overridevirtual

Implements RPCClient.

Definition at line 81 of file RPCNoisyStripTest.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 RPCNoisyStripTest::myBooker ( DQMStore::IBooker & ibooker )

overridevirtual

Implements RPCClient.

Definition at line 32 of file RPCNoisyStripTest.cc.

References dqm::implementation::IBooker::book1D(), RPCRollMapHisto::bookBarrel(), RPCRollMapHisto::bookEndcap(), ztail::d, DEVDDisk, DEVDWheel, globalFolder_, hlt_dqm_clientPB-live_cfg::me, NOISEDDisk, NOISEDisk, NOISEDWheel, NOISEWheel, numberOfDisks_, hltrates_dqm_sourceclient-live_cfg::offset, dqm::implementation::NavigatorBase::setCurrentFolder(), testMode_, useRollInfo_, and w().

                                                          {
   ibooker.setCurrentFolder(globalFolder_);
 
   std::stringstream histoName;
 
   for (int w = -2; w <= 2; w++) {  //loop on wheels and disks
 
     if (testMode_) {
       histoName.str("");
       histoName << "RPCNoisyStrips_Distribution_Wheel" << w;
       NOISEDWheel[w + 2] = ibooker.book1D(histoName.str().c_str(), histoName.str().c_str(), 6, -0.5, 5.5);
 
       histoName.str("");
       histoName << "RPCStripsDeviation_Distribution_Wheel" << w;
       DEVDWheel[w + 2] = ibooker.book1D(histoName.str().c_str(), histoName.str().c_str(), 101, -0.01, 10.01);
     }
 
     histoName.str("");
     histoName << "RPCNoisyStrips_Roll_vs_Sector_Wheel" << w;
     auto me = RPCRollMapHisto::bookBarrel(ibooker, w, histoName.str(), histoName.str(), useRollInfo_);
     NOISEWheel[w + 2] = dynamic_cast<MonitorElement*>(me);
   }
 
   for (int d = -numberOfDisks_; d <= numberOfDisks_; d++) {  //ENDCAP
 
     if (d == 0)
       continue;
 
     int offset = numberOfDisks_;
     if (d > 0)
       offset--;
 
     if (testMode_) {
       histoName.str("");
       histoName << "RPCNoisyStrips_Distribution_Disk" << d;
       NOISEDDisk[d + offset] = ibooker.book1D(histoName.str().c_str(), histoName.str().c_str(), 6, -0.5, 5.5);
 
       histoName.str("");
       histoName << "RPCStripsDeviation_Distribution_Disk" << d;
       DEVDDisk[d + offset] = ibooker.book1D(histoName.str().c_str(), histoName.str().c_str(), 101, -0.01, 10.01);
     }
 
     histoName.str("");
     histoName << "RPCNoisyStrips_Ring_vs_Segment_Disk" << d;
     auto me = RPCRollMapHisto::bookEndcap(ibooker, d, histoName.str(), histoName.str(), useRollInfo_);
     NOISEDisk[d + offset] = dynamic_cast<MonitorElement*>(me);
   }
 }