RPCOccupancyTest Class Reference

#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_

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::RPCOccupancyTest

(

const edm::ParameterSet &

ps

)

Definition at line 12 of file RPCOccupancyTest.cc.

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

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

~RPCOccupancyTest()

RPCOccupancyTest::~RPCOccupancyTest ( )

override

Definition at line 27 of file RPCOccupancyTest.cc.

{}

Member Function Documentation

beginJob()

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

overridevirtual

Implements RPCClient.

Definition at line 29 of file RPCOccupancyTest.cc.

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

References globalFolder_, totalActive_, and totalStrips_.

clientOperation()

void RPCOccupancyTest::clientOperation ( )

overridevirtual

Implements RPCClient.

Definition at line 51 of file RPCOccupancyTest.cc.

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

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

fillGlobalME()

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

protected

Definition at line 123 of file RPCOccupancyTest.cc.

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

References AsyMeDisk, AsyMeWheel, rpcdqm::utils::detId2RollNr(), dqmMemoryStats::float, 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_, photonAnalyzer_cfi::xBin, and photonAnalyzer_cfi::yBin.

Referenced by clientOperation().

getMonitorElements()

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

overridevirtual

Implements RPCClient.

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

overridevirtual

Implements RPCClient.

Definition at line 69 of file RPCOccupancyTest.cc.

                                                        {
  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);
 
  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_);
 
  }  //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_);
 
  }  //End loop on Endcap
}

References Active_Dead, Active_Fraction, AsyMeDisk, AsyMeWheel, dqm::implementation::IBooker::book1D(), dqm::implementation::IBooker::book2D(), ztail::d, globalFolder_, HltBtagPostValidation_cff::histoName, rpcdqm::utils::labelXAxisSector(), rpcdqm::utils::labelXAxisSegment(), rpcdqm::utils::labelYAxisRing(), rpcdqm::utils::labelYAxisRoll(), numberOfDisks_, numberOfRings_, hltrates_dqm_sourceclient-live_cfg::offset, dqm::impl::MonitorElement::setBinLabel(), dqm::implementation::NavigatorBase::setCurrentFolder(), useRollInfo_, and w.

Member Data Documentation

Active_Dead

MonitorElement* RPCOccupancyTest::Active_Dead

private

Definition at line 41 of file RPCOccupancyTest.h.

Referenced by clientOperation(), and myBooker().

Active_Fraction

MonitorElement* RPCOccupancyTest::Active_Fraction

private

Definition at line 40 of file RPCOccupancyTest.h.

Referenced by clientOperation(), and myBooker().

AsyMeDisk

MonitorElement* RPCOccupancyTest::AsyMeDisk[10]

private

Definition at line 47 of file RPCOccupancyTest.h.

Referenced by fillGlobalME(), and myBooker().

AsyMeWheel

MonitorElement* RPCOccupancyTest::AsyMeWheel[5]

private

Definition at line 43 of file RPCOccupancyTest.h.

Referenced by fillGlobalME(), and myBooker().

Barrel_OccBySt

MonitorElement* RPCOccupancyTest::Barrel_OccBySt

private

Definition at line 51 of file RPCOccupancyTest.h.

EndCap_OccByDisk

MonitorElement* RPCOccupancyTest::EndCap_OccByDisk

private

Definition at line 53 of file RPCOccupancyTest.h.

EndCap_OccByRng

MonitorElement* RPCOccupancyTest::EndCap_OccByRng

private

Definition at line 52 of file RPCOccupancyTest.h.

globalFolder_

std::string RPCOccupancyTest::globalFolder_

private

Definition at line 27 of file RPCOccupancyTest.h.

Referenced by beginJob(), and myBooker().

myDetIds_

std::vector<RPCDetId> RPCOccupancyTest::myDetIds_

private

Definition at line 31 of file RPCOccupancyTest.h.

Referenced by clientOperation(), and getMonitorElements().

myOccupancyMe_

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

private

Definition at line 30 of file RPCOccupancyTest.h.

Referenced by clientOperation(), and getMonitorElements().

NormOccupDDisk

MonitorElement* RPCOccupancyTest::NormOccupDDisk[10]

private

Definition at line 49 of file RPCOccupancyTest.h.

NormOccupDisk

MonitorElement* RPCOccupancyTest::NormOccupDisk[10]

private

Definition at line 48 of file RPCOccupancyTest.h.

NormOccupDWheel

MonitorElement* RPCOccupancyTest::NormOccupDWheel[5]

private

Definition at line 45 of file RPCOccupancyTest.h.

NormOccupWheel

MonitorElement* RPCOccupancyTest::NormOccupWheel[5]

private

Definition at line 44 of file RPCOccupancyTest.h.

numberOfDisks_

int RPCOccupancyTest::numberOfDisks_

private

Definition at line 36 of file RPCOccupancyTest.h.

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

numberOfRings_

int RPCOccupancyTest::numberOfRings_

private

Definition at line 36 of file RPCOccupancyTest.h.

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

prefixDir_

std::string RPCOccupancyTest::prefixDir_

private

Definition at line 27 of file RPCOccupancyTest.h.

Referenced by RPCOccupancyTest().

prescaleFactor_

int RPCOccupancyTest::prescaleFactor_

private

Definition at line 32 of file RPCOccupancyTest.h.

Referenced by RPCOccupancyTest().

rpcevents_

float RPCOccupancyTest::rpcevents_

private

Definition at line 38 of file RPCOccupancyTest.h.

totalActive_

float RPCOccupancyTest::totalActive_

private

Definition at line 34 of file RPCOccupancyTest.h.

Referenced by beginJob(), clientOperation(), and fillGlobalME().

totalStrips_

float RPCOccupancyTest::totalStrips_

private

Definition at line 34 of file RPCOccupancyTest.h.

Referenced by beginJob(), clientOperation(), and fillGlobalME().

useNormalization_

bool RPCOccupancyTest::useNormalization_

private

Definition at line 28 of file RPCOccupancyTest.h.

Referenced by RPCOccupancyTest().

useRollInfo_

bool RPCOccupancyTest::useRollInfo_

private

Definition at line 29 of file RPCOccupancyTest.h.

Referenced by myBooker(), and RPCOccupancyTest().