RPCChamberQuality.cc

Go to the documentation of this file.

#include "DQM/RPCMonitorClient/interface/RPCChamberQuality.h"

#include "DQM/RPCMonitorClient/interface/RPCBookFolderStructure.h"
#include "DQM/RPCMonitorClient/interface/RPCRollMapHisto.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include <DataFormats/MuonDetId/interface/RPCDetId.h>

#include <fmt/format.h>

const std::string RPCChamberQuality::xLabels_[7] = {
    "Good", "OFF", "Nois.St", "Nois.Ch", "Part.Dead", "Dead", "Bad.Shape"};
const std::string RPCChamberQuality::regions_[3] = {"EndcapNegative", "Barrel", "EndcapPositive"};

RPCChamberQuality::RPCChamberQuality(const edm::ParameterSet& ps) {
  edm::LogVerbatim("rpcchamberquality") << "[RPCChamberQuality]: Constructor";

  prescaleFactor_ = ps.getUntrackedParameter<int>("PrescaleFactor", 5);

  std::string subsystemFolder = ps.getUntrackedParameter<std::string>("RPCFolder", "RPC");
  std::string recHitTypeFolder = ps.getUntrackedParameter<std::string>("RecHitTypeFolder", "AllHits");
  std::string summaryFolder = ps.getUntrackedParameter<std::string>("SummaryFolder", "SummaryHistograms");

  summaryDir_ = subsystemFolder + "/" + recHitTypeFolder + "/" + summaryFolder;
  prefixDir_ = subsystemFolder + "/" + recHitTypeFolder;

  enableDQMClients_ = ps.getUntrackedParameter<bool>("EnableRPCDqmClient", true);

  minEvents = ps.getUntrackedParameter<int>("MinimumRPCEvents", 10000);
  numberOfDisks_ = ps.getUntrackedParameter<int>("NumberOfEndcapDisks", 4);
  useRollInfo_ = ps.getUntrackedParameter<bool>("UseRollInfo", false);
  offlineDQM_ = ps.getUntrackedParameter<bool>("OfflineDQM", true);

  init_ = false;
  lumiCounter_ = 0;
}

RPCChamberQuality::~RPCChamberQuality() { edm::LogVerbatim("rpcchamberquality") << "[RPCChamberQuality]: Destructor "; }

void RPCChamberQuality::beginJob() { edm::LogVerbatim("rpcchamberquality") << "[RPCChamberQuality]: Begin job "; }

void RPCChamberQuality::dqmEndLuminosityBlock(DQMStore::IBooker& ibooker,
                                              DQMStore::IGetter& igetter,
                                              edm::LuminosityBlock const& iLumi,
                                              edm::EventSetup const& iSetup) {
  edm::LogVerbatim("rpcchamberquality") << "[RPCChamberQuality]: End Lumi Block";

  if (enableDQMClients_ && !offlineDQM_) {
    edm::LogVerbatim("rpcchamberquality") << "[RPCChamberQuality]: Performing DQM client operation";

    if (lumiCounter_ == 0) {  //book histograms during at firt LB end
      this->myBooker(ibooker);
      lumiCounter_ = prescaleFactor_;
    }

    if (lumiCounter_ % prescaleFactor_ == 0) {  //Fill histograms every N=prescaleFactor_ LBs
      this->fillMonitorElements(igetter);
    }
  }
  lumiCounter_++;
}

void RPCChamberQuality::dqmEndJob(DQMStore::IBooker& ibooker, DQMStore::IGetter& igetter) {
  edm::LogVerbatim("rpcchamberquality") << "[RPCChamberQuality]: End Job";

  if (enableDQMClients_) {
    edm::LogVerbatim("rpcchamberquality") << "[RPCChamberQuality]: Performing DQM client operation";
    if (offlineDQM_ && !init_) {
      this->myBooker(ibooker);
    }
    if (init_) {
      this->fillMonitorElements(igetter);
    }
  }
}

void RPCChamberQuality::myBooker(DQMStore::IBooker& ibooker) {
  init_ = true;

  ibooker.setCurrentFolder(summaryDir_);

  for (int r = 0; r < 3; r++) {
    const std::string histoName = fmt::format("RPCChamberQuality_{}", regions_[r]);
    MonitorElement* me = ibooker.book1D(histoName, histoName, 7, 0.5, 7.5);

    for (int x = 1; x < 8; x++) {
      me->setBinLabel(x, xLabels_[x - 1]);
    }
  }

  MonitorElement* me =
      ibooker.book2D("RPC_System_Quality_Overview", "RPC_System_Quality_Overview", 7, 0.5, 7.5, 3, 0.5, 3.5);
  me->setBinLabel(1, "E-", 2);
  me->setBinLabel(2, "B", 2);
  me->setBinLabel(3, "E+", 2);

  for (int x = 1; x < 8; x++) {
    me->setBinLabel(x, xLabels_[x - 1]);
  }

  for (int w = -2; w < 3; w++) {  //Loop on wheels

    const std::string histoName2D = fmt::format("RPCChamberQuality_Roll_vs_Sector_Wheel{}", w);
    RPCRollMapHisto::bookBarrel(ibooker, w, histoName2D, histoName2D, useRollInfo_);

    const std::string histoName1D = fmt::format("RPCChamberQuality_Distribution_Wheel{}", w);
    MonitorElement* me1D = ibooker.book1D(histoName1D, histoName1D, 7, 0.5, 7.5);

    for (int x = 1; x < 8; x++) {
      me1D->setBinLabel(x, xLabels_[x - 1]);
    }
  }  //end loop on wheels

  for (int d = -numberOfDisks_; d <= numberOfDisks_; d++) {  // Loop on disk
    if (d == 0)
      continue;
    const std::string histoName2D =
        fmt::format("RPCChamberQuality_Ring_vs_Segment_Disk{}", d);  //  2D histo for RPC Qtest
    RPCRollMapHisto::bookEndcap(ibooker, d, histoName2D, histoName2D, useRollInfo_);

    const std::string histoName1D = fmt::format("RPCChamberQuality_Distribution_Disk{}", d);
    MonitorElement* me1D = ibooker.book1D(histoName1D, histoName1D, 7, 0.5, 7.5);

    for (int x = 1; x < 8; x++) {
      me1D->setBinLabel(x, xLabels_[x - 1]);
    }
  }
}

void RPCChamberQuality::fillMonitorElements(DQMStore::IGetter& igetter) {
  int rpcEvents = minEvents;
  RpcEvents = igetter.get(prefixDir_ + "/RPCEvents");

  if (RpcEvents)
    rpcEvents = (int)RpcEvents->getBinContent(1);

  if (rpcEvents >= minEvents) {
    init_ = true;

    MonitorElement* summary[3];

    for (int r = 0; r < 3; r++) {
      const std::string meName = fmt::format("{}/RPCChamberQuality_{}", summaryDir_, RPCChamberQuality::regions_[r]);
      summary[r] = igetter.get(meName);

      if (summary[r] != nullptr)
        summary[r]->Reset();
    }

    //Barrel
    for (int wheel = -2; wheel < 3; wheel++) {  // loop by Wheels
      const std::string meName = fmt::format("Roll_vs_Sector_Wheel{}", wheel);

      this->performeClientOperation(meName, 0, summary[1], igetter);
    }  // loop by Wheels

    // Endcap
    for (int i = -numberOfDisks_; i <= numberOfDisks_; i++) {  //loop on Disks
      if (i == 0)
        continue;

      const std::string meName = fmt::format("Ring_vs_Segment_Disk{}", i);

      if (i < 0)
        this->performeClientOperation(meName, -1, summary[0], igetter);
      else
        this->performeClientOperation(meName, 1, summary[2], igetter);
    }  //loop on Disks

    MonitorElement* RpcOverview = igetter.get(summaryDir_ + "/RPC_System_Quality_Overview");
    RpcOverview->Reset();

    if (RpcOverview) {  //Fill Overview ME
      for (int r = 0; r < 3; r++) {
        if (summary[r] == nullptr)
          continue;
        const double entries = summary[r]->getEntries();
        if (entries == 0)
          continue;
        for (int x = 1; x <= 7; x++) {
          RpcOverview->setBinContent(x, r + 1, (summary[r]->getBinContent(x) / entries));
        }
      }
    }  //loop by LimiBloks
  }
}

void RPCChamberQuality::performeClientOperation(std::string MESufix,
                                                int region,
                                                MonitorElement* quality,
                                                DQMStore::IGetter& igetter) {
  MonitorElement* RCQ = igetter.get(summaryDir_ + "/RPCChamberQuality_" + MESufix);
  //  if (RCQ)  RCQ->Reset();

  const int pos = MESufix.find_last_of('_');
  MonitorElement* RCQD = igetter.get(summaryDir_ + "/RPCChamberQuality_Distribution" + MESufix.substr(pos));
  if (RCQD)
    RCQD->Reset();

  //get HV Histo
  MonitorElement* HV = igetter.get(summaryDir_ + "/HVStatus_" + MESufix);
  //get LV Histo
  MonitorElement* LV = igetter.get(summaryDir_ + "/LVStatus_" + MESufix);
  //Dead
  MonitorElement* DEAD = igetter.get(summaryDir_ + "/DeadChannelFraction_" + MESufix);
  //ClusterSize
  MonitorElement* CLS = igetter.get(summaryDir_ + "/ClusterSizeIn1Bin_" + MESufix);
  //NoisyStrips
  MonitorElement* NoisySt = igetter.get(summaryDir_ + "/RPCNoisyStrips_" + MESufix);
  //Multiplicity
  MonitorElement* MULT = igetter.get(summaryDir_ + "/NumberOfDigi_Mean_" + MESufix);
  //Asymetry
  MonitorElement* Chip = igetter.get(summaryDir_ + "/AsymmetryLeftRight_" + MESufix);

  int xBinMax, yBinMax;

  if (region != 0)
    xBinMax = 37;
  else
    xBinMax = 13;

  for (int x = 1; x < xBinMax; x++) {
    if (region != 0) {
      yBinMax = 7;
    } else {
      if (x == 4)
        yBinMax = 22;
      else if (x == 9 || x == 11)
        yBinMax = 16;
      else
        yBinMax = 18;
    }
    for (int y = 1; y < yBinMax; y++) {
      int hv = 1;
      int lv = 1;
      float dead = 0;
      float firstbin = 0;
      float noisystrips = 0;
      float mult = 0;
      float asy = 0;
      chamberQualityState chamberState = GoodState;

      if (HV)
        hv = (int)HV->getBinContent(x, y);
      if (LV)
        lv = (int)LV->getBinContent(x, y);

      if (hv != 1 || lv != 1) {
        chamberState = OffState;
      } else {
        if (DEAD)
          dead = DEAD->getBinContent(x, y);
        if (dead >= 0.80) {
          chamberState = DeadState;
        } else if (0.33 <= dead && dead < 0.80) {
          chamberState = PartiallyDeadState;
        } else {
          if (CLS)
            firstbin = CLS->getBinContent(x, y);
          if (firstbin >= 0.88) {
            chamberState = NoisyStripState;
          } else {
            if (NoisySt)
              noisystrips = NoisySt->getBinContent(x, y);
            if (noisystrips > 0) {
              chamberState = NoisyStripState;
            } else {
              if (MULT)
                mult = MULT->getBinContent(x, y);
              if (mult >= 6) {
                chamberState = NoisyRollState;
              } else {
                if (Chip)
                  asy = Chip->getBinContent(x, y);
                if (asy > 0.35) {
                  chamberState = BadShapeState;
                } else {
                  chamberState = GoodState;
                }
              }
            }
          }
        }
      }
      if (RCQ)
        RCQ->setBinContent(x, y, chamberState);
      if (RCQD)
        RCQD->Fill(chamberState);
      if (quality)
        quality->Fill(chamberState);
    }
  }
  return;
}