RPCNoisyStripTest Class Reference

#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
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::RPCNoisyStripTest

(

const edm::ParameterSet &

ps

)

Definition at line 14 of file RPCNoisyStripTest.cc.

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

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

~RPCNoisyStripTest()

RPCNoisyStripTest::~RPCNoisyStripTest ( )

override

Definition at line 24 of file RPCNoisyStripTest.cc.

{}

Member Function Documentation

beginJob()

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

overridevirtual

Implements RPCClient.

Definition at line 26 of file RPCNoisyStripTest.cc.

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

References globalFolder_.

clientOperation()

void RPCNoisyStripTest::clientOperation ( )

overridevirtual

Implements RPCClient.

Definition at line 31 of file RPCNoisyStripTest.cc.

                                        {
  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
}

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

fillGlobalME()

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

protected

Definition at line 114 of file RPCNoisyStripTest.cc.

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

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

Referenced by clientOperation().

getMonitorElements()

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

overridevirtual

Implements RPCClient.

Definition at line 100 of file RPCNoisyStripTest.cc.

                                                                       {
  //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]);
    }
  }
}

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

myBooker()

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

overridevirtual

Implements RPCClient.

Definition at line 40 of file RPCNoisyStripTest.cc.

                                                         {
  ibooker.setCurrentFolder(globalFolder_);
 
  std::stringstream histoName;
 
  rpcdqm::utils rpcUtils;
 
  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;
    NOISEWheel[w + 2] = ibooker.book2D(histoName.str().c_str(), histoName.str().c_str(), 12, 0.5, 12.5, 21, 0.5, 21.5);
    rpcUtils.labelXAxisSector(NOISEWheel[w + 2]);
    rpcUtils.labelYAxisRoll(NOISEWheel[w + 2], 0, w, useRollInfo_);
  }
 
  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;
    NOISEDisk[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(NOISEDisk[d + offset]);
    rpcUtils.labelYAxisRing(NOISEDisk[d + offset], numberOfRings_, useRollInfo_);
  }
}

References dqm::implementation::IBooker::book1D(), dqm::implementation::IBooker::book2D(), ztail::d, DEVDDisk, DEVDWheel, globalFolder_, HltBtagPostValidation_cff::histoName, rpcdqm::utils::labelXAxisSector(), rpcdqm::utils::labelXAxisSegment(), rpcdqm::utils::labelYAxisRing(), rpcdqm::utils::labelYAxisRoll(), NOISEDDisk, NOISEDisk, NOISEDWheel, NOISEWheel, numberOfDisks_, numberOfRings_, hltrates_dqm_sourceclient-live_cfg::offset, dqm::implementation::NavigatorBase::setCurrentFolder(), testMode_, useRollInfo_, and w.

Member Data Documentation

DEVDDisk

MonitorElement* RPCNoisyStripTest::DEVDDisk[10]

private

Definition at line 35 of file RPCNoisyStripTest.h.

Referenced by fillGlobalME(), and myBooker().

DEVDWheel

MonitorElement* RPCNoisyStripTest::DEVDWheel[5]

private

Definition at line 31 of file RPCNoisyStripTest.h.

Referenced by fillGlobalME(), and myBooker().

globalFolder_

std::string RPCNoisyStripTest::globalFolder_

private

Definition at line 21 of file RPCNoisyStripTest.h.

Referenced by beginJob(), and myBooker().

myDetIds_

std::vector<RPCDetId> RPCNoisyStripTest::myDetIds_

private

Definition at line 27 of file RPCNoisyStripTest.h.

Referenced by clientOperation(), and getMonitorElements().

myOccupancyMe_

std::vector<MonitorElement *> RPCNoisyStripTest::myOccupancyMe_

private

Definition at line 26 of file RPCNoisyStripTest.h.

Referenced by clientOperation(), and getMonitorElements().

NOISEDDisk

MonitorElement* RPCNoisyStripTest::NOISEDDisk[10]

private

Definition at line 34 of file RPCNoisyStripTest.h.

Referenced by fillGlobalME(), and myBooker().

NOISEDisk

MonitorElement* RPCNoisyStripTest::NOISEDisk[10]

private

Definition at line 33 of file RPCNoisyStripTest.h.

Referenced by fillGlobalME(), and myBooker().

NOISEDWheel

MonitorElement* RPCNoisyStripTest::NOISEDWheel[5]

private

Definition at line 30 of file RPCNoisyStripTest.h.

Referenced by fillGlobalME(), and myBooker().

NOISEWheel

MonitorElement* RPCNoisyStripTest::NOISEWheel[5]

private

Definition at line 29 of file RPCNoisyStripTest.h.

Referenced by fillGlobalME(), and myBooker().

numberOfDisks_

int RPCNoisyStripTest::numberOfDisks_

private

Definition at line 36 of file RPCNoisyStripTest.h.

Referenced by fillGlobalME(), myBooker(), and RPCNoisyStripTest().

numberOfRings_

int RPCNoisyStripTest::numberOfRings_

private

Definition at line 22 of file RPCNoisyStripTest.h.

Referenced by fillGlobalME(), myBooker(), and RPCNoisyStripTest().

prescaleFactor_

int RPCNoisyStripTest::prescaleFactor_

private

Definition at line 23 of file RPCNoisyStripTest.h.

Referenced by RPCNoisyStripTest().

testMode_

bool RPCNoisyStripTest::testMode_

private

Definition at line 24 of file RPCNoisyStripTest.h.

Referenced by fillGlobalME(), myBooker(), and RPCNoisyStripTest().

useRollInfo_

bool RPCNoisyStripTest::useRollInfo_

private

Definition at line 28 of file RPCNoisyStripTest.h.

Referenced by myBooker(), and RPCNoisyStripTest().