#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

◆ MEArraySizes

enum RPCClusterSizeTest::MEArraySizes

private

Enumerator
kWheels
kDisks

Definition at line 31 of file RPCClusterSizeTest.h.

31 { kWheels = 5, kDisks = 10 };

Constructor & Destructor Documentation

◆ RPCClusterSizeTest()

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

Constructor.

Definition at line 8 of file RPCClusterSizeTest.cc.

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

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

◆ ~RPCClusterSizeTest()

RPCClusterSizeTest::~RPCClusterSizeTest ( )

overridedefault

Destructor.

Member Function Documentation

◆ beginJob()

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

overridevirtual

Implements RPCClient.

Definition at line 21 of file RPCClusterSizeTest.cc.

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

References globalFolder_.

◆ clientOperation()

void RPCClusterSizeTest::clientOperation ( )

overridevirtual

Implements RPCClient.

Definition at line 41 of file RPCClusterSizeTest.cc.

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

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_, photonAnalyzer_cfi::xBin, and photonAnalyzer_cfi::yBin.

◆ getMonitorElements()

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.

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

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

◆ myBooker()

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

overridevirtual

Implements RPCClient.

Definition at line 137 of file RPCClusterSizeTest.cc.

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

References dqm::implementation::IBooker::book1D(), RPCRollMapHisto::bookBarrel(), RPCRollMapHisto::bookEndcap(), CLSDDisk, CLSDisk, CLSDWheel, CLSWheel, ztail::d, globalFolder_, HltBtagPostValidation_cff::histoName, 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()

void RPCClusterSizeTest::resetMEArrays ( void )

private

Definition at line 125 of file RPCClusterSizeTest.cc.

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