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
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.

{ kWheels = 5, kDisks = 10 };

Constructor & Destructor Documentation

RPCClusterSizeTest()

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", true);

  resetMEArrays();
}

~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.

References globalFolder_.

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

  globalFolder_ = workingFolder;
}

clientOperation()

void RPCClusterSizeTest::clientOperation ( )

overridevirtual

Implements RPCClient.

Definition at line 35 of file RPCClusterSizeTest.cc.

References haddnano::cl, dqm::impl::MonitorElement::Fill(), dqm-mbProfile::format, dqm::impl::MonitorElement::getBinContent(), dqm::impl::MonitorElement::getEntries(), dqm::impl::MonitorElement::getName(), dqm::impl::MonitorElement::getNbinsX(), dqm::impl::MonitorElement::getNbinsY(), h, mps_fire::i, PVValHelper::MEAN, MEANDDisk, MEANDisk, MEANDWheel, MEANWheel, myClusterMe_, hlt_dqm_clientPB-live_cfg::nbinsX, numberOfDisks_, numberOfRings_, HLT_2022v12_cff::region, relativeConstraints::ring, AlCaHLTBitMon_QueryRunRegistry::string, testMode_, makeMuonMisalignmentScenario::wheel, photonAnalyzer_cfi::xBin, and photonAnalyzer_cfi::yBin.

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

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

  MonitorElement* MEAN = nullptr;   // Mean ClusterSize, Roll vs Sector
  MonitorElement* MEAND = nullptr;  // Mean ClusterSize, Distribution

  //Loop on summary histograms
  for (unsigned int i = 0; i < myClusterMe_.size(); ++i) {
    MonitorElement* myMe = myClusterMe_[i];
    if (!myMe || myMe->getEntries() == 0)
      continue;
    std::string meName = myMe->getName();

    int xBin = 0, yBin = 0;
    float meanCLS = 0.;

    //Barrel
    for (int wheel = -2; wheel <= 2; wheel++) {
      for (int sector = 1; sector <= 12; sector++) {
        std::string tmpName = fmt::format("ClusterSize_Wheel_{}_Sector_{}", wheel, sector);

        if (tmpName == meName) {
          MEAN = MEANWheel[wheel + 2];
          if (testMode_) {
            MEAND = MEANDWheel[wheel + 2];
          }

          xBin = sector;
          for (int yBin_ = 1; yBin_ <= myMe->getNbinsY(); yBin_++) {
            int nbinsX = myMe->getNbinsX() - 1;  //Exclude overflow
            TH1F* h = new TH1F("h", "h", nbinsX, 0.5, 0.5 + nbinsX);
            for (int xBin_ = 1; xBin_ <= nbinsX; xBin_++) {
              int cl = myMe->getBinContent(xBin_, yBin_);
              h->SetBinContent(xBin_, cl);
            }
            yBin = yBin_;

            meanCLS = h->GetMean();

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

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

    //Endcap
    const std::array<std::string, 4> chNames = {{"CH01-CH09", "CH10-CH18", "CH19-CH27", "CH28-CH36"}};

    for (int region = -1; region <= 1; region++) {
      if (region == 0)
        continue;

      for (int disk = 1; disk <= numberOfDisks_; disk++) {
        for (int ring = 2; ring < numberOfRings_ + 2; ring++) {
          for (unsigned int ich = 0; ich < chNames.size(); ich++) {
            std::string tmpName = fmt::format("ClusterSize_Disk_{}_Ring_{}_{}", (region * disk), ring, chNames[ich]);

            if (tmpName == meName) {
              xBin = (ich * 9);

              if (((disk * region) + numberOfDisks_) >= 0) {
                if (region < 0) {
                  MEAN = MEANDisk[(disk * region) + numberOfDisks_];
                  if (testMode_) {
                    MEAND = MEANDDisk[(disk * region) + numberOfDisks_];
                  }
                } else {
                  MEAN = MEANDisk[(disk * region) + numberOfDisks_ - 1];
                  if (testMode_) {
                    MEAND = MEANDDisk[(disk * region) + numberOfDisks_ - 1];
                  }
                }
              }

              for (int yBin_ = 1; yBin_ <= myMe->getNbinsY(); yBin_++) {
                int nbinsX = myMe->getNbinsX() - 1;  //Exclude overflow
                TH1F* h = new TH1F("h", "h", nbinsX, 0.5, 0.5 + nbinsX);
                for (int xBin_ = 1; xBin_ <= nbinsX; xBin_++) {
                  int cl = myMe->getBinContent(xBin_, yBin_);
                  h->SetBinContent(xBin_, cl);
                }

                yBin = yBin_ - (3 * ((yBin_ - 1) / 3)) + (3 * (ring - 2));
                if (yBin % 3 == 1)
                  xBin++;

                meanCLS = h->GetMean();

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

                if (testMode_) {
                  if (MEAND)
                    MEAND->Fill(meanCLS);
                }
              }
            }  //name check
          }
        }
      }
    }
  }  //End loop on chambers
}

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.

References mps_fire::i, and myClusterMe_.

                                                                        {
  //Get  ME for each roll
  for (unsigned int i = 0; i < meVector.size(); i++)
    myClusterMe_.push_back(meVector[i]);
}

myBooker()

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

overridevirtual

Implements RPCClient.

Definition at line 157 of file RPCClusterSizeTest.cc.

References dqm::implementation::IBooker::book1D(), RPCRollMapHisto::bookBarrel(), RPCRollMapHisto::bookEndcap(), 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();

  ibooker.setCurrentFolder(globalFolder_);

  std::stringstream histoName;

  rpcdqm::utils rpcUtils;

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

    if (testMode_) {
      histoName.str("");
      histoName << "ClusterSizeMean_Distribution_Wheel" << w;  //  Avarage ClusterSize Distribution
      MEANDWheel[w + 2] = ibooker.book1D(histoName.str().c_str(), histoName.str().c_str(), 100, 1, 11);
    }
  }  //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 << "ClusterSizeMean_Ring_vs_Segment_Disk" << d;  // Avarage ClusterSize (2D Roll vs Sector)
    auto me = RPCRollMapHisto::bookEndcap(ibooker, d, histoName.str(), histoName.str(), useRollInfo_);
    MEANDisk[d + offset] = dynamic_cast<MonitorElement*>(me);

    if (testMode_) {
      histoName.str("");
      histoName << "ClusterSizeMean_Distribution_Disk" << d;  //  Avarage ClusterSize Distribution
      MEANDDisk[d + offset] = ibooker.book1D(histoName.str().c_str(), histoName.str().c_str(), 100, 1, 11);
    }
  }
}

resetMEArrays()

void RPCClusterSizeTest::resetMEArrays ( void  )

private

Definition at line 149 of file RPCClusterSizeTest.cc.

References kDisks, kWheels, MEANDDisk, MEANDisk, MEANDWheel, and MEANWheel.

Referenced by myBooker(), and RPCClusterSizeTest().

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

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

Member Data Documentation

globalFolder_

std::string RPCClusterSizeTest::globalFolder_

private

Definition at line 23 of file RPCClusterSizeTest.h.

Referenced by beginJob(), and myBooker().

MEANDDisk

MonitorElement* RPCClusterSizeTest::MEANDDisk[kDisks]

private

Definition at line 37 of file RPCClusterSizeTest.h.

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

MEANDisk

MonitorElement* RPCClusterSizeTest::MEANDisk[kDisks]

private

Definition at line 36 of file RPCClusterSizeTest.h.

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

MEANDWheel

MonitorElement* RPCClusterSizeTest::MEANDWheel[kWheels]

private

Definition at line 34 of file RPCClusterSizeTest.h.

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

MEANWheel

MonitorElement* RPCClusterSizeTest::MEANWheel[kWheels]

private

Definition at line 33 of file RPCClusterSizeTest.h.

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

myClusterMe_

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

private

Definition at line 29 of file RPCClusterSizeTest.h.

Referenced by clientOperation(), and getMonitorElements().

myDetIds_

std::vector<RPCDetId> RPCClusterSizeTest::myDetIds_

private

Definition at line 30 of file RPCClusterSizeTest.h.

numberOfDisks_

int RPCClusterSizeTest::numberOfDisks_

private

Definition at line 24 of file RPCClusterSizeTest.h.

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

numberOfRings_

int RPCClusterSizeTest::numberOfRings_

private

Definition at line 25 of file RPCClusterSizeTest.h.

Referenced by clientOperation(), and RPCClusterSizeTest().

prescaleFactor_

int RPCClusterSizeTest::prescaleFactor_

private

Definition at line 26 of file RPCClusterSizeTest.h.

Referenced by RPCClusterSizeTest().

testMode_

bool RPCClusterSizeTest::testMode_

private

Definition at line 27 of file RPCClusterSizeTest.h.

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

useRollInfo_

bool RPCClusterSizeTest::useRollInfo_

private

Definition at line 28 of file RPCClusterSizeTest.h.

Referenced by myBooker(), and RPCClusterSizeTest().