MuonAlignmentSummary.cc

Go to the documentation of this file.

/*
 *  DQM client for muon alignment summary
 *
 *  \author J. Fernandez - Univ. Oviedo <Javier.Fernandez@cern.ch>
 */

#include "DQMOffline/Alignment/interface/MuonAlignmentSummary.h"

MuonAlignmentSummary::MuonAlignmentSummary(const edm::ParameterSet &pSet) {
  parameters = pSet;

  meanPositionRange = parameters.getUntrackedParameter<double>("meanPositionRange");
  rmsPositionRange = parameters.getUntrackedParameter<double>("rmsPositionRange");
  meanAngleRange = parameters.getUntrackedParameter<double>("meanAngleRange");
  rmsAngleRange = parameters.getUntrackedParameter<double>("rmsAngleRange");

  doDT = parameters.getUntrackedParameter<bool>("doDT");
  doCSC = parameters.getUntrackedParameter<bool>("doCSC");

  MEFolderName = parameters.getParameter<std::string>("FolderName");
  topFolder << MEFolderName + "Alignment/Muon";

  if (!(doDT || doCSC)) {
    edm::LogError("MuonAlignmentSummary") << " Error!! At least one Muon subsystem (DT or CSC) must be "
                                             "monitorized!!"
                                          << std::endl;
    edm::LogError("MuonAlignmentSummary")
        << " Please enable doDT or doCSC to True in your python cfg file!!!" << std::endl;
    exit(1);
  }
}

MuonAlignmentSummary::~MuonAlignmentSummary() {}

void MuonAlignmentSummary::dqmEndJob(DQMStore::IBooker &ibooker, DQMStore::IGetter &igetter) {
  metname = "MuonAlignmentSummary";

  LogTrace(metname) << "[MuonAlignmentSummary] Parameters initialization";

  if (doDT) {
    ibooker.setCurrentFolder(topFolder.str() + "/DT");
    hLocalPositionDT = ibooker.book2D(
        "hLocalPositionDT", "Local DT position (cm) absolute MEAN residuals;Sector;;cm", 14, 1, 15, 40, 0, 40);

    hLocalAngleDT = ibooker.book2D(
        "hLocalAngleDT", "Local DT angle (rad) absolute MEAN residuals;Sector;;rad", 14, 1, 15, 40, 0, 40);

    hLocalPositionRmsDT =
        ibooker.book2D("hLocalPositionRmsDT", "Local DT position (cm) RMS residuals;Sector;;cm", 14, 1, 15, 40, 0, 40);

    hLocalAngleRmsDT =
        ibooker.book2D("hLocalAngleRmsDT", "Local DT angle (rad) RMS residuals;Sector;;rad", 14, 1, 15, 40, 0, 40);

    hLocalXMeanDT = ibooker.book1D("hLocalXMeanDT",
                                   "Distribution of absolute MEAN Local X (cm) residuals "
                                   "for DT;<X> (cm);number of chambers",
                                   100,
                                   0,
                                   meanPositionRange);

    hLocalXRmsDT = ibooker.book1D("hLocalXRmsDT",
                                  "Distribution of RMS Local X (cm) residuals "
                                  "for DT;X RMS (cm);number of chambers",
                                  100,
                                  0,
                                  rmsPositionRange);

    hLocalYMeanDT = ibooker.book1D("hLocalYMeanDT",
                                   "Distribution of absolute MEAN Local Y (cm) residuals "
                                   "for DT;<Y> (cm);number of chambers",
                                   100,
                                   0,
                                   meanPositionRange);

    hLocalYRmsDT = ibooker.book1D("hLocalYRmsDT",
                                  "Distribution of RMS Local Y (cm) residuals "
                                  "for DT;Y RMS (cm);number of chambers",
                                  100,
                                  0,
                                  rmsPositionRange);

    hLocalPhiMeanDT = ibooker.book1D("hLocalPhiMeanDT",
                                     "Distribution of absolute MEAN #phi (rad) residuals for "
                                     "DT;<#phi>(rad);number of chambers",
                                     100,
                                     0,
                                     meanAngleRange);

    hLocalPhiRmsDT = ibooker.book1D("hLocalPhiRmsDT",
                                    "Distribution of RMS #phi (rad) residuals "
                                    "for DT;#phi RMS (rad);number of chambers",
                                    100,
                                    0,
                                    rmsAngleRange);

    hLocalThetaMeanDT = ibooker.book1D("hLocalThetaMeanDT",
                                       "Distribution of absolute MEAN #theta (rad) residuals "
                                       "for DT;<#theta>(rad);number of chambers",
                                       100,
                                       0,
                                       meanAngleRange);

    hLocalThetaRmsDT = ibooker.book1D("hLocalThetaRmsDT",
                                      "Distribution of RMS #theta (rad) residuals for "
                                      "DT;#theta RMS (rad);number of chambers",
                                      100,
                                      0,
                                      rmsAngleRange);

    hLocalPositionDT->Reset();
    hLocalAngleDT->Reset();
    hLocalPositionRmsDT->Reset();
    hLocalAngleRmsDT->Reset();
    hLocalXMeanDT->Reset();
    hLocalXRmsDT->Reset();
    hLocalYMeanDT->Reset();
    hLocalYRmsDT->Reset();
    hLocalPhiMeanDT->Reset();
    hLocalPhiRmsDT->Reset();
    hLocalThetaMeanDT->Reset();
    hLocalThetaRmsDT->Reset();
  }

  if (doCSC) {
    ibooker.setCurrentFolder(topFolder.str() + "/CSC");
    hLocalPositionCSC = ibooker.book2D(
        "hLocalPositionCSC", "Local CSC position (cm) absolute MEAN residuals;Sector;;cm", 36, 1, 37, 40, 0, 40);

    hLocalAngleCSC = ibooker.book2D(
        "hLocalAngleCSC", "Local CSC angle (rad) absolute MEAN residuals;Sector;;rad", 36, 1, 37, 40, 0, 40);

    hLocalPositionRmsCSC = ibooker.book2D(
        "hLocalPositionRmsCSC", "Local CSC position (cm) RMS residuals;Sector;;cm", 36, 1, 37, 40, 0, 40);

    hLocalAngleRmsCSC =
        ibooker.book2D("hLocalAngleRmsCSC", "Local CSC angle (rad) RMS residuals;Sector;;rad", 36, 1, 37, 40, 0, 40);

    hLocalXMeanCSC = ibooker.book1D("hLocalXMeanCSC",
                                    "Distribution of absolute MEAN Local X (cm) residuals "
                                    "for CSC;<X> (cm);number of chambers",
                                    100,
                                    0,
                                    meanPositionRange);

    hLocalXRmsCSC = ibooker.book1D("hLocalXRmsCSC",
                                   "Distribution of RMS Local X (cm) residuals "
                                   "for CSC;X RMS (cm);number of chambers",
                                   100,
                                   0,
                                   rmsPositionRange);

    hLocalYMeanCSC = ibooker.book1D("hLocalYMeanCSC",
                                    "Distribution of absolute MEAN Local Y (cm) residuals "
                                    "for CSC;<Y> (cm);number of chambers",
                                    100,
                                    0,
                                    meanPositionRange);

    hLocalYRmsCSC = ibooker.book1D("hLocalYRmsCSC",
                                   "Distribution of RMS Local Y (cm) residuals "
                                   "for CSC;Y RMS (cm);number of chambers",
                                   100,
                                   0,
                                   rmsPositionRange);

    hLocalPhiMeanCSC = ibooker.book1D("hLocalPhiMeanCSC",
                                      "Distribution of absolute MEAN #phi (rad) residuals for "
                                      "CSC;<#phi>(rad);number of chambers",
                                      100,
                                      0,
                                      meanAngleRange);

    hLocalPhiRmsCSC = ibooker.book1D("hLocalPhiRmsCSC",
                                     "Distribution of RMS #phi (rad) residuals for CSC;#phi "
                                     "RMS (rad);number of chambers",
                                     100,
                                     0,
                                     rmsAngleRange);

    hLocalThetaMeanCSC = ibooker.book1D("hLocalThetaMeanCSC",
                                        "Distribution of absolute MEAN #theta (rad) residuals "
                                        "for CSC;<#theta>(rad);number of chambers",
                                        100,
                                        0,
                                        meanAngleRange);

    hLocalThetaRmsCSC = ibooker.book1D("hLocalThetaRmsCSC",
                                       "Distribution of RMS #theta (rad) residuals for "
                                       "CSC;#theta RMS (rad);number of chambers",
                                       100,
                                       0,
                                       rmsAngleRange);

    hLocalPositionCSC->Reset();
    hLocalAngleCSC->Reset();
    hLocalPositionRmsCSC->Reset();
    hLocalAngleRmsCSC->Reset();
    hLocalXMeanCSC->Reset();
    hLocalXRmsCSC->Reset();
    hLocalYMeanCSC->Reset();
    hLocalYRmsCSC->Reset();
    hLocalPhiMeanCSC->Reset();
    hLocalPhiRmsCSC->Reset();
    hLocalThetaMeanCSC->Reset();
    hLocalThetaRmsCSC->Reset();
  }

  LogTrace(metname) << "[MuonAlignmentSummary] Saving the histos";

  char binLabel[40];

  for (int station = -4; station < 5; station++) {
    if (doDT) {
      if (station > 0) {
        for (int wheel = -2; wheel < 3; wheel++) {
          for (int sector = 1; sector < 15; sector++) {
            if (!((sector == 13 || sector == 14) && station != 4)) {
              std::stringstream Wheel;
              Wheel << wheel;
              std::stringstream Station;
              Station << station;
              std::stringstream Sector;
              Sector << sector;

              std::string nameOfHistoLocalX =
                  "ResidualLocalX_W" + Wheel.str() + "MB" + Station.str() + "S" + Sector.str();
              std::string nameOfHistoLocalPhi =
                  "ResidualLocalPhi_W" + Wheel.str() + "MB" + Station.str() + "S" + Sector.str();
              std::string nameOfHistoLocalTheta =
                  "ResidualLocalTheta_W" + Wheel.str() + "MB" + Station.str() + "S" + Sector.str();
              std::string nameOfHistoLocalY =
                  "ResidualLocalY_W" + Wheel.str() + "MB" + Station.str() + "S" + Sector.str();

              std::string path = topFolder.str() + "/DT/Wheel" + Wheel.str() + "/Station" + Station.str() + "/Sector" +
                                 Sector.str() + "/";

              std::string histo = path + nameOfHistoLocalX;

              Int_t nstation = station - 1;
              Int_t nwheel = wheel + 2;
              MonitorElement *localX = igetter.get(histo);
              if (localX) {
                Double_t Mean = localX->getMean();
                Double_t Error = localX->getMeanError();

                Int_t ybin = 1 + nwheel * 8 + nstation * 2;
                hLocalPositionDT->setBinContent(sector, ybin, fabs(Mean));
                snprintf(binLabel, sizeof(binLabel), "MB%d/%d_X", wheel, station);
                hLocalPositionDT->setBinLabel(ybin, binLabel, 2);
                hLocalPositionRmsDT->setBinContent(sector, ybin, Error);
                hLocalPositionRmsDT->setBinLabel(ybin, binLabel, 2);

                if (localX->getEntries() != 0) {
                  hLocalXMeanDT->Fill(fabs(Mean));
                  hLocalXRmsDT->Fill(Error);
                }
              }

              histo = path + nameOfHistoLocalPhi;
              MonitorElement *localPhi = igetter.get(histo);
              if (localPhi) {
                Double_t Mean = localPhi->getMean();
                Double_t Error = localPhi->getMeanError();

                Int_t ybin = 1 + nwheel * 8 + nstation * 2;
                hLocalAngleDT->setBinContent(sector, ybin, fabs(Mean));
                snprintf(binLabel, sizeof(binLabel), "MB%d/%d_#phi", wheel, station);
                hLocalAngleDT->setBinLabel(ybin, binLabel, 2);
                hLocalAngleRmsDT->setBinContent(sector, ybin, Error);
                hLocalAngleRmsDT->setBinLabel(ybin, binLabel, 2);

                if (localPhi->getEntries() != 0) {
                  hLocalPhiMeanDT->Fill(fabs(Mean));
                  hLocalPhiRmsDT->Fill(Error);
                }
              }

              if (station != 4) {
                histo = path + nameOfHistoLocalY;
                MonitorElement *localY = igetter.get(histo);
                if (localY) {
                  Double_t Mean = localY->getMean();
                  Double_t Error = localY->getMeanError();

                  Int_t ybin = 2 + nwheel * 8 + nstation * 2;
                  hLocalPositionDT->setBinContent(sector, ybin, fabs(Mean));
                  snprintf(binLabel, sizeof(binLabel), "MB%d/%d_Y", wheel, station);
                  hLocalPositionDT->setBinLabel(ybin, binLabel, 2);
                  hLocalPositionRmsDT->setBinContent(sector, ybin, Error);
                  hLocalPositionRmsDT->setBinLabel(ybin, binLabel, 2);
                  if (localY->getEntries() != 0) {
                    hLocalYMeanDT->Fill(fabs(Mean));
                    hLocalYRmsDT->Fill(Error);
                  }
                }
                histo = path + nameOfHistoLocalTheta;
                MonitorElement *localTheta = igetter.get(histo);
                if (localTheta) {
                  Double_t Mean = localTheta->getMean();
                  Double_t Error = localTheta->getMeanError();

                  Int_t ybin = 2 + nwheel * 8 + nstation * 2;
                  hLocalAngleDT->setBinContent(sector, ybin, fabs(Mean));
                  snprintf(binLabel, sizeof(binLabel), "MB%d/%d_#theta", wheel, station);
                  hLocalAngleDT->setBinLabel(ybin, binLabel, 2);
                  hLocalAngleRmsDT->setBinContent(sector, ybin, Error);
                  hLocalAngleRmsDT->setBinLabel(ybin, binLabel, 2);
                  if (localTheta->getEntries() != 0) {
                    hLocalThetaMeanDT->Fill(fabs(Mean));
                    hLocalThetaRmsDT->Fill(Error);
                  }
                }
              }  // station != 4
            }    // avoid non existing sectors
          }      // sector
        }        // wheel
      }          // station>0
    }            // doDT

    if (doCSC) {
      if (station != 0) {
        for (int ring = 1; ring < 5; ring++) {
          for (int chamber = 1; chamber < 37; chamber++) {
            if (!(((abs(station) == 2 || abs(station) == 3 || abs(station) == 4) && ring == 1 && chamber > 18) ||
                  ((abs(station) == 2 || abs(station) == 3 || abs(station) == 4) && ring > 2))) {
              std::stringstream Ring;
              Ring << ring;
              std::stringstream Station;
              Station << station;
              std::stringstream Chamber;
              Chamber << chamber;

              std::string nameOfHistoLocalX =
                  "ResidualLocalX_ME" + Station.str() + "R" + Ring.str() + "C" + Chamber.str();
              std::string nameOfHistoLocalPhi =
                  "ResidualLocalPhi_ME" + Station.str() + "R" + Ring.str() + "C" + Chamber.str();
              std::string nameOfHistoLocalTheta =
                  "ResidualLocalTheta_ME" + Station.str() + "R" + Ring.str() + "C" + Chamber.str();
              std::string nameOfHistoLocalY =
                  "ResidualLocalY_ME" + Station.str() + "R" + Ring.str() + "C" + Chamber.str();

              std::string path = topFolder.str() + "/CSC/Station" + Station.str() + "/Ring" + Ring.str() + "/Chamber" +
                                 Chamber.str() + "/";

              Int_t ybin = abs(station) * 2 + ring;
              if (abs(station) == 1)
                ybin = ring;
              if (station > 0)
                ybin = ybin + 10;
              else
                ybin = 11 - ybin;
              std::string histo = path + nameOfHistoLocalX;
              MonitorElement *localX = igetter.get(histo);
              if (localX) {
                Double_t Mean = localX->getMean();
                Double_t Error = localX->getMeanError();

                Int_t ybin2 = 2 * ybin - 1;
                hLocalPositionCSC->setBinContent(chamber, ybin2, fabs(Mean));
                snprintf(binLabel, sizeof(binLabel), "ME%d/%d_X", station, ring);
                hLocalPositionCSC->setBinLabel(ybin2, binLabel, 2);
                hLocalPositionRmsCSC->setBinContent(chamber, ybin2, Error);
                hLocalPositionRmsCSC->setBinLabel(ybin2, binLabel, 2);
                if (localX->getEntries() != 0) {
                  hLocalXMeanCSC->Fill(fabs(Mean));
                  hLocalXRmsCSC->Fill(Error);
                }
              }
              histo = path + nameOfHistoLocalPhi;

              MonitorElement *localPhi = igetter.get(histo);
              if (localPhi) {
                Double_t Mean = localPhi->getMean();
                Double_t Error = localPhi->getMeanError();

                Int_t ybin2 = 2 * ybin - 1;
                hLocalAngleCSC->setBinContent(chamber, ybin2, fabs(Mean));
                snprintf(binLabel, sizeof(binLabel), "ME%d/%d_#phi", station, ring);
                hLocalAngleCSC->setBinLabel(ybin2, binLabel, 2);
                hLocalAngleRmsCSC->setBinContent(chamber, ybin2, Error);
                hLocalAngleRmsCSC->setBinLabel(ybin2, binLabel, 2);
                if (localPhi->getEntries() != 0) {
                  hLocalPhiMeanCSC->Fill(fabs(Mean));
                  hLocalPhiRmsCSC->Fill(Error);
                }
              }
              histo = path + nameOfHistoLocalTheta;
              MonitorElement *localTheta = igetter.get(histo);
              if (localTheta) {
                Double_t Mean = localTheta->getMean();
                Double_t Error = localTheta->getMeanError();

                Int_t ybin2 = 2 * ybin;
                hLocalAngleCSC->setBinContent(chamber, ybin2, fabs(Mean));
                snprintf(binLabel, sizeof(binLabel), "ME%d/%d_#theta", station, ring);
                hLocalAngleCSC->setBinLabel(ybin2, binLabel, 2);
                hLocalAngleRmsCSC->setBinContent(chamber, ybin2, Error);
                hLocalAngleRmsCSC->setBinLabel(ybin2, binLabel, 2);
                if (localTheta->getEntries() != 0) {
                  hLocalThetaMeanCSC->Fill(fabs(Mean));
                  hLocalThetaRmsCSC->Fill(Error);
                }
              }
              histo = path + nameOfHistoLocalY;

              MonitorElement *localY = igetter.get(histo);
              if (localY) {
                Double_t Mean = localY->getMean();
                Double_t Error = localY->getMeanError();

                Int_t ybin2 = 2 * ybin;
                hLocalPositionCSC->setBinContent(chamber, ybin2, fabs(Mean));
                snprintf(binLabel, sizeof(binLabel), "ME%d/%d_Y", station, ring);
                hLocalPositionCSC->setBinLabel(ybin2, binLabel, 2);
                hLocalPositionRmsCSC->setBinContent(chamber, ybin2, Error);
                hLocalPositionRmsCSC->setBinLabel(ybin2, binLabel, 2);
                if (localY->getEntries() != 0) {
                  hLocalYMeanCSC->Fill(fabs(Mean));
                  hLocalYRmsCSC->Fill(Error);
                }
              }
            }  // avoid non existing rings
          }    // chamber
        }      // ring
      }        // station!=0
    }          // doCSC
  }            // loop on stations
}