RPCClusterSizeTest Class Reference

#include <RPCClusterSizeTest.h>

Inheritance diagram for RPCClusterSizeTest:

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
	RPCClusterSizeTest (const edm::ParameterSet &ps)
	Constructor. More...
	~RPCClusterSizeTest () override=default
	Destructor. More...
Public Member Functions inherited from RPCClient
virtual	~RPCClient (void)

Private Types
enum	MEArraySizes { kWheels = 5, kDisks = 10 }

Private Member Functions
void	resetMEArrays (void)

Private Attributes
MonitorElement *	CLSDDisk [kDisks]
MonitorElement *	CLSDisk [kDisks]
MonitorElement *	CLSDWheel [kWheels]
MonitorElement *	CLSWheel [kWheels]
std::string	globalFolder_
MonitorElement *	MEANDDisk [kDisks]
MonitorElement *	MEANDisk [kDisks]
MonitorElement *	MEANDWheel [kWheels]
MonitorElement *	MEANWheel [kWheels]
std::vector< MonitorElement * >	myClusterMe_
std::vector< RPCDetId >	myDetIds_
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 10 of file RPCClusterSizeTest.h.

Member Enumeration Documentation

enum RPCClusterSizeTest::MEArraySizes

private

Enumerator
kWheels
kDisks

Definition at line 31 of file RPCClusterSizeTest.h.

{ kWheels = 5, kDisks = 10 };

Constructor & Destructor Documentation

RPCClusterSizeTest::RPCClusterSizeTest

(

const edm::ParameterSet &

ps

)

Constructor.

Definition at line 8 of file RPCClusterSizeTest.cc.

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

                                                                {
  edm::LogVerbatim("rpceventsummary") << "[RPCClusterSizeTest]: Constructor";

  prescaleFactor_ = ps.getUntrackedParameter<int>("DiagnosticPrescale", 1);

  numberOfDisks_ = ps.getUntrackedParameter<int>("NumberOfEndcapDisks", 4);
  numberOfRings_ = ps.getUntrackedParameter<int>("NumberOfEndcapRings", 2);
  testMode_ = ps.getUntrackedParameter<bool>("testMode", false);
  useRollInfo_ = ps.getUntrackedParameter<bool>("useRollInfo", false);

  resetMEArrays();
}

RPCClusterSizeTest::~RPCClusterSizeTest ( )

overridedefault

Destructor.

Member Function Documentation

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

overridevirtual

Implements RPCClient.

Definition at line 21 of file RPCClusterSizeTest.cc.

References globalFolder_.

                                                          {
  edm::LogVerbatim("rpceventsummary") << "[RPCClusterSizeTest]: Begin job ";

  globalFolder_ = workingFolder;
}

void RPCClusterSizeTest::clientOperation ( )

overridevirtual

Implements RPCClient.

Definition at line 41 of file RPCClusterSizeTest.cc.

References CLSDDisk, CLSDisk, CLSDWheel, CLSWheel, rpcdqm::utils::detId2RollNr(), dqm::impl::MonitorElement::Fill(), dqm::impl::MonitorElement::getBinContent(), dqm::impl::MonitorElement::getEntries(), dqm::impl::MonitorElement::getMean(), mps_fire::i, PVValHelper::MEAN, MEANDDisk, MEANDisk, MEANDWheel, MEANWheel, myClusterMe_, myDetIds_, numberOfDisks_, numberOfRings_, RPCDetId::region(), RPCDetId::ring(), RPCDetId::roll(), RPCDetId::sector(), RPCGeomServ::segment(), dqm::impl::MonitorElement::setBinContent(), RPCDetId::station(), testMode_, and cuy::yBin.

                                         {
  edm::LogVerbatim("rpceventsummary") << "[RPCClusterSizeTest]:Client Operation";

  //check some statements and prescale Factor
  if (myClusterMe_.empty() || myDetIds_.empty())
    return;

  MonitorElement* CLS = nullptr;    // ClusterSize in 1 bin, Roll vs Sector
  MonitorElement* CLSD = nullptr;   // ClusterSize in 1 bin, Distribution
  MonitorElement* MEAN = nullptr;   // Mean ClusterSize, Roll vs Sector
  MonitorElement* MEAND = nullptr;  // Mean ClusterSize, Distribution

  std::stringstream meName;

  //Loop on chambers
  for (unsigned int i = 0; i < myClusterMe_.size(); ++i) {
    MonitorElement* myMe = myClusterMe_[i];
    if (!myMe || myMe->getEntries() == 0)
      continue;

    const RPCDetId& detId = myDetIds_[i];

    if (detId.region() == 0) {
      CLS = CLSWheel[detId.ring() + 2];
      MEAN = MEANWheel[detId.ring() + 2];
      if (testMode_) {
        CLSD = CLSDWheel[detId.ring() + 2];
        MEAND = MEANDWheel[detId.ring() + 2];
      }
    } else {
      if (((detId.station() * detId.region()) + numberOfDisks_) >= 0) {
        if (detId.region() < 0) {
          CLS = CLSDisk[(detId.station() * detId.region()) + numberOfDisks_];
          MEAN = MEANDisk[(detId.station() * detId.region()) + numberOfDisks_];
          if (testMode_) {
            CLSD = CLSDDisk[(detId.station() * detId.region()) + numberOfDisks_];
            MEAND = MEANDDisk[(detId.station() * detId.region()) + numberOfDisks_];
          }
        } else {
          CLS = CLSDisk[(detId.station() * detId.region()) + numberOfDisks_ - 1];
          MEAN = MEANDisk[(detId.station() * detId.region()) + numberOfDisks_ - 1];
          if (testMode_) {
            CLSD = CLSDDisk[(detId.station() * detId.region()) + numberOfDisks_ - 1];
            MEAND = MEANDDisk[(detId.station() * detId.region()) + numberOfDisks_ - 1];
          }
        }
      }
    }

    int xBin = 0, yBin = 0;

    if (detId.region() == 0) {  //Barrel

      rpcdqm::utils rollNumber;
      yBin = rollNumber.detId2RollNr(detId);
      xBin = detId.sector();
    } 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);
    }

    // Normalization -> # of Entries in first Bin normalaized by total Entries
    const float NormCLS = myMe->getBinContent(1) / myMe->getEntries();
    const float meanCLS = myMe->getMean();

    if (CLS)
      CLS->setBinContent(xBin, yBin, NormCLS);
    if (MEAN)
      MEAN->setBinContent(xBin, yBin, meanCLS);

    if (testMode_) {
      if (MEAND)
        MEAND->Fill(meanCLS);
      if (CLSD)
        CLSD->Fill(NormCLS);
    }

  }  //End loop on chambers
}

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

overridevirtual

Implements RPCClient.

Definition at line 27 of file RPCClusterSizeTest.cc.

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

                                                                        {
  //Get  ME for each roll
  for (unsigned int i = 0; i < meVector.size(); i++) {
    const std::string& meName = meVector[i]->getName();

    if (meName.find(clientHistoName) != std::string::npos) {
      myClusterMe_.push_back(meVector[i]);
      myDetIds_.push_back(detIdVector[i]);
    }
  }
}

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

overridevirtual

Implements RPCClient.

Definition at line 137 of file RPCClusterSizeTest.cc.

References dqm::implementation::IBooker::book1D(), RPCRollMapHisto::bookBarrel(), RPCRollMapHisto::bookEndcap(), CLSDDisk, CLSDisk, CLSDWheel, CLSWheel, ztail::d, globalFolder_, hlt_dqm_clientPB-live_cfg::me, MEANDDisk, MEANDisk, MEANDWheel, MEANWheel, numberOfDisks_, hltrates_dqm_sourceclient-live_cfg::offset, resetMEArrays(), dqm::implementation::NavigatorBase::setCurrentFolder(), testMode_, useRollInfo_, and w().

                                                          {
  resetMEArrays();

  ibooker.setCurrentFolder(globalFolder_);

  std::stringstream histoName;

  rpcdqm::utils rpcUtils;

  // Loop over wheels
  for (int w = -2; w <= 2; w++) {
    histoName.str("");
    histoName << "ClusterSizeIn1Bin_Roll_vs_Sector_Wheel"
              << w;  // ClusterSize in first bin norm. by Entries (2D Roll vs Sector)
    auto me = RPCRollMapHisto::bookBarrel(ibooker, w, histoName.str(), histoName.str(), useRollInfo_);
    CLSWheel[w + 2] = dynamic_cast<MonitorElement*>(me);

    histoName.str("");
    histoName << "ClusterSizeMean_Roll_vs_Sector_Wheel" << w;  // Avarage ClusterSize (2D Roll vs Sector)
    me = RPCRollMapHisto::bookBarrel(ibooker, w, histoName.str(), histoName.str(), useRollInfo_);
    MEANWheel[w + 2] = dynamic_cast<MonitorElement*>(me);

    if (testMode_) {
      histoName.str("");
      histoName << "ClusterSizeIn1Bin_Distribution_Wheel" << w;  //  ClusterSize in first bin, distribution
      CLSDWheel[w + 2] = ibooker.book1D(histoName.str().c_str(), histoName.str().c_str(), 20, 0.0, 1.0);

      histoName.str("");
      histoName << "ClusterSizeMean_Distribution_Wheel" << w;  //  Avarage ClusterSize Distribution
      MEANDWheel[w + 2] = ibooker.book1D(histoName.str().c_str(), histoName.str().c_str(), 100, 0.5, 10.5);
    }
  }  //end loop on wheels

  for (int d = -numberOfDisks_; d <= numberOfDisks_; d++) {
    if (d == 0)
      continue;
    //Endcap
    int offset = numberOfDisks_;
    if (d > 0)
      offset--;

    histoName.str("");
    histoName << "ClusterSizeIn1Bin_Ring_vs_Segment_Disk"
              << d;  // ClusterSize in first bin norm. by Entries (2D Roll vs Sector)
    auto me = RPCRollMapHisto::bookEndcap(ibooker, d, histoName.str(), histoName.str(), useRollInfo_);
    CLSDisk[d + offset] = dynamic_cast<MonitorElement*>(me);

    if (testMode_) {
      histoName.str("");
      histoName << "ClusterSizeIn1Bin_Distribution_Disk" << d;  //  ClusterSize in first bin, distribution
      CLSDDisk[d + offset] = ibooker.book1D(histoName.str().c_str(), histoName.str().c_str(), 20, 0.0, 1.0);

      histoName.str("");
      histoName << "ClusterSizeMean_Distribution_Disk" << d;  //  Avarage ClusterSize Distribution
      MEANDDisk[d + offset] = ibooker.book1D(histoName.str().c_str(), histoName.str().c_str(), 100, 0.5, 10.5);
    }

    histoName.str("");
    histoName << "ClusterSizeMean_Ring_vs_Segment_Disk" << d;  // Avarage ClusterSize (2D Roll vs Sector)
    me = RPCRollMapHisto::bookEndcap(ibooker, d, histoName.str(), histoName.str(), useRollInfo_);
    MEANDisk[d + offset] = dynamic_cast<MonitorElement*>(me);
  }
}

void RPCClusterSizeTest::resetMEArrays ( void  )

private

Definition at line 125 of file RPCClusterSizeTest.cc.

References CLSDDisk, CLSDisk, CLSDWheel, CLSWheel, kDisks, kWheels, MEANDDisk, MEANDisk, MEANDWheel, and MEANWheel.

Referenced by myBooker(), and RPCClusterSizeTest().

                                           {
  memset((void*)CLSWheel, 0, sizeof(MonitorElement*) * kWheels);
  memset((void*)CLSDWheel, 0, sizeof(MonitorElement*) * kWheels);
  memset((void*)MEANWheel, 0, sizeof(MonitorElement*) * kWheels);
  memset((void*)MEANDWheel, 0, sizeof(MonitorElement*) * kWheels);

  memset((void*)CLSDisk, 0, sizeof(MonitorElement*) * kDisks);
  memset((void*)CLSDDisk, 0, sizeof(MonitorElement*) * kDisks);
  memset((void*)MEANDisk, 0, sizeof(MonitorElement*) * kDisks);
  memset((void*)MEANDDisk, 0, sizeof(MonitorElement*) * kDisks);
}

Member Data Documentation

MonitorElement* RPCClusterSizeTest::CLSDDisk[kDisks]

private

Definition at line 39 of file RPCClusterSizeTest.h.

Referenced by clientOperation(), myBooker(), and resetMEArrays().

MonitorElement* RPCClusterSizeTest::CLSDisk[kDisks]

private

Definition at line 38 of file RPCClusterSizeTest.h.

Referenced by clientOperation(), myBooker(), and resetMEArrays().

MonitorElement* RPCClusterSizeTest::CLSDWheel[kWheels]

private

Definition at line 34 of file RPCClusterSizeTest.h.

Referenced by clientOperation(), myBooker(), and resetMEArrays().

MonitorElement* RPCClusterSizeTest::CLSWheel[kWheels]

private

Definition at line 33 of file RPCClusterSizeTest.h.

Referenced by clientOperation(), myBooker(), and resetMEArrays().

std::string RPCClusterSizeTest::globalFolder_

private

Definition at line 23 of file RPCClusterSizeTest.h.

Referenced by beginJob(), and myBooker().

MonitorElement* RPCClusterSizeTest::MEANDDisk[kDisks]

private

Definition at line 41 of file RPCClusterSizeTest.h.

Referenced by clientOperation(), myBooker(), and resetMEArrays().

MonitorElement* RPCClusterSizeTest::MEANDisk[kDisks]

private

Definition at line 40 of file RPCClusterSizeTest.h.

Referenced by clientOperation(), myBooker(), and resetMEArrays().

MonitorElement* RPCClusterSizeTest::MEANDWheel[kWheels]

private

Definition at line 36 of file RPCClusterSizeTest.h.

Referenced by clientOperation(), myBooker(), and resetMEArrays().

MonitorElement* RPCClusterSizeTest::MEANWheel[kWheels]

private

Definition at line 35 of file RPCClusterSizeTest.h.

Referenced by clientOperation(), myBooker(), and resetMEArrays().

std::vector<MonitorElement *> RPCClusterSizeTest::myClusterMe_

private

Definition at line 29 of file RPCClusterSizeTest.h.

Referenced by clientOperation(), and getMonitorElements().

std::vector<RPCDetId> RPCClusterSizeTest::myDetIds_

private

Definition at line 30 of file RPCClusterSizeTest.h.

Referenced by clientOperation(), and getMonitorElements().

int RPCClusterSizeTest::numberOfDisks_

private

Definition at line 24 of file RPCClusterSizeTest.h.

Referenced by clientOperation(), myBooker(), and RPCClusterSizeTest().

int RPCClusterSizeTest::numberOfRings_

private

Definition at line 25 of file RPCClusterSizeTest.h.

Referenced by clientOperation(), and RPCClusterSizeTest().

int RPCClusterSizeTest::prescaleFactor_

private

Definition at line 26 of file RPCClusterSizeTest.h.

Referenced by RPCClusterSizeTest().

bool RPCClusterSizeTest::testMode_

private

Definition at line 27 of file RPCClusterSizeTest.h.

Referenced by clientOperation(), myBooker(), and RPCClusterSizeTest().

bool RPCClusterSizeTest::useRollInfo_

private

Definition at line 28 of file RPCClusterSizeTest.h.

Referenced by myBooker(), and RPCClusterSizeTest().