File indexing completed on 2024-04-06 12:07:47
0001
0002
0003
0004
0005
0006
0007
0008
0009
0010
0011
0012
0013
0014
0015
0016 #include "DQM/L1TMonitor/interface/L1ExtraDQM.h"
0017
0018
0019 #include <iostream>
0020 #include <iomanip>
0021 #include <memory>
0022 #include <string>
0023
0024
0025 L1ExtraDQM::L1ExtraDQM(const edm::ParameterSet& paramSet)
0026 :
0027 m_retrieveL1Extra(paramSet.getParameter<edm::ParameterSet>("L1ExtraInputTags"), consumesCollector()),
0028 L1ExtraIsoTauJetSource(paramSet.getParameter<edm::InputTag>("L1ExtraIsoTauJetSource_")),
0029 m_dirName(paramSet.getParameter<std::string>("DirName")),
0030 m_stage1_layer2_(paramSet.getParameter<bool>("stage1_layer2_")),
0031
0032 m_nrBxInEventGmt(paramSet.getParameter<int>("NrBxInEventGmt")),
0033 m_nrBxInEventGct(paramSet.getParameter<int>("NrBxInEventGct")),
0034
0035 m_resetModule(true),
0036 m_currentRun(-99),
0037
0038 m_nrEvJob(0),
0039 m_nrEvRun(0),
0040
0041 m_histTokens(consumesCollector(), true) {
0042
0043 if ((m_nrBxInEventGmt > 0) && ((m_nrBxInEventGmt % 2) == 0)) {
0044 m_nrBxInEventGmt = m_nrBxInEventGmt - 1;
0045
0046 edm::LogInfo("L1ExtraDQM") << "\nWARNING: Number of bunch crossing to be monitored for GMT rounded to: "
0047 << m_nrBxInEventGmt << "\n The number must be an odd number!\n"
0048 << std::endl;
0049 }
0050
0051 if ((m_nrBxInEventGct > 0) && ((m_nrBxInEventGct % 2) == 0)) {
0052 m_nrBxInEventGct = m_nrBxInEventGct - 1;
0053
0054 edm::LogInfo("L1ExtraDQM") << "\nWARNING: Number of bunch crossing to be monitored for GCT rounded to: "
0055 << m_nrBxInEventGct << "\n The number must be an odd number!\n"
0056 << std::endl;
0057 }
0058
0059 if (m_stage1_layer2_ == true) {
0060 m_tagL1ExtraIsoTauJetTok =
0061 consumes<l1extra::L1JetParticleCollection>(paramSet.getParameter<edm::InputTag>("L1ExtraIsoTauJetSource_"));
0062 }
0063
0064 m_meAnalysisL1ExtraMuon.reserve(m_nrBxInEventGmt);
0065 m_meAnalysisL1ExtraIsoEG.reserve(m_nrBxInEventGct);
0066 m_meAnalysisL1ExtraNoIsoEG.reserve(m_nrBxInEventGct);
0067 m_meAnalysisL1ExtraCenJet.reserve(m_nrBxInEventGct);
0068 m_meAnalysisL1ExtraForJet.reserve(m_nrBxInEventGct);
0069 m_meAnalysisL1ExtraTauJet.reserve(m_nrBxInEventGct);
0070 if (m_stage1_layer2_ == true) {
0071 m_meAnalysisL1ExtraIsoTauJet.reserve(m_nrBxInEventGct);
0072 }
0073 m_meAnalysisL1ExtraETT.reserve(m_nrBxInEventGct);
0074 m_meAnalysisL1ExtraETM.reserve(m_nrBxInEventGct);
0075 m_meAnalysisL1ExtraHTT.reserve(m_nrBxInEventGct);
0076 m_meAnalysisL1ExtraHTM.reserve(m_nrBxInEventGct);
0077 m_meAnalysisL1ExtraHfBitCounts.reserve(m_nrBxInEventGct);
0078 m_meAnalysisL1ExtraHfRingEtSums.reserve(m_nrBxInEventGct);
0079 }
0080
0081
0082 L1ExtraDQM::~L1ExtraDQM() {
0083
0084 }
0085
0086 void L1ExtraDQM::analyzeL1ExtraMuon(const edm::Event& iEvent, const edm::EventSetup& evSetup) {
0087 bool bookEta = true;
0088 bool bookPhi = true;
0089
0090 bool isL1Coll = true;
0091
0092 for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGmt; ++iBxInEvent) {
0093 int bxInEvent = iBxInEvent + (m_nrBxInEventGmt + 1) / 2 - m_nrBxInEventGmt;
0094
0095 (m_meAnalysisL1ExtraMuon.at(iBxInEvent))
0096 ->fillNrObjects(m_retrieveL1Extra.l1ExtraMuon(), m_retrieveL1Extra.validL1ExtraMuon(), isL1Coll, bxInEvent);
0097 (m_meAnalysisL1ExtraMuon.at(iBxInEvent))
0098 ->fillPtPhiEta(m_retrieveL1Extra.l1ExtraMuon(),
0099 m_retrieveL1Extra.validL1ExtraMuon(),
0100 bookPhi,
0101 bookEta,
0102 isL1Coll,
0103 bxInEvent);
0104 }
0105 }
0106
0107 void L1ExtraDQM::analyzeL1ExtraIsoEG(const edm::Event& iEvent, const edm::EventSetup& evSetup) {
0108 bool bookEta = true;
0109 bool bookPhi = true;
0110
0111 bool isL1Coll = true;
0112
0113 for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {
0114 int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2 - m_nrBxInEventGct;
0115
0116 (m_meAnalysisL1ExtraIsoEG.at(iBxInEvent))
0117 ->fillNrObjects(m_retrieveL1Extra.l1ExtraIsoEG(), m_retrieveL1Extra.validL1ExtraIsoEG(), isL1Coll, bxInEvent);
0118 (m_meAnalysisL1ExtraIsoEG.at(iBxInEvent))
0119 ->fillPtPhiEta(m_retrieveL1Extra.l1ExtraIsoEG(),
0120 m_retrieveL1Extra.validL1ExtraIsoEG(),
0121 bookPhi,
0122 bookEta,
0123 isL1Coll,
0124 bxInEvent);
0125 }
0126 }
0127
0128 void L1ExtraDQM::analyzeL1ExtraNoIsoEG(const edm::Event& iEvent, const edm::EventSetup& evSetup) {
0129 bool bookEta = true;
0130 bool bookPhi = true;
0131
0132 bool isL1Coll = true;
0133
0134 for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {
0135 int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2 - m_nrBxInEventGct;
0136
0137 (m_meAnalysisL1ExtraNoIsoEG.at(iBxInEvent))
0138 ->fillNrObjects(
0139 m_retrieveL1Extra.l1ExtraNoIsoEG(), m_retrieveL1Extra.validL1ExtraNoIsoEG(), isL1Coll, bxInEvent);
0140 (m_meAnalysisL1ExtraNoIsoEG.at(iBxInEvent))
0141 ->fillPtPhiEta(m_retrieveL1Extra.l1ExtraNoIsoEG(),
0142 m_retrieveL1Extra.validL1ExtraNoIsoEG(),
0143 bookPhi,
0144 bookEta,
0145 isL1Coll,
0146 bxInEvent);
0147 }
0148 }
0149
0150 void L1ExtraDQM::analyzeL1ExtraCenJet(const edm::Event& iEvent, const edm::EventSetup& evSetup) {
0151 bool bookEta = true;
0152 bool bookPhi = true;
0153
0154 bool isL1Coll = true;
0155
0156 for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {
0157 int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2 - m_nrBxInEventGct;
0158
0159 (m_meAnalysisL1ExtraCenJet.at(iBxInEvent))
0160 ->fillNrObjects(m_retrieveL1Extra.l1ExtraCenJet(), m_retrieveL1Extra.validL1ExtraCenJet(), isL1Coll, bxInEvent);
0161 (m_meAnalysisL1ExtraCenJet.at(iBxInEvent))
0162 ->fillEtPhiEta(m_retrieveL1Extra.l1ExtraCenJet(),
0163 m_retrieveL1Extra.validL1ExtraCenJet(),
0164 bookPhi,
0165 bookEta,
0166 isL1Coll,
0167 bxInEvent);
0168 }
0169 }
0170
0171 void L1ExtraDQM::analyzeL1ExtraForJet(const edm::Event& iEvent, const edm::EventSetup& evSetup) {
0172 bool bookPhi = true;
0173 bool bookEta = true;
0174
0175 bool isL1Coll = true;
0176
0177 for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {
0178 int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2 - m_nrBxInEventGct;
0179
0180 (m_meAnalysisL1ExtraForJet.at(iBxInEvent))
0181 ->fillNrObjects(m_retrieveL1Extra.l1ExtraForJet(), m_retrieveL1Extra.validL1ExtraForJet(), isL1Coll, bxInEvent);
0182 (m_meAnalysisL1ExtraForJet.at(iBxInEvent))
0183 ->fillEtPhiEta(m_retrieveL1Extra.l1ExtraForJet(),
0184 m_retrieveL1Extra.validL1ExtraForJet(),
0185 bookPhi,
0186 bookEta,
0187 isL1Coll,
0188 bxInEvent);
0189 }
0190 }
0191
0192 void L1ExtraDQM::analyzeL1ExtraTauJet(const edm::Event& iEvent, const edm::EventSetup& evSetup) {
0193 bool bookPhi = true;
0194 bool bookEta = true;
0195
0196 bool isL1Coll = true;
0197
0198 for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {
0199 int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2 - m_nrBxInEventGct;
0200
0201 (m_meAnalysisL1ExtraTauJet.at(iBxInEvent))
0202 ->fillNrObjects(m_retrieveL1Extra.l1ExtraTauJet(), m_retrieveL1Extra.validL1ExtraTauJet(), isL1Coll, bxInEvent);
0203 (m_meAnalysisL1ExtraTauJet.at(iBxInEvent))
0204 ->fillEtPhiEta(m_retrieveL1Extra.l1ExtraTauJet(),
0205 m_retrieveL1Extra.validL1ExtraTauJet(),
0206 bookPhi,
0207 bookEta,
0208 isL1Coll,
0209 bxInEvent);
0210 }
0211 }
0212
0213 void L1ExtraDQM::analyzeL1ExtraIsoTauJet(const edm::Event& iEvent, const edm::EventSetup& evSetup) {
0214 bool bookPhi = true;
0215 bool bookEta = true;
0216
0217 bool isL1Coll = true;
0218
0219 bool m_validL1ExtraIsoTauJet;
0220
0221 edm::Handle<l1extra::L1JetParticleCollection> collL1ExtraIsoTauJet;
0222 iEvent.getByToken(m_tagL1ExtraIsoTauJetTok, collL1ExtraIsoTauJet);
0223
0224 const l1extra::L1JetParticleCollection* m_l1ExtraIsoTauJet;
0225
0226 if (collL1ExtraIsoTauJet.isValid()) {
0227 m_validL1ExtraIsoTauJet = true;
0228 m_l1ExtraIsoTauJet = collL1ExtraIsoTauJet.product();
0229 } else {
0230 LogDebug("L1RetrieveL1Extra") << "\n l1extra::L1JetParticleCollection with input tag \n "
0231 << "m_tagL1ExtraIsoTauJet"
0232 << "\n not found in the event.\n"
0233 << "\n Return pointer 0 and false validity tag." << std::endl;
0234
0235 m_validL1ExtraIsoTauJet = false;
0236 m_l1ExtraIsoTauJet = nullptr;
0237 }
0238
0239 for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {
0240 int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2 - m_nrBxInEventGct;
0241 (m_meAnalysisL1ExtraIsoTauJet.at(iBxInEvent))
0242 ->fillNrObjects(m_l1ExtraIsoTauJet, m_validL1ExtraIsoTauJet, isL1Coll, bxInEvent);
0243 (m_meAnalysisL1ExtraIsoTauJet.at(iBxInEvent))
0244 ->fillEtPhiEta(m_l1ExtraIsoTauJet, m_validL1ExtraIsoTauJet, bookPhi, bookEta, isL1Coll, bxInEvent);
0245 }
0246 }
0247
0248 void L1ExtraDQM::analyzeL1ExtraETT(const edm::Event& iEvent, const edm::EventSetup& evSetup) {
0249 bool isL1Coll = true;
0250
0251 for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {
0252 int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2 - m_nrBxInEventGct;
0253
0254 (m_meAnalysisL1ExtraETT.at(iBxInEvent))
0255 ->fillEtTotal(m_retrieveL1Extra.l1ExtraETT(), m_retrieveL1Extra.validL1ExtraETT(), isL1Coll, bxInEvent);
0256 }
0257 }
0258
0259 void L1ExtraDQM::analyzeL1ExtraETM(const edm::Event& iEvent, const edm::EventSetup& evSetup) {
0260 bool bookPhi = true;
0261 bool bookEta = false;
0262
0263 bool isL1Coll = true;
0264
0265 for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {
0266 int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2 - m_nrBxInEventGct;
0267
0268 (m_meAnalysisL1ExtraETM.at(iBxInEvent))
0269 ->fillEtPhiEta(
0270 m_retrieveL1Extra.l1ExtraETM(), m_retrieveL1Extra.validL1ExtraETM(), bookPhi, bookEta, isL1Coll, bxInEvent);
0271 }
0272 }
0273
0274 void L1ExtraDQM::analyzeL1ExtraHTT(const edm::Event& iEvent, const edm::EventSetup& evSetup) {
0275 bool isL1Coll = true;
0276
0277 for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {
0278 int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2 - m_nrBxInEventGct;
0279
0280 (m_meAnalysisL1ExtraHTT.at(iBxInEvent))
0281 ->fillEtTotal(m_retrieveL1Extra.l1ExtraHTT(), m_retrieveL1Extra.validL1ExtraHTT(), isL1Coll, bxInEvent);
0282 }
0283 }
0284
0285 void L1ExtraDQM::analyzeL1ExtraHTM(const edm::Event& iEvent, const edm::EventSetup& evSetup) {
0286 bool bookPhi = true;
0287 bool bookEta = false;
0288
0289 bool isL1Coll = true;
0290
0291 for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {
0292 int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2 - m_nrBxInEventGct;
0293
0294 (m_meAnalysisL1ExtraHTM.at(iBxInEvent))
0295 ->fillEtPhiEta(
0296 m_retrieveL1Extra.l1ExtraHTM(), m_retrieveL1Extra.validL1ExtraHTM(), bookPhi, bookEta, isL1Coll, bxInEvent);
0297 }
0298 }
0299
0300 void L1ExtraDQM::analyzeL1ExtraHfBitCounts(const edm::Event& iEvent, const edm::EventSetup& evSetup) {
0301 bool isL1Coll = true;
0302
0303 for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {
0304 int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2 - m_nrBxInEventGct;
0305
0306 for (int iCount = 0; iCount < l1extra::L1HFRings::kNumRings; ++iCount) {
0307 (m_meAnalysisL1ExtraHfBitCounts.at(iBxInEvent))
0308 ->fillHfBitCounts(m_retrieveL1Extra.l1ExtraHfBitCounts(),
0309 m_retrieveL1Extra.validL1ExtraHfBitCounts(),
0310 iCount,
0311 isL1Coll,
0312 bxInEvent);
0313 }
0314 }
0315 }
0316
0317 void L1ExtraDQM::analyzeL1ExtraHfRingEtSums(const edm::Event& iEvent, const edm::EventSetup& evSetup) {
0318 bool isL1Coll = true;
0319
0320 for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {
0321 int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2 - m_nrBxInEventGct;
0322
0323 for (int iCount = 0; iCount < l1extra::L1HFRings::kNumRings; ++iCount) {
0324 (m_meAnalysisL1ExtraHfRingEtSums.at(iBxInEvent))
0325 ->fillHfRingEtSums(m_retrieveL1Extra.l1ExtraHfRingEtSums(),
0326 m_retrieveL1Extra.validL1ExtraHfRingEtSums(),
0327 iCount,
0328 isL1Coll,
0329 bxInEvent);
0330 }
0331 }
0332 }
0333
0334 void L1ExtraDQM::dqmBeginRun(edm::Run const& iRun, edm::EventSetup const& evSetup) {}
0335
0336 void L1ExtraDQM::bookHistograms(DQMStore::IBooker& ibooker, edm::Run const&, edm::EventSetup const& evSetup) {
0337 m_nrEvRun = 0;
0338
0339 std::vector<L1GtObject> l1Obj;
0340
0341
0342
0343
0344
0345 l1Obj.clear();
0346 l1Obj.push_back(Mu);
0347 int nrMonElements = 5;
0348
0349 for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGmt; ++iBxInEvent) {
0350 m_meAnalysisL1ExtraMuon.push_back(
0351 new L1ExtraDQM::L1ExtraMonElement<l1extra::L1MuonParticleCollection>(m_histTokens, nrMonElements));
0352
0353 int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2 - m_nrBxInEventGct;
0354 int bxInEventHex = (bxInEvent + 16) % 16;
0355
0356 std::stringstream ss;
0357 std::string bxInEventHexString;
0358 ss << std::uppercase << std::hex << bxInEventHex;
0359 ss >> bxInEventHexString;
0360
0361 ibooker.setCurrentFolder(m_dirName + "/BxInEvent_" + bxInEventHexString);
0362
0363 (m_meAnalysisL1ExtraMuon.at(iBxInEvent))->bookhistograms(evSetup, ibooker, "L1_Mu", l1Obj);
0364 }
0365
0366
0367 l1Obj.clear();
0368 l1Obj.push_back(IsoEG);
0369 nrMonElements = 4;
0370
0371 for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {
0372 m_meAnalysisL1ExtraIsoEG.push_back(
0373 new L1ExtraDQM::L1ExtraMonElement<l1extra::L1EmParticleCollection>(m_histTokens, nrMonElements));
0374
0375 int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2 - m_nrBxInEventGct;
0376 int bxInEventHex = (bxInEvent + 16) % 16;
0377
0378 std::stringstream ss;
0379 std::string bxInEventHexString;
0380 ss << std::uppercase << std::hex << bxInEventHex;
0381 ss >> bxInEventHexString;
0382
0383 ibooker.setCurrentFolder(m_dirName + "/BxInEvent_" + bxInEventHexString);
0384
0385 (m_meAnalysisL1ExtraIsoEG.at(iBxInEvent))->bookhistograms(evSetup, ibooker, "L1_IsoEG", l1Obj);
0386 }
0387
0388
0389 l1Obj.clear();
0390 l1Obj.push_back(NoIsoEG);
0391 nrMonElements = 4;
0392
0393 for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {
0394 m_meAnalysisL1ExtraNoIsoEG.push_back(
0395 new L1ExtraDQM::L1ExtraMonElement<l1extra::L1EmParticleCollection>(m_histTokens, nrMonElements));
0396
0397 int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2 - m_nrBxInEventGct;
0398 int bxInEventHex = (bxInEvent + 16) % 16;
0399
0400 std::stringstream ss;
0401 std::string bxInEventHexString;
0402 ss << std::uppercase << std::hex << bxInEventHex;
0403 ss >> bxInEventHexString;
0404
0405
0406 ibooker.setCurrentFolder(m_dirName + "/BxInEvent_" + bxInEventHexString);
0407
0408
0409 (m_meAnalysisL1ExtraNoIsoEG.at(iBxInEvent))->bookhistograms(evSetup, ibooker, "L1_NoIsoEG", l1Obj);
0410 }
0411
0412
0413 l1Obj.clear();
0414 l1Obj.push_back(CenJet);
0415 nrMonElements = 4;
0416
0417 for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {
0418 m_meAnalysisL1ExtraCenJet.push_back(
0419 new L1ExtraDQM::L1ExtraMonElement<l1extra::L1JetParticleCollection>(m_histTokens, nrMonElements));
0420
0421 int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2 - m_nrBxInEventGct;
0422 int bxInEventHex = (bxInEvent + 16) % 16;
0423
0424 std::stringstream ss;
0425 std::string bxInEventHexString;
0426 ss << std::uppercase << std::hex << bxInEventHex;
0427 ss >> bxInEventHexString;
0428
0429 ibooker.setCurrentFolder(m_dirName + "/BxInEvent_" + bxInEventHexString);
0430
0431 (m_meAnalysisL1ExtraCenJet.at(iBxInEvent))->bookhistograms(evSetup, ibooker, "L1_CenJet", l1Obj);
0432 }
0433
0434
0435 l1Obj.clear();
0436 l1Obj.push_back(ForJet);
0437
0438 for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {
0439 m_meAnalysisL1ExtraForJet.push_back(
0440 new L1ExtraDQM::L1ExtraMonElement<l1extra::L1JetParticleCollection>(m_histTokens, nrMonElements));
0441
0442 int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2 - m_nrBxInEventGct;
0443 int bxInEventHex = (bxInEvent + 16) % 16;
0444
0445 std::stringstream ss;
0446 std::string bxInEventHexString;
0447 ss << std::uppercase << std::hex << bxInEventHex;
0448 ss >> bxInEventHexString;
0449
0450 ibooker.setCurrentFolder(m_dirName + "/BxInEvent_" + bxInEventHexString);
0451
0452 (m_meAnalysisL1ExtraForJet.at(iBxInEvent))->bookhistograms(evSetup, ibooker, "L1_ForJet", l1Obj);
0453 }
0454
0455
0456 l1Obj.clear();
0457 l1Obj.push_back(TauJet);
0458
0459 for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {
0460 m_meAnalysisL1ExtraTauJet.push_back(
0461 new L1ExtraDQM::L1ExtraMonElement<l1extra::L1JetParticleCollection>(m_histTokens, nrMonElements));
0462
0463 int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2 - m_nrBxInEventGct;
0464 int bxInEventHex = (bxInEvent + 16) % 16;
0465
0466 std::stringstream ss;
0467 std::string bxInEventHexString;
0468 ss << std::uppercase << std::hex << bxInEventHex;
0469 ss >> bxInEventHexString;
0470
0471 ibooker.setCurrentFolder(m_dirName + "/BxInEvent_" + bxInEventHexString);
0472
0473 (m_meAnalysisL1ExtraTauJet.at(iBxInEvent))->bookhistograms(evSetup, ibooker, "L1_TauJet", l1Obj);
0474 }
0475
0476 if (m_stage1_layer2_ == true) {
0477 l1Obj.clear();
0478 l1Obj.push_back(TauJet);
0479 nrMonElements = 4;
0480
0481 for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {
0482 m_meAnalysisL1ExtraIsoTauJet.push_back(
0483 new L1ExtraDQM::L1ExtraMonElement<l1extra::L1JetParticleCollection>(m_histTokens, nrMonElements));
0484
0485 int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2 - m_nrBxInEventGct;
0486 int bxInEventHex = (bxInEvent + 16) % 16;
0487
0488 std::stringstream ss;
0489 std::string bxInEventHexString;
0490 ss << std::uppercase << std::hex << bxInEventHex;
0491 ss >> bxInEventHexString;
0492
0493 ibooker.setCurrentFolder(m_dirName + "/BxInEvent_" + bxInEventHexString);
0494
0495 (m_meAnalysisL1ExtraIsoTauJet.at(iBxInEvent))->bookhistograms(evSetup, ibooker, "L1_IsoTauJet", l1Obj);
0496 }
0497 }
0498
0499
0500 l1Obj.clear();
0501 l1Obj.push_back(ETT);
0502 nrMonElements = 1;
0503
0504 bool bookPhi = false;
0505 bool bookEta = false;
0506
0507 for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {
0508 m_meAnalysisL1ExtraETT.push_back(
0509 new L1ExtraDQM::L1ExtraMonElement<l1extra::L1EtMissParticleCollection>(m_histTokens, nrMonElements));
0510
0511 int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2 - m_nrBxInEventGct;
0512 int bxInEventHex = (bxInEvent + 16) % 16;
0513
0514 std::stringstream ss;
0515 std::string bxInEventHexString;
0516 ss << std::uppercase << std::hex << bxInEventHex;
0517 ss >> bxInEventHexString;
0518
0519 ibooker.setCurrentFolder(m_dirName + "/BxInEvent_" + bxInEventHexString);
0520
0521 (m_meAnalysisL1ExtraETT.at(iBxInEvent))->bookhistograms(evSetup, ibooker, "L1_ETT", l1Obj, bookPhi, bookEta);
0522 }
0523
0524
0525 l1Obj.clear();
0526 l1Obj.push_back(ETM);
0527 nrMonElements = 2;
0528
0529 bookPhi = true;
0530 bookEta = false;
0531
0532 for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {
0533 m_meAnalysisL1ExtraETM.push_back(
0534 new L1ExtraDQM::L1ExtraMonElement<l1extra::L1EtMissParticleCollection>(m_histTokens, nrMonElements));
0535 int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2 - m_nrBxInEventGct;
0536 int bxInEventHex = (bxInEvent + 16) % 16;
0537
0538 std::stringstream ss;
0539 std::string bxInEventHexString;
0540 ss << std::uppercase << std::hex << bxInEventHex;
0541 ss >> bxInEventHexString;
0542
0543 ibooker.setCurrentFolder(m_dirName + "/BxInEvent_" + bxInEventHexString);
0544
0545 (m_meAnalysisL1ExtraETM.at(iBxInEvent))->bookhistograms(evSetup, ibooker, "L1_ETM", l1Obj, bookPhi, bookEta);
0546 }
0547
0548
0549 l1Obj.clear();
0550 l1Obj.push_back(HTT);
0551 nrMonElements = 1;
0552
0553 bookPhi = false;
0554 bookEta = false;
0555
0556 for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {
0557 m_meAnalysisL1ExtraHTT.push_back(
0558 new L1ExtraDQM::L1ExtraMonElement<l1extra::L1EtMissParticleCollection>(m_histTokens, nrMonElements));
0559 int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2 - m_nrBxInEventGct;
0560 int bxInEventHex = (bxInEvent + 16) % 16;
0561
0562 std::stringstream ss;
0563 std::string bxInEventHexString;
0564 ss << std::uppercase << std::hex << bxInEventHex;
0565 ss >> bxInEventHexString;
0566
0567 ibooker.setCurrentFolder(m_dirName + "/BxInEvent_" + bxInEventHexString);
0568
0569 (m_meAnalysisL1ExtraHTT.at(iBxInEvent))->bookhistograms(evSetup, ibooker, "L1_HTT", l1Obj, bookPhi, bookEta);
0570 }
0571
0572
0573 l1Obj.clear();
0574 l1Obj.push_back(HTM);
0575 nrMonElements = 2;
0576
0577 bookPhi = true;
0578 bookEta = false;
0579
0580 for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {
0581 m_meAnalysisL1ExtraHTM.push_back(
0582 new L1ExtraDQM::L1ExtraMonElement<l1extra::L1EtMissParticleCollection>(m_histTokens, nrMonElements));
0583 int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2 - m_nrBxInEventGct;
0584 int bxInEventHex = (bxInEvent + 16) % 16;
0585
0586 std::stringstream ss;
0587 std::string bxInEventHexString;
0588 ss << std::uppercase << std::hex << bxInEventHex;
0589 ss >> bxInEventHexString;
0590
0591 ibooker.setCurrentFolder(m_dirName + "/BxInEvent_" + bxInEventHexString);
0592
0593 if (m_stage1_layer2_ == false) {
0594 (m_meAnalysisL1ExtraHTM.at(iBxInEvent))->bookhistograms(evSetup, ibooker, "L1_HTM", l1Obj, bookPhi, bookEta);
0595 } else {
0596 (m_meAnalysisL1ExtraHTM.at(iBxInEvent))->bookhistograms(evSetup, ibooker, "L1_HTMHTT", l1Obj, bookPhi, bookEta);
0597 }
0598 }
0599
0600
0601 l1Obj.clear();
0602 l1Obj.push_back(HfBitCounts);
0603 nrMonElements = 1;
0604
0605 bookPhi = false;
0606 bookEta = false;
0607
0608 for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {
0609 m_meAnalysisL1ExtraHfBitCounts.push_back(
0610 new L1ExtraDQM::L1ExtraMonElement<l1extra::L1HFRingsCollection>(m_histTokens, nrMonElements));
0611 int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2 - m_nrBxInEventGct;
0612 int bxInEventHex = (bxInEvent + 16) % 16;
0613
0614 std::stringstream ss;
0615 std::string bxInEventHexString;
0616 ss << std::uppercase << std::hex << bxInEventHex;
0617 ss >> bxInEventHexString;
0618
0619 ibooker.setCurrentFolder(m_dirName + "/BxInEvent_" + bxInEventHexString);
0620
0621 (m_meAnalysisL1ExtraHfBitCounts.at(iBxInEvent))
0622 ->bookhistograms(evSetup, ibooker, "L1_HfBitCounts", l1Obj, bookPhi, bookEta);
0623 }
0624
0625
0626 l1Obj.clear();
0627 l1Obj.push_back(HfRingEtSums);
0628 nrMonElements = 1;
0629
0630 bookPhi = false;
0631 bookEta = false;
0632
0633 for (int iBxInEvent = 0; iBxInEvent < m_nrBxInEventGct; ++iBxInEvent) {
0634 m_meAnalysisL1ExtraHfRingEtSums.push_back(
0635 new L1ExtraDQM::L1ExtraMonElement<l1extra::L1HFRingsCollection>(m_histTokens, nrMonElements));
0636 int bxInEvent = iBxInEvent + (m_nrBxInEventGct + 1) / 2 - m_nrBxInEventGct;
0637 int bxInEventHex = (bxInEvent + 16) % 16;
0638
0639 std::stringstream ss;
0640 std::string bxInEventHexString;
0641 ss << std::uppercase << std::hex << bxInEventHex;
0642 ss >> bxInEventHexString;
0643
0644 ibooker.setCurrentFolder(m_dirName + "/BxInEvent_" + bxInEventHexString);
0645
0646 if (m_stage1_layer2_ == false) {
0647 (m_meAnalysisL1ExtraHfRingEtSums.at(iBxInEvent))
0648 ->bookhistograms(evSetup, ibooker, "L1_HfRingEtSums", l1Obj, bookPhi, bookEta);
0649 }
0650 if (m_stage1_layer2_ == true) {
0651 (m_meAnalysisL1ExtraHfRingEtSums.at(iBxInEvent))
0652 ->bookhistograms(evSetup, ibooker, "L1_IsoTau_replace_Hf", l1Obj, bookPhi, bookEta);
0653 }
0654 }
0655 }
0656
0657
0658 void L1ExtraDQM::analyze(const edm::Event& iEvent, const edm::EventSetup& evSetup) {
0659 ++m_nrEvJob;
0660 ++m_nrEvRun;
0661
0662 m_retrieveL1Extra.retrieveL1ExtraObjects(iEvent, evSetup);
0663
0664 analyzeL1ExtraMuon(iEvent, evSetup);
0665 analyzeL1ExtraIsoEG(iEvent, evSetup);
0666 analyzeL1ExtraNoIsoEG(iEvent, evSetup);
0667 analyzeL1ExtraCenJet(iEvent, evSetup);
0668 analyzeL1ExtraForJet(iEvent, evSetup);
0669 analyzeL1ExtraTauJet(iEvent, evSetup);
0670 analyzeL1ExtraETT(iEvent, evSetup);
0671 analyzeL1ExtraETM(iEvent, evSetup);
0672 analyzeL1ExtraHTT(iEvent, evSetup);
0673 analyzeL1ExtraHTM(iEvent, evSetup);
0674 analyzeL1ExtraHfBitCounts(iEvent, evSetup);
0675 analyzeL1ExtraHfRingEtSums(iEvent, evSetup);
0676
0677 if (m_stage1_layer2_ == true) {
0678 analyzeL1ExtraIsoTauJet(iEvent, evSetup);
0679 }
0680 }
0681
0682 void L1ExtraDQM::dqmEndRun(const edm::Run& run, const edm::EventSetup& evSetup) {
0683
0684
0685 for (std::vector<L1ExtraMonElement<l1extra::L1MuonParticleCollection>*>::iterator iterME =
0686 m_meAnalysisL1ExtraMuon.begin();
0687 iterME != m_meAnalysisL1ExtraMuon.end();
0688 ++iterME) {
0689 delete *iterME;
0690 }
0691 m_meAnalysisL1ExtraMuon.clear();
0692
0693 for (std::vector<L1ExtraMonElement<l1extra::L1EmParticleCollection>*>::iterator iterME =
0694 m_meAnalysisL1ExtraIsoEG.begin();
0695 iterME != m_meAnalysisL1ExtraIsoEG.end();
0696 ++iterME) {
0697 delete *iterME;
0698 }
0699 m_meAnalysisL1ExtraIsoEG.clear();
0700
0701 for (std::vector<L1ExtraMonElement<l1extra::L1EmParticleCollection>*>::iterator iterME =
0702 m_meAnalysisL1ExtraNoIsoEG.begin();
0703 iterME != m_meAnalysisL1ExtraNoIsoEG.end();
0704 ++iterME) {
0705 delete *iterME;
0706 }
0707 m_meAnalysisL1ExtraNoIsoEG.clear();
0708
0709 for (std::vector<L1ExtraMonElement<l1extra::L1JetParticleCollection>*>::iterator iterME =
0710 m_meAnalysisL1ExtraCenJet.begin();
0711 iterME != m_meAnalysisL1ExtraCenJet.end();
0712 ++iterME) {
0713 delete *iterME;
0714 }
0715 m_meAnalysisL1ExtraCenJet.clear();
0716
0717 for (std::vector<L1ExtraMonElement<l1extra::L1JetParticleCollection>*>::iterator iterME =
0718 m_meAnalysisL1ExtraForJet.begin();
0719 iterME != m_meAnalysisL1ExtraForJet.end();
0720 ++iterME) {
0721 delete *iterME;
0722 }
0723 m_meAnalysisL1ExtraForJet.clear();
0724
0725 for (std::vector<L1ExtraMonElement<l1extra::L1JetParticleCollection>*>::iterator iterME =
0726 m_meAnalysisL1ExtraTauJet.begin();
0727 iterME != m_meAnalysisL1ExtraTauJet.end();
0728 ++iterME) {
0729 delete *iterME;
0730 }
0731 m_meAnalysisL1ExtraTauJet.clear();
0732
0733 for (std::vector<L1ExtraMonElement<l1extra::L1EtMissParticleCollection>*>::iterator iterME =
0734 m_meAnalysisL1ExtraETT.begin();
0735 iterME != m_meAnalysisL1ExtraETT.end();
0736 ++iterME) {
0737 delete *iterME;
0738 }
0739 m_meAnalysisL1ExtraETT.clear();
0740
0741 for (std::vector<L1ExtraMonElement<l1extra::L1EtMissParticleCollection>*>::iterator iterME =
0742 m_meAnalysisL1ExtraETM.begin();
0743 iterME != m_meAnalysisL1ExtraETM.end();
0744 ++iterME) {
0745 delete *iterME;
0746 }
0747 m_meAnalysisL1ExtraETM.clear();
0748
0749 for (std::vector<L1ExtraMonElement<l1extra::L1EtMissParticleCollection>*>::iterator iterME =
0750 m_meAnalysisL1ExtraHTT.begin();
0751 iterME != m_meAnalysisL1ExtraHTT.end();
0752 ++iterME) {
0753 delete *iterME;
0754 }
0755 m_meAnalysisL1ExtraHTT.clear();
0756
0757 for (std::vector<L1ExtraMonElement<l1extra::L1EtMissParticleCollection>*>::iterator iterME =
0758 m_meAnalysisL1ExtraHTM.begin();
0759 iterME != m_meAnalysisL1ExtraHTM.end();
0760 ++iterME) {
0761 delete *iterME;
0762 }
0763 m_meAnalysisL1ExtraHTM.clear();
0764
0765 for (std::vector<L1ExtraMonElement<l1extra::L1HFRingsCollection>*>::iterator iterME =
0766 m_meAnalysisL1ExtraHfBitCounts.begin();
0767 iterME != m_meAnalysisL1ExtraHfBitCounts.end();
0768 ++iterME) {
0769 delete *iterME;
0770 }
0771 m_meAnalysisL1ExtraHfBitCounts.clear();
0772
0773 for (std::vector<L1ExtraMonElement<l1extra::L1HFRingsCollection>*>::iterator iterME =
0774 m_meAnalysisL1ExtraHfRingEtSums.begin();
0775 iterME != m_meAnalysisL1ExtraHfRingEtSums.end();
0776 ++iterME) {
0777 delete *iterME;
0778 }
0779 m_meAnalysisL1ExtraHfRingEtSums.clear();
0780
0781 LogDebug("L1ExtraDQM") << "\n\n endRun: " << run.id()
0782 << "\n Number of events analyzed in this run: " << m_nrEvRun
0783 << "\n Total number of events analyzed in this job: " << m_nrEvJob << "\n"
0784 << std::endl;
0785 }
0786
0787
0788 template <class CollectionType>
0789 L1ExtraDQM::L1ExtraMonElement<CollectionType>::L1ExtraMonElement(const L1GetHistLimits::Tokens& tokens,
0790 const int nrElements)
0791 : m_tokens(tokens),
0792 m_indexNrObjects(-1),
0793 m_indexPt(-1),
0794 m_indexEt(-1),
0795 m_indexPhi(-1),
0796 m_indexEta(-1),
0797 m_indexEtTotal(-1),
0798 m_indexCharge(-1),
0799 m_indexHfBitCounts(-1),
0800 m_indexHfRingEtSums(-1) {
0801 m_monElement.reserve(nrElements);
0802 }
0803
0804
0805 template <class CollectionType>
0806 L1ExtraDQM::L1ExtraMonElement<CollectionType>::~L1ExtraMonElement() {
0807
0808 }
0809
0810 template <class CollectionType>
0811 void L1ExtraDQM::L1ExtraMonElement<CollectionType>::bookhistograms(const edm::EventSetup& evSetup,
0812 DQMStore::IBooker& ibooker,
0813 const std::string& l1ExtraObject,
0814 const std::vector<L1GtObject>& l1GtObj,
0815 const bool bookPhi,
0816 const bool bookEta) {
0817
0818 L1GtObject gtObj = l1GtObj.at(0);
0819
0820
0821 std::string histName;
0822 std::string histTitle;
0823 std::string xAxisTitle;
0824 std::string yAxisTitle;
0825
0826 std::string quantity = "";
0827
0828 int indexHistogram = -1;
0829
0830 if (gtObj == HfBitCounts) {
0831 L1GetHistLimits l1GetHistLimits(m_tokens, evSetup);
0832 const L1GetHistLimits::L1HistLimits& histLimits = l1GetHistLimits.l1HistLimits(gtObj, quantity);
0833
0834 const int histNrBins = histLimits.nrBins;
0835 const double histMinValue = histLimits.lowerBinValue;
0836 const double histMaxValue = histLimits.upperBinValue;
0837
0838 indexHistogram++;
0839 m_indexHfBitCounts = indexHistogram;
0840
0841 for (int iCount = 0; iCount < l1extra::L1HFRings::kNumRings; ++iCount) {
0842 histName = l1ExtraObject + "_Count_" + std::to_string(iCount);
0843 histTitle = l1ExtraObject + ": count " + std::to_string(iCount);
0844 xAxisTitle = l1ExtraObject;
0845 yAxisTitle = "Entries";
0846
0847 m_monElement.push_back(ibooker.book1D(histName, histTitle, histNrBins, histMinValue, histMaxValue));
0848 m_monElement[m_indexHfBitCounts + iCount]->setAxisTitle(xAxisTitle, 1);
0849 m_monElement[m_indexHfBitCounts + iCount]->setAxisTitle(yAxisTitle, 2);
0850 }
0851
0852 return;
0853 }
0854
0855
0856 if ((gtObj == Mu) || (gtObj == IsoEG) || (gtObj == NoIsoEG) || (gtObj == CenJet) || (gtObj == ForJet) ||
0857 (gtObj == TauJet)) {
0858 quantity = "NrObjects";
0859
0860 L1GetHistLimits l1GetHistLimits(m_tokens, evSetup);
0861 const L1GetHistLimits::L1HistLimits& histLimits = l1GetHistLimits.l1HistLimits(gtObj, quantity);
0862
0863 const int histNrBins = histLimits.nrBins;
0864 const double histMinValue = histLimits.lowerBinValue;
0865 const double histMaxValue = histLimits.upperBinValue;
0866
0867 histName = l1ExtraObject + "_NrObjectsPerEvent";
0868 histTitle = l1ExtraObject + ": number of objects per event";
0869 xAxisTitle = "Nr_" + l1ExtraObject;
0870 yAxisTitle = "Entries";
0871
0872 m_monElement.push_back(ibooker.book1D(histName, histTitle, histNrBins, histMinValue, histMaxValue));
0873 indexHistogram++;
0874
0875 m_monElement[indexHistogram]->setAxisTitle(xAxisTitle, 1);
0876 m_monElement[indexHistogram]->setAxisTitle(yAxisTitle, 2);
0877 m_indexNrObjects = indexHistogram;
0878 }
0879
0880
0881
0882 quantity = "ET";
0883 std::string quantityLongName = " transverse energy ";
0884
0885 if (gtObj == Mu) {
0886 quantity = "PT";
0887 quantityLongName = " transverse momentum ";
0888 }
0889
0890 L1GetHistLimits l1GetHistLimits(m_tokens, evSetup);
0891 const L1GetHistLimits::L1HistLimits& histLimits = l1GetHistLimits.l1HistLimits(gtObj, quantity);
0892
0893 const int histNrBinsET = histLimits.nrBins;
0894 const double histMinValueET = histLimits.lowerBinValue;
0895 const double histMaxValueET = histLimits.upperBinValue;
0896 const std::vector<float>& binThresholdsET = histLimits.binThresholds;
0897
0898 float* binThresholdsETf;
0899 size_t sizeBinThresholdsET = binThresholdsET.size();
0900 binThresholdsETf = new float[sizeBinThresholdsET];
0901 copy(binThresholdsET.begin(), binThresholdsET.end(), binThresholdsETf);
0902
0903 LogDebug("L1ExtraDQM") << "\n PT/ET histogram for " << l1ExtraObject << "\n histNrBinsET = " << histNrBinsET
0904 << "\n histMinValueET = " << histMinValueET << "\n histMaxValueET = " << histMaxValueET
0905 << "\n Last bin value represents the upper limit of the histogram" << std::endl;
0906 for (size_t iBin = 0; iBin < sizeBinThresholdsET; ++iBin) {
0907 LogTrace("L1ExtraDQM") << "Bin " << iBin << ": " << quantity << " = " << binThresholdsETf[iBin] << " GeV"
0908 << std::endl;
0909 }
0910
0911 histName = l1ExtraObject + "_" + quantity;
0912 histTitle = l1ExtraObject + ":" + quantityLongName + quantity + " [GeV]";
0913 xAxisTitle = l1ExtraObject + "_" + quantity + " [GeV]";
0914 yAxisTitle = "Entries";
0915
0916 if (gtObj == HfRingEtSums) {
0917 indexHistogram++;
0918 m_indexHfRingEtSums = indexHistogram;
0919
0920 for (int iCount = 0; iCount < l1extra::L1HFRings::kNumRings; ++iCount) {
0921 histName = l1ExtraObject + "_Count_" + std::to_string(iCount);
0922 histTitle = l1ExtraObject + ": count " + std::to_string(iCount);
0923 xAxisTitle = l1ExtraObject;
0924 yAxisTitle = "Entries";
0925
0926 m_monElement.push_back(ibooker.book1D(histName, histTitle, histNrBinsET, binThresholdsETf));
0927
0928 m_monElement[m_indexHfRingEtSums + iCount]->setAxisTitle(xAxisTitle, 1);
0929 m_monElement[m_indexHfRingEtSums + iCount]->setAxisTitle(yAxisTitle, 2);
0930 }
0931
0932 } else {
0933 m_monElement.push_back(ibooker.book1D(histName, histTitle, histNrBinsET, binThresholdsETf));
0934 indexHistogram++;
0935
0936 m_monElement[indexHistogram]->setAxisTitle(xAxisTitle, 1);
0937 m_monElement[indexHistogram]->setAxisTitle(yAxisTitle, 2);
0938 m_indexPt = indexHistogram;
0939 m_indexEt = indexHistogram;
0940 m_indexEtTotal = indexHistogram;
0941 }
0942
0943 delete[] binThresholdsETf;
0944
0945
0946
0947 if (bookPhi) {
0948 quantity = "phi";
0949
0950
0951 L1GetHistLimits l1GetHistLimits(m_tokens, evSetup);
0952 const L1GetHistLimits::L1HistLimits& histLimits = l1GetHistLimits.l1HistLimits(gtObj, quantity);
0953
0954 const int histNrBinsPhi = histLimits.nrBins;
0955 const double histMinValuePhi = histLimits.lowerBinValue;
0956 const double histMaxValuePhi = histLimits.upperBinValue;
0957 const std::vector<float>& binThresholdsPhi = histLimits.binThresholds;
0958
0959 float* binThresholdsPhif;
0960 size_t sizeBinThresholdsPhi = binThresholdsPhi.size();
0961 binThresholdsPhif = new float[sizeBinThresholdsPhi];
0962 copy(binThresholdsPhi.begin(), binThresholdsPhi.end(), binThresholdsPhif);
0963
0964 LogDebug("L1ExtraDQM") << "\n phi histogram for " << l1ExtraObject << "\n histNrBinsPhi = " << histNrBinsPhi
0965 << "\n histMinValuePhi = " << histMinValuePhi << "\n histMaxValuePhi = " << histMaxValuePhi
0966 << "\n Last bin value represents the upper limit of the histogram" << std::endl;
0967 for (size_t iBin = 0; iBin < sizeBinThresholdsPhi; ++iBin) {
0968 LogTrace("L1ExtraDQM") << "Bin " << iBin << ": phi = " << binThresholdsPhif[iBin] << " deg" << std::endl;
0969 }
0970
0971 histName = l1ExtraObject + "_phi";
0972 histTitle = l1ExtraObject + ": phi distribution ";
0973 xAxisTitle = l1ExtraObject + "_phi [deg]";
0974 yAxisTitle = "Entries";
0975
0976 m_monElement.push_back(ibooker.book1D(histName, histTitle, histNrBinsPhi, histMinValuePhi, histMaxValuePhi));
0977 indexHistogram++;
0978
0979 m_monElement[indexHistogram]->setAxisTitle(xAxisTitle, 1);
0980 m_monElement[indexHistogram]->setAxisTitle(yAxisTitle, 2);
0981 m_indexPhi = indexHistogram;
0982
0983 delete[] binThresholdsPhif;
0984 }
0985
0986
0987
0988 if (bookEta) {
0989 quantity = "eta";
0990
0991
0992 L1GetHistLimits l1GetHistLimits(m_tokens, evSetup);
0993 const L1GetHistLimits::L1HistLimits& histLimits = l1GetHistLimits.l1HistLimits(gtObj, quantity);
0994
0995 const int histNrBinsEta = histLimits.nrBins;
0996 const double histMinValueEta = histLimits.lowerBinValue;
0997 const double histMaxValueEta = histLimits.upperBinValue;
0998 const std::vector<float>& binThresholdsEta = histLimits.binThresholds;
0999
1000
1001 float* binThresholdsEtaf;
1002 size_t sizeBinThresholdsEta = binThresholdsEta.size();
1003 binThresholdsEtaf = new float[sizeBinThresholdsEta];
1004 copy(binThresholdsEta.begin(), binThresholdsEta.end(), binThresholdsEtaf);
1005
1006 LogDebug("L1ExtraDQM") << "\n eta histogram for " << l1ExtraObject << "\n histNrBinsEta = " << histNrBinsEta
1007 << "\n histMinValueEta = " << histMinValueEta << "\n histMaxValueEta = " << histMaxValueEta
1008 << "\n Last bin value represents the upper limit of the histogram" << std::endl;
1009 for (size_t iBin = 0; iBin < sizeBinThresholdsEta; ++iBin) {
1010 LogTrace("L1ExtraDQM") << "Bin " << iBin << ": eta = " << binThresholdsEtaf[iBin] << std::endl;
1011 }
1012
1013 histName = l1ExtraObject + "_eta";
1014 histTitle = l1ExtraObject + ": eta distribution ";
1015 xAxisTitle = l1ExtraObject + "_eta";
1016 yAxisTitle = "Entries";
1017
1018 m_monElement.push_back(ibooker.book1D(histName, histTitle, histNrBinsEta, binThresholdsEtaf));
1019 indexHistogram++;
1020
1021 m_monElement[indexHistogram]->setAxisTitle(xAxisTitle, 1);
1022 m_monElement[indexHistogram]->setAxisTitle(yAxisTitle, 2);
1023 m_indexEta = indexHistogram;
1024
1025 delete[] binThresholdsEtaf;
1026 }
1027 }
1028
1029 template <class CollectionType>
1030 void L1ExtraDQM::L1ExtraMonElement<CollectionType>::fillNrObjects(const CollectionType* collType,
1031 const bool validColl,
1032 const bool isL1Coll,
1033 const int bxInEvent) {
1034 if (validColl && isL1Coll) {
1035 size_t collSize = 0;
1036 for (CIterColl iterColl = collType->begin(); iterColl != collType->end(); ++iterColl) {
1037 if (iterColl->bx() == bxInEvent) {
1038 collSize++;
1039 }
1040 }
1041 m_monElement[m_indexNrObjects]->Fill(collSize);
1042 } else {
1043 size_t collSize = collType->size();
1044 m_monElement[m_indexNrObjects]->Fill(collSize);
1045 }
1046 }
1047
1048 template <class CollectionType>
1049 void L1ExtraDQM::L1ExtraMonElement<CollectionType>::fillPtPhiEta(const CollectionType* collType,
1050 const bool validColl,
1051 const bool bookPhi,
1052 const bool bookEta,
1053 const bool isL1Coll,
1054 const int bxInEvent) {
1055 if (validColl) {
1056 for (CIterColl iterColl = collType->begin(); iterColl != collType->end(); ++iterColl) {
1057 if (isL1Coll && (iterColl->bx() != bxInEvent)) {
1058 continue;
1059 }
1060
1061 m_monElement[m_indexPt]->Fill(iterColl->pt());
1062
1063 if (bookPhi) {
1064
1065 m_monElement[m_indexPhi]->Fill(rad2deg(iterColl->phi()) + 1.e-6);
1066 }
1067
1068 if (bookEta) {
1069 m_monElement[m_indexEta]->Fill(iterColl->eta());
1070 }
1071 }
1072 }
1073 }
1074
1075 template <class CollectionType>
1076 void L1ExtraDQM::L1ExtraMonElement<CollectionType>::fillEtPhiEta(const CollectionType* collType,
1077 const bool validColl,
1078 const bool bookPhi,
1079 const bool bookEta,
1080 const bool isL1Coll,
1081 const int bxInEvent) {
1082 if (validColl) {
1083 for (CIterColl iterColl = collType->begin(); iterColl != collType->end(); ++iterColl) {
1084 if (isL1Coll && (iterColl->bx() != bxInEvent)) {
1085 continue;
1086 }
1087
1088 m_monElement[m_indexEt]->Fill(iterColl->et());
1089
1090 if (bookPhi) {
1091
1092 m_monElement[m_indexPhi]->Fill(rad2deg(iterColl->phi()) + 1.e-6);
1093 }
1094
1095 if (bookEta) {
1096 m_monElement[m_indexEta]->Fill(iterColl->eta());
1097 }
1098 }
1099 }
1100 }
1101
1102 template <class CollectionType>
1103 void L1ExtraDQM::L1ExtraMonElement<CollectionType>::fillEtTotal(const CollectionType* collType,
1104 const bool validColl,
1105 const bool isL1Coll,
1106 const int bxInEvent) {
1107 if (validColl) {
1108 for (CIterColl iterColl = collType->begin(); iterColl != collType->end(); ++iterColl) {
1109 if (isL1Coll && (iterColl->bx() != bxInEvent)) {
1110 continue;
1111 }
1112
1113 m_monElement[m_indexEtTotal]->Fill(iterColl->etTotal());
1114 }
1115 }
1116 }
1117
1118 template <class CollectionType>
1119 void L1ExtraDQM::L1ExtraMonElement<CollectionType>::fillCharge(const CollectionType* collType,
1120 const bool validColl,
1121 const bool isL1Coll,
1122 const int bxInEvent) {
1123 if (validColl) {
1124 for (CIterColl iterColl = collType->begin(); iterColl != collType->end(); ++iterColl) {
1125 if (isL1Coll && (iterColl->bx() != bxInEvent)) {
1126 continue;
1127 }
1128
1129 m_monElement[m_indexCharge]->Fill(iterColl->charge());
1130 }
1131 }
1132 }
1133
1134 template <class CollectionType>
1135 void L1ExtraDQM::L1ExtraMonElement<CollectionType>::fillHfBitCounts(const CollectionType* collType,
1136 const bool validColl,
1137 const int countIndex,
1138 const bool isL1Coll,
1139 const int bxInEvent) {
1140 if (validColl) {
1141 for (CIterColl iterColl = collType->begin(); iterColl != collType->end(); ++iterColl) {
1142 if (isL1Coll && (iterColl->bx() != bxInEvent)) {
1143 continue;
1144 }
1145
1146 m_monElement[m_indexHfBitCounts + countIndex]->Fill(
1147 iterColl->hfBitCount((l1extra::L1HFRings::HFRingLabels)countIndex));
1148 }
1149 }
1150 }
1151
1152 template <class CollectionType>
1153 void L1ExtraDQM::L1ExtraMonElement<CollectionType>::fillHfRingEtSums(const CollectionType* collType,
1154 const bool validColl,
1155 const int countIndex,
1156 const bool isL1Coll,
1157 const int bxInEvent) {
1158 if (validColl) {
1159 for (CIterColl iterColl = collType->begin(); iterColl != collType->end(); ++iterColl) {
1160 if (isL1Coll && (iterColl->bx() != bxInEvent)) {
1161 continue;
1162 }
1163
1164 m_monElement[m_indexHfRingEtSums + countIndex]->Fill(
1165 iterColl->hfEtSum((l1extra::L1HFRings::HFRingLabels)countIndex));
1166 }
1167 }
1168 }