File indexing completed on 2024-09-11 04:32:29
0001 #ifndef DQM_GEM_INTERFACE_GEMDQMBase_h
0002 #define DQM_GEM_INTERFACE_GEMDQMBase_h
0003
0004 #include <map>
0005 #include <tuple>
0006
0007 #include "FWCore/Framework/interface/ESHandle.h"
0008 #include "FWCore/Framework/interface/MakerMacros.h"
0009 #include "FWCore/PluginManager/interface/ModuleDef.h"
0010 #include "FWCore/Framework/interface/Event.h"
0011 #include "FWCore/Framework/interface/EventSetup.h"
0012 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0013 #include "FWCore/Utilities/interface/InputTag.h"
0014 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0015
0016 #include "DQMServices/Core/interface/DQMEDAnalyzer.h"
0017 #include "DQMServices/Core/interface/DQMEDAnalyzer.h"
0018 #include "DQMServices/Core/interface/DQMStore.h"
0019 #include "DQMServices/Core/interface/MonitorElement.h"
0020
0021 #include "CondFormats/GEMObjects/interface/GEMeMap.h"
0022 #include "Validation/MuonGEMHits/interface/GEMValidationUtils.h"
0023
0024 #include "DataFormats/GEMDigi/interface/GEMDigiCollection.h"
0025
0026 #include "Geometry/GEMGeometry/interface/GEMGeometry.h"
0027 #include "Geometry/Records/interface/MuonGeometryRecord.h"
0028
0029 class GEMDQMBase : public DQMEDAnalyzer {
0030 public:
0031
0032 class BookingHelper {
0033 public:
0034 BookingHelper(DQMStore::IBooker &ibooker, const TString &name_suffix, const TString &title_suffix)
0035 : ibooker_(&ibooker), name_suffix_(name_suffix), title_suffix_(title_suffix) {}
0036
0037 ~BookingHelper() {}
0038
0039 MonitorElement *book1D(TString name,
0040 TString title,
0041 int nbinsx,
0042 double xlow,
0043 double xup,
0044 TString x_title = "",
0045 TString y_title = "Entries") {
0046 name += name_suffix_;
0047 title += title_suffix_ + ";" + x_title + ";" + y_title;
0048 return ibooker_->book1D(name, title, nbinsx, xlow, xup);
0049 }
0050
0051 MonitorElement *book1D(TString name,
0052 TString title,
0053 std::vector<double> &x_binning,
0054 TString x_title = "",
0055 TString y_title = "Entries") {
0056 name += name_suffix_;
0057 title += title_suffix_ + ";" + x_title + ";" + y_title;
0058 TH1F *h_obj = new TH1F(name, title, x_binning.size() - 1, &x_binning[0]);
0059 return ibooker_->book1D(name, h_obj);
0060 }
0061
0062 MonitorElement *book2D(TString name,
0063 TString title,
0064 int nbinsx,
0065 double xlow,
0066 double xup,
0067 int nbinsy,
0068 double ylow,
0069 double yup,
0070 TString x_title = "",
0071 TString y_title = "") {
0072 name += name_suffix_;
0073 title += title_suffix_ + ";" + x_title + ";" + y_title;
0074 return ibooker_->book2D(name, title, nbinsx, xlow, xup, nbinsy, ylow, yup);
0075 }
0076
0077 MonitorElement *bookProfile2D(TString name,
0078 TString title,
0079 int nbinsx,
0080 double xlow,
0081 double xup,
0082 int nbinsy,
0083 double ylow,
0084 double yup,
0085 double zlow,
0086 double zup,
0087 TString x_title = "",
0088 TString y_title = "") {
0089 name += name_suffix_;
0090 title += title_suffix_ + ";" + x_title + ";" + y_title;
0091 return ibooker_->bookProfile2D(name, title, nbinsx, xlow, xup, nbinsy, ylow, yup, zlow, zup);
0092 }
0093
0094 DQMStore::IBooker *getBooker() { return ibooker_; }
0095
0096 private:
0097 DQMStore::IBooker *ibooker_;
0098 const TString name_suffix_;
0099 const TString title_suffix_;
0100 };
0101
0102 template <class M, class K>
0103 class MEMapInfT {
0104 public:
0105 MEMapInfT() : bOperating_(false), bIsNoUnderOverflowBin_(false) {}
0106
0107 MEMapInfT(
0108 GEMDQMBase *pDQMBase, TString strName, TString strTitle, TString strTitleX = "", TString strTitleY = "Entries")
0109 : pDQMBase_(pDQMBase),
0110 strName_(strName),
0111 strTitle_(strTitle),
0112 strTitleX_(strTitleX),
0113 strTitleY_(strTitleY),
0114 log_category_own_(pDQMBase->log_category_) {}
0115
0116 MEMapInfT(GEMDQMBase *pDQMBase,
0117 TString strName,
0118 TString strTitle,
0119 Int_t nBinsX,
0120 Double_t dXL,
0121 Double_t dXH,
0122 TString strTitleX = "",
0123 TString strTitleY = "Entries")
0124 : pDQMBase_(pDQMBase),
0125 strName_(strName),
0126 strTitle_(strTitle),
0127 strTitleX_(strTitleX),
0128 strTitleY_(strTitleY),
0129 bOperating_(true),
0130 bIsProfile_(false),
0131 bIsNoUnderOverflowBin_(false),
0132 nBinsX_(nBinsX),
0133 dXL_(dXL),
0134 dXH_(dXH),
0135 nBinsY_(-1),
0136 log_category_own_(pDQMBase->log_category_) {}
0137
0138 MEMapInfT(GEMDQMBase *pDQMBase,
0139 TString strName,
0140 TString strTitle,
0141 std::vector<Double_t> &x_binning,
0142 TString strTitleX = "",
0143 TString strTitleY = "Entries")
0144 : pDQMBase_(pDQMBase),
0145 strName_(strName),
0146 strTitle_(strTitle),
0147 strTitleX_(strTitleX),
0148 strTitleY_(strTitleY),
0149 bOperating_(true),
0150 bIsProfile_(false),
0151 bIsNoUnderOverflowBin_(false),
0152 nBinsX_(-1),
0153 nBinsY_(-1),
0154 log_category_own_(pDQMBase->log_category_) {
0155 for (Int_t i = 0; i < (Int_t)x_binning.size(); i++)
0156 x_binning_.push_back(x_binning[i]);
0157 };
0158
0159 MEMapInfT(GEMDQMBase *pDQMBase,
0160 TString strName,
0161 TString strTitle,
0162 Int_t nBinsX,
0163 Double_t dXL,
0164 Double_t dXH,
0165 Int_t nBinsY,
0166 Double_t dYL,
0167 Double_t dYH,
0168 TString strTitleX = "",
0169 TString strTitleY = "")
0170 : pDQMBase_(pDQMBase),
0171 strName_(strName),
0172 strTitle_(strTitle),
0173 strTitleX_(strTitleX),
0174 strTitleY_(strTitleY),
0175 bOperating_(true),
0176 bIsProfile_(false),
0177 bIsNoUnderOverflowBin_(false),
0178 nBinsX_(nBinsX),
0179 dXL_(dXL),
0180 dXH_(dXH),
0181 nBinsY_(nBinsY),
0182 dYL_(dYL),
0183 dYH_(dYH),
0184 dZL_(0),
0185 dZH_(1024),
0186 log_category_own_(pDQMBase->log_category_) {}
0187
0188 MEMapInfT(GEMDQMBase *pDQMBase,
0189 TString strName,
0190 TString strTitle,
0191 Int_t nBinsX,
0192 Double_t dXL,
0193 Double_t dXH,
0194 Int_t nBinsY,
0195 Double_t dYL,
0196 Double_t dYH,
0197 Double_t dZL,
0198 Double_t dZH,
0199 TString strTitleX = "",
0200 TString strTitleY = "")
0201 : pDQMBase_(pDQMBase),
0202 strName_(strName),
0203 strTitle_(strTitle),
0204 strTitleX_(strTitleX),
0205 strTitleY_(strTitleY),
0206 bOperating_(true),
0207 bIsProfile_(true),
0208 bIsNoUnderOverflowBin_(false),
0209 nBinsX_(nBinsX),
0210 dXL_(dXL),
0211 dXH_(dXH),
0212 nBinsY_(nBinsY),
0213 dYL_(dYL),
0214 dYH_(dYH),
0215 dZL_(dZL),
0216 dZH_(dZH),
0217 log_category_own_(pDQMBase->log_category_) {}
0218
0219
0220
0221
0222
0223
0224
0225
0226
0227
0228
0229
0230
0231
0232
0233
0234
0235
0236
0237
0238
0239
0240
0241 ~MEMapInfT() {}
0242
0243 Bool_t isOperating() { return bOperating_; };
0244 void SetOperating(Bool_t bOperating) { bOperating_ = bOperating; };
0245 void TurnOn() { bOperating_ = true; };
0246 void TurnOff() { bOperating_ = false; };
0247 void SetNoUnderOverflowBin() { bIsNoUnderOverflowBin_ = true; };
0248
0249 Bool_t isProfile() { return bIsProfile_; };
0250 void SetProfile(Bool_t bIsProfile) { bIsProfile_ = bIsProfile; };
0251
0252 TString GetName() { return strName_; };
0253 void SetName(TString strName) { strName_ = strName; };
0254 TString GetTitle() { return strTitle_; };
0255 void SetTitle(TString strTitle) { strTitle_ = strTitle; };
0256 TString GetTitleX() { return strTitleX_; };
0257 void SetTitleX(TString strTitleX) { strTitleX_ = strTitleX; };
0258 TString GetTitleY() { return strTitleY_; };
0259 void SetTitleY(TString strTitleY) { strTitleY_ = strTitleY; };
0260
0261 Int_t GetNbinsX() { return nBinsX_; };
0262 void SetNbinsX(Int_t nBinsX) { nBinsX_ = nBinsX; };
0263 Double_t GetBinLowEdgeX() { return dXL_; };
0264 void SetBinLowEdgeX(Double_t dXL) { dXL_ = dXL; };
0265 Double_t GetBinHighEdgeX() { return dXH_; };
0266 void SetBinHighEdgeX(Double_t dXH) { dXH_ = dXH; };
0267
0268
0269 Int_t GetNbinsY() { return nBinsY_; };
0270 void SetNbinsY(Int_t nBinsY) { nBinsY_ = nBinsY; };
0271 Double_t GetBinLowEdgeY() { return dYL_; };
0272 void SetBinLowEdgeY(Double_t dYL) { dYL_ = dYL; };
0273 Double_t GetBinHighEdgeY() { return dYH_; };
0274 void SetBinHighEdgeY(Double_t dYH) { dYH_ = dYH; };
0275
0276 Double_t GetBinLowEdgeZ() { return dZL_; };
0277 void SetBinLowEdgeZ(Double_t dZL) { dZL_ = dZL; };
0278 Double_t GetBinHighEdgeZ() { return dZH_; };
0279 void SetBinHighEdgeZ(Double_t dZH) { dZH_ = dZH; };
0280
0281 void SetBinConfX(Int_t nBins, Double_t dL = 0.5, Double_t dH = -1048576.0) {
0282 nBinsX_ = nBins;
0283 dXL_ = dL;
0284 if (dH <= dL)
0285 dH = dL + nBins;
0286 dXH_ = dH;
0287 };
0288
0289 void SetBinConfY(Int_t nBins, Double_t dL = 0.5, Double_t dH = -1048576.0) {
0290 nBinsY_ = nBins;
0291 dYL_ = dL;
0292 if (dH <= dL)
0293 dH = dL + nBins;
0294 dYH_ = dH;
0295 };
0296
0297 void SetPointUOFlow() {
0298 dXU_ = dXL_ + (dXH_ - dXL_) / nBinsX_ * 0.5;
0299 dXO_ = dXL_ + (dXH_ - dXL_) / nBinsX_ * (nBinsX_ - 0.5);
0300 dYU_ = dYL_ + (dYH_ - dYL_) / nBinsY_ * 0.5;
0301 dYO_ = dYL_ + (dYH_ - dYL_) / nBinsY_ * (nBinsY_ - 0.5);
0302 dZU_ = dZL_ + (dZH_ - dZL_) / nBinsZ_ * 0.5;
0303 dZO_ = dZL_ + (dZH_ - dZL_) / nBinsZ_ * (nBinsZ_ - 0.5);
0304 };
0305
0306 M &map() { return mapHist; }
0307 int bookND(BookingHelper &bh, K key) {
0308 if (!bOperating_)
0309 return 0;
0310 SetPointUOFlow();
0311 if (bIsProfile_) {
0312 mapHist[key] = bh.bookProfile2D(
0313 strName_, strTitle_, nBinsX_, dXL_, dXH_, nBinsY_, dYL_, dYH_, dZL_, dZH_, strTitleX_, strTitleY_);
0314 } else if (nBinsY_ > 0 && nBinsX_ > 0) {
0315 mapHist[key] = bh.book2D(strName_, strTitle_, nBinsX_, dXL_, dXH_, nBinsY_, dYL_, dYH_, strTitleX_, strTitleY_);
0316 return 0;
0317 } else if (!x_binning_.empty()) {
0318 mapHist[key] = bh.book1D(strName_, strTitle_, nBinsX_, dXL_, dXH_, strTitleX_, strTitleY_);
0319 return 0;
0320 } else if (nBinsX_ > 0) {
0321 mapHist[key] = bh.book1D(strName_, strTitle_, nBinsX_, dXL_, dXH_, strTitleX_, strTitleY_);
0322 return 0;
0323 }
0324
0325 return -1;
0326 };
0327
0328 dqm::impl::MonitorElement *FindHist(K key) {
0329 if (mapHist.find(key) == mapHist.end()) {
0330 edm::LogError(log_category_own_)
0331 << "WARNING: Cannot find the histogram corresponing to the given key\n";
0332 return nullptr;
0333 }
0334 return mapHist[key];
0335 };
0336
0337 int SetLabelForChambers(K key, Int_t nAxis, Int_t nNumBin = -1, Int_t nIdxStart = 1) {
0338 if (!bOperating_)
0339 return 0;
0340 if (nNumBin <= 0) {
0341 if (nAxis == 1)
0342 nNumBin = nBinsX_;
0343 else if (nAxis == 2)
0344 nNumBin = nBinsY_;
0345 else
0346 return -1;
0347 }
0348 dqm::impl::MonitorElement *histCurr = FindHist(key);
0349 if (histCurr == nullptr)
0350 return -999;
0351 for (Int_t i = 1; i <= nNumBin; i++) {
0352 histCurr->setBinLabel(i, Form("%i", nIdxStart + i - 1), nAxis);
0353 }
0354 return 0;
0355 };
0356
0357 int SetLabelForIEta(K key, Int_t nAxis, Int_t nNumBin = -1) { return SetLabelForChambers(key, nAxis, nNumBin); };
0358
0359 int SetLabelForVFATs(K key, Int_t nNumEtaPartitions, Int_t nAxis, Int_t nNumBin = -1) {
0360 if (!bOperating_)
0361 return 0;
0362 if (nNumBin <= 0) {
0363 if (nAxis == 1)
0364 nNumBin = nBinsX_;
0365 else if (nAxis == 2)
0366 nNumBin = nBinsY_;
0367 else
0368 return -1;
0369 }
0370 dqm::impl::MonitorElement *histCurr = FindHist(key);
0371 if (histCurr == nullptr)
0372 return -999;
0373 if (std::get<1>(key) == 2) {
0374 Int_t nNumVFATPerModule = 12;
0375 if (nNumBin > nNumVFATPerModule) {
0376 for (Int_t i = 0; i < nNumBin; i++) {
0377 Int_t nIModule = i / nNumVFATPerModule + 1;
0378 histCurr->setBinLabel(
0379 i + 1, Form((nAxis == 1 ? "#splitline{%i}{M%i}" : "%i (M%i)"), i % nNumVFATPerModule, nIModule), nAxis);
0380 }
0381 } else {
0382 for (Int_t i = 0; i < nNumBin; i++) {
0383 histCurr->setBinLabel(i + 1, Form("%i", i), nAxis);
0384 }
0385 }
0386 } else {
0387 for (Int_t i = 0; i < nNumBin; i++) {
0388 Int_t nIEta = pDQMBase_->getIEtaFromVFAT(std::get<1>(key), i);
0389 histCurr->setBinLabel(i + 1, Form("%i (%i)", i, nIEta), nAxis);
0390 }
0391 }
0392 return 0;
0393 };
0394
0395 int Fill(K key, Double_t x) {
0396 if (!bOperating_)
0397 return 0;
0398 dqm::impl::MonitorElement *hist = FindHist(key);
0399 if (hist == nullptr)
0400 return -999;
0401 if (bIsNoUnderOverflowBin_) {
0402 if (x <= dXL_)
0403 x = dXU_;
0404 else if (x >= dXH_)
0405 x = dXO_;
0406 }
0407 hist->Fill(x);
0408 return 1;
0409 };
0410
0411 int Fill(K key, Double_t x, Double_t y, Double_t w = 1.0) {
0412 if (!bOperating_)
0413 return 0;
0414 dqm::impl::MonitorElement *hist = FindHist(key);
0415 if (hist == nullptr)
0416 return -999;
0417 if (bIsNoUnderOverflowBin_) {
0418 if (x <= dXL_)
0419 x = dXU_;
0420 else if (x >= dXH_)
0421 x = dXO_;
0422 if (y <= dYL_)
0423 y = dYU_;
0424 else if (y >= dYH_)
0425 y = dYO_;
0426 }
0427 hist->Fill(x, y, w);
0428 return 1;
0429 };
0430
0431 int FillBits(K key, Double_t x, UInt_t bits, Double_t w = 1.0) {
0432 if (!bOperating_)
0433 return 0;
0434 dqm::impl::MonitorElement *hist = FindHist(key);
0435 if (hist == nullptr)
0436 return -999;
0437
0438 if (nBinsY_ <= 0)
0439 return -888;
0440 UInt_t unMask = 0x1;
0441 for (Int_t i = 1; i <= nBinsY_; i++) {
0442 if ((unMask & bits) != 0)
0443 hist->Fill(x, i, w);
0444 unMask <<= 1;
0445 }
0446
0447 return 1;
0448 };
0449
0450 private:
0451 GEMDQMBase *pDQMBase_;
0452
0453 M mapHist;
0454 TString strName_, strTitle_, strTitleX_, strTitleY_;
0455 Bool_t bOperating_;
0456 Bool_t bIsProfile_;
0457 Bool_t bIsNoUnderOverflowBin_;
0458
0459 std::vector<double> x_binning_;
0460 Int_t nBinsX_;
0461 Double_t dXL_, dXH_;
0462 Int_t nBinsY_;
0463 Double_t dYL_, dYH_;
0464 Int_t nBinsZ_;
0465 Double_t dZL_, dZH_;
0466 Double_t dXU_, dXO_;
0467 Double_t dYU_, dYO_;
0468 Double_t dZU_, dZO_;
0469
0470 std::string log_category_own_;
0471 };
0472
0473 typedef MEMapInfT<MEMap2Ids, ME2IdsKey> MEMap2Inf;
0474 typedef MEMapInfT<MEMap3Ids, ME3IdsKey> MEMap3Inf;
0475 typedef MEMapInfT<MEMap4Ids, ME4IdsKey> MEMap4Inf;
0476 typedef MEMapInfT<MEMap5Ids, ME5IdsKey> MEMap5Inf;
0477
0478 class MEStationInfo {
0479 public:
0480 MEStationInfo() : nNumChambers_(-1) {}
0481 MEStationInfo(Int_t nRegion,
0482 Int_t nStation,
0483 Int_t nLayer,
0484 Int_t nNumChambers,
0485 Int_t nNumModules,
0486 Int_t nNumEtaPartitions,
0487 Int_t nMaxVFAT,
0488 Int_t nFirstStrip,
0489 Int_t nNumDigi,
0490 Int_t nMinIdxChamber,
0491 Int_t nMaxIdxChamber)
0492 : nRegion_(nRegion),
0493 nStation_(nStation),
0494 nLayer_(nLayer),
0495 nNumChambers_(nNumChambers),
0496 nNumModules_(nNumModules),
0497 nNumEtaPartitions_(nNumEtaPartitions),
0498 nMaxVFAT_(nMaxVFAT),
0499 nFirstStrip_(nFirstStrip),
0500 nNumDigi_(nNumDigi),
0501 nMinIdxChamber_(nMinIdxChamber),
0502 nMaxIdxChamber_(nMaxIdxChamber),
0503 fMinPhi_(0) {}
0504
0505 bool operator==(const MEStationInfo &other) const {
0506 return (nRegion_ == other.nRegion_ && nStation_ == other.nStation_ && nLayer_ == other.nLayer_ &&
0507 nNumChambers_ == other.nNumChambers_ && nNumModules_ == other.nNumModules_ &&
0508 nNumEtaPartitions_ == other.nNumEtaPartitions_ && nMaxVFAT_ == other.nMaxVFAT_ &&
0509 nFirstStrip_ == other.nFirstStrip_ && nNumDigi_ == other.nNumDigi_);
0510 };
0511
0512 Int_t nRegion_;
0513 Int_t nStation_;
0514 Int_t nLayer_;
0515 Int_t nNumChambers_;
0516 Int_t nNumModules_;
0517 Int_t nNumEtaPartitions_;
0518 Int_t nMaxVFAT_;
0519 Int_t nFirstStrip_;
0520 Int_t nNumDigi_;
0521
0522 Int_t nMinIdxChamber_;
0523 Int_t nMaxIdxChamber_;
0524 Float_t fMinPhi_;
0525
0526 std::vector<Float_t> listRadiusEvenChamber_;
0527 std::vector<Float_t> listRadiusOddChamber_;
0528 };
0529
0530 int readGeometryRadiusInfoChamber(const GEMStation *station, MEStationInfo &stationInfo);
0531 int readGeometryPhiInfoChamber(const GEMStation *station, MEStationInfo &stationInfo);
0532
0533 public:
0534 explicit GEMDQMBase(const edm::ParameterSet &cfg);
0535 ~GEMDQMBase() override {}
0536
0537 enum {
0538 GEMDQM_RUNTYPE_ONLINE,
0539 GEMDQM_RUNTYPE_OFFLINE,
0540 GEMDQM_RUNTYPE_RELVAL,
0541 GEMDQM_RUNTYPE_ALLPLOTS,
0542 GEMDQM_RUNTYPE_NONE = -1
0543 };
0544
0545 Int_t nRunType_;
0546
0547 std::string log_category_;
0548
0549 protected:
0550 int initGeometry(edm::EventSetup const &iSetup);
0551 int loadChambers();
0552
0553 int GenerateMEPerChamber(DQMStore::IBooker &ibooker);
0554 virtual int ProcessWithMEMap2(BookingHelper &bh, ME2IdsKey key) { return 0; };
0555 virtual int ProcessWithMEMap2WithEta(BookingHelper &bh, ME3IdsKey key) { return 0; };
0556 virtual int ProcessWithMEMap2AbsReWithEta(BookingHelper &bh, ME3IdsKey key) { return 0; };
0557 virtual int ProcessWithMEMap3(BookingHelper &bh, ME3IdsKey key) { return 0; };
0558 virtual int ProcessWithMEMap4(BookingHelper &bh, ME4IdsKey key) { return 0; };
0559 virtual int ProcessWithMEMap5(BookingHelper &bh, ME5IdsKey key) { return 0; };
0560
0561 virtual int ProcessWithMEMap2WithChamber(BookingHelper &bh, ME3IdsKey key) { return 0; };
0562
0563
0564 virtual int ProcessWithMEMap2WithEtaCh(BookingHelper &bh, ME4IdsKey key) { return 0; };
0565
0566
0567 virtual int ProcessWithMEMap4WithChamber(BookingHelper &bh, ME4IdsKey key) { return 0; };
0568 virtual int ProcessWithMEMap5WithChamber(BookingHelper &bh, ME5IdsKey key) { return 0; };
0569
0570 int keyToRegion(ME2IdsKey key) { return std::get<0>(key); };
0571 int keyToRegion(ME3IdsKey key) { return std::get<0>(key); };
0572 int keyToRegion(ME4IdsKey key) { return std::get<0>(key); };
0573 int keyToRegion(ME5IdsKey key) { return std::get<0>(key); };
0574 int keyToStation(ME2IdsKey key) { return std::get<1>(key); };
0575 int keyToStation(ME3IdsKey key) { return std::get<1>(key); };
0576 int keyToStation(ME4IdsKey key) { return std::get<1>(key); };
0577 int keyToStation(ME5IdsKey key) { return std::get<1>(key); };
0578 int keyToLayer(ME3IdsKey key) { return std::get<2>(key); };
0579 int keyToLayer(ME4IdsKey key) { return std::get<2>(key); };
0580 int keyToLayer(ME5IdsKey key) { return std::get<2>(key); };
0581 int keyToModule(ME4IdsKey key) { return std::get<3>(key); };
0582 int keyToModule(ME5IdsKey key) { return std::get<3>(key); };
0583 int keyToChamber(ME4IdsKey key) { return std::get<3>(key); };
0584 int keyToChamber(ME5IdsKey key) { return std::get<4>(key); };
0585
0586 int keyToChamber(ME3IdsKey key) { return std::get<2>(key); };
0587
0588 int keyToIEta(ME4IdsKey key) { return std::get<3>(key); };
0589 int keyToIEta(ME5IdsKey key) { return std::get<4>(key); };
0590
0591 ME2IdsKey key3Tokey2(ME3IdsKey key) {
0592 auto keyNew = ME2IdsKey{keyToRegion(key), keyToStation(key)};
0593 return keyNew;
0594 };
0595
0596 ME3IdsKey key4Tokey3(ME4IdsKey key) {
0597 auto keyNew = ME3IdsKey{keyToRegion(key), keyToStation(key), keyToLayer(key)};
0598 return keyNew;
0599 };
0600
0601 ME4IdsKey key5Tokey4(ME5IdsKey key) {
0602 auto keyNew = ME4IdsKey{keyToRegion(key), keyToStation(key), keyToLayer(key), keyToModule(key)};
0603 return keyNew;
0604 };
0605
0606 int SortingLayers(std::vector<ME4IdsKey> &listLayers);
0607 dqm::impl::MonitorElement *CreateSummaryHist(DQMStore::IBooker &ibooker, TString strName);
0608
0609 template <typename T>
0610 inline bool checkRefs(const std::vector<T *> &);
0611
0612 int getNumEtaPartitions(const GEMStation *);
0613 inline int getVFATNumber(const int, const int, const int);
0614 inline int getVFATNumberGE11(const int, const int, const int);
0615 inline int getVFATNumberByDigi(const int, const int, const int);
0616 inline int getIEtaFromVFAT(const int station, const int vfat);
0617 inline int getIEtaFromVFATGE0(const int vfat);
0618 inline int getIEtaFromVFATGE11(const int vfat);
0619 inline int getIEtaFromVFATGE21(const int vfat);
0620 inline int getMaxVFAT(const int);
0621 inline int getNumModule(const int);
0622 inline int getIdxModule(const int, const int);
0623 inline int getDetOccXBin(const int, const int, const int);
0624 inline Float_t restrictAngle(const Float_t fTheta, const Float_t fStart);
0625 inline std::string getNameDirLayer(ME3IdsKey key3);
0626 inline std::string getNameDirLayer(ME4IdsKey key4);
0627 inline std::string getNameDirChamber(ME4IdsKey key4);
0628
0629 const GEMGeometry *GEMGeometry_;
0630 edm::ESGetToken<GEMGeometry, MuonGeometryRecord> geomToken_;
0631
0632 std::vector<GEMDetId> listChamberId_;
0633 std::map<GEMDetId, std::vector<const GEMEtaPartition *>> mapEtaPartition_;
0634
0635 std::map<ME2IdsKey, bool> MEMap2Check_;
0636 std::map<ME3IdsKey, bool> MEMap2WithEtaCheck_;
0637 std::map<ME3IdsKey, bool> MEMap2AbsReWithEtaCheck_;
0638
0639 std::map<ME3IdsKey, bool> MEMap2WithChCheck_;
0640
0641
0642 std::map<ME4IdsKey, bool> MEMap2WithEtaChCheck_;
0643
0644 std::map<ME3IdsKey, bool> MEMap3Check_;
0645 std::map<ME4IdsKey, bool> MEMap4Check_;
0646 std::map<ME4IdsKey, bool> MEMap4WithChCheck_;
0647 std::map<ME5IdsKey, bool> MEMap5WithChCheck_;
0648 std::map<ME5IdsKey, bool> MEMap5Check_;
0649
0650 int nMaxNumCh_;
0651 std::map<ME3IdsKey, MEStationInfo> mapStationInfo_;
0652 std::map<ME4IdsKey, int> mapStationToIdx_;
0653 };
0654
0655
0656 template <typename T>
0657 inline bool GEMDQMBase::checkRefs(const std::vector<T *> &refs) {
0658 if (refs.empty())
0659 return false;
0660 if (refs.front() == nullptr)
0661 return false;
0662 return true;
0663 }
0664
0665
0666 inline int GEMDQMBase::getMaxVFAT(const int station) {
0667 if (station == 0)
0668 return GEMeMap::maxVFatGE0_;
0669 if (station == 1)
0670 return GEMeMap::maxVFatGE11_;
0671 else if (station == 2)
0672 return GEMeMap::maxVFatGE21_ / 2;
0673 else
0674 return -1;
0675 }
0676
0677 inline int GEMDQMBase::getNumModule(const int station) {
0678 if (station == 0)
0679 return 1;
0680 if (station == 1)
0681 return 1;
0682 else if (station == 2)
0683 return 4;
0684 else
0685 return -1;
0686 }
0687
0688 inline int GEMDQMBase::getIdxModule(const int station, const int chamberType) {
0689 if (station == 0)
0690 return 1;
0691 if (station == 1)
0692 return 1;
0693 else if (station == 2)
0694 return chamberType - 20;
0695 else
0696 return -1;
0697 }
0698
0699 inline int GEMDQMBase::getVFATNumber(const int station, const int ieta, const int vfat_phi) {
0700 if (station == 1)
0701 return getVFATNumberGE11(station, ieta, vfat_phi);
0702 return getVFATNumberGE11(station, ieta, vfat_phi);
0703 }
0704
0705 inline int GEMDQMBase::getVFATNumberGE11(const int station, const int ieta, const int vfat_phi) {
0706 return vfat_phi * GEMeMap::maxiEtaIdGE11_ + (GEMeMap::maxiEtaIdGE11_ - ieta);
0707 }
0708
0709 inline int GEMDQMBase::getVFATNumberByDigi(const int station, const int ieta, const int digi) {
0710 const int vfat_phi = digi / GEMeMap::maxChan_;
0711 return getVFATNumber(station, ieta, vfat_phi);
0712 }
0713
0714 inline int GEMDQMBase::getIEtaFromVFAT(const int station, const int vfat) {
0715 if (station == 0)
0716 return getIEtaFromVFATGE0(vfat);
0717 if (station == 1)
0718 return getIEtaFromVFATGE11(vfat);
0719 if (station == 2)
0720 return getIEtaFromVFATGE21(vfat);
0721 return getIEtaFromVFATGE11(vfat);
0722 }
0723
0724 inline int GEMDQMBase::getIEtaFromVFATGE0(const int vfat) {
0725 return GEMeMap::maxiEtaIdGE0_ - (vfat % GEMeMap::maxiEtaIdGE0_);
0726 }
0727
0728 inline int GEMDQMBase::getIEtaFromVFATGE11(const int vfat) {
0729 return GEMeMap::maxiEtaIdGE11_ - (vfat % GEMeMap::maxiEtaIdGE11_);
0730 }
0731
0732 inline int GEMDQMBase::getIEtaFromVFATGE21(const int vfat) {
0733 return GEMeMap::maxiEtaIdGE21_ - (vfat % GEMeMap::maxiEtaIdGE21_);
0734 }
0735
0736 inline int GEMDQMBase::getDetOccXBin(const int chamber, const int layer, const int n_chambers) {
0737 return n_chambers * (chamber - 1) + layer;
0738 }
0739
0740 inline Float_t GEMDQMBase::restrictAngle(const Float_t fTheta, const Float_t fStart) {
0741 Float_t fLoop = (fTheta - fStart) / (2 * M_PI);
0742 int nLoop = (fLoop >= 0 ? (int)fLoop : (int)fLoop - 1);
0743 return fTheta - nLoop * 2 * M_PI;
0744 }
0745
0746 inline std::string GEMDQMBase::getNameDirLayer(ME3IdsKey key3) {
0747 auto nStation = keyToStation(key3);
0748 char cRegion = (keyToRegion(key3) > 0 ? 'P' : 'M');
0749 auto nLayer = keyToLayer(key3);
0750 return std::string(Form("GE%i1-%c-L%i", nStation, cRegion, nLayer));
0751 }
0752
0753 inline std::string GEMDQMBase::getNameDirLayer(ME4IdsKey key4) {
0754 auto nStation = keyToStation(key4);
0755 char cRegion = (keyToRegion(key4) > 0 ? 'P' : 'M');
0756 auto nLayer = keyToLayer(key4);
0757 if (nStation == 2) {
0758 auto nModule = keyToModule(key4);
0759 return std::string(Form("GE%i1-%c-L%i-M%i", nStation, cRegion, nLayer, nModule));
0760 }
0761 return std::string(Form("GE%i1-%c-L%i", nStation, cRegion, nLayer));
0762 }
0763
0764 inline std::string GEMDQMBase::getNameDirChamber(ME4IdsKey key4) {
0765 auto nStation = keyToStation(key4);
0766 char cRegion = (keyToRegion(key4) > 0 ? 'P' : 'M');
0767 auto nChamber = keyToChamber(key4);
0768 return std::string(Form("GE%i1-%c-Ch%i", nStation, cRegion, nChamber));
0769 }
0770 #endif
