File indexing completed on 2021-02-14 12:52:00
0001 #include "CondTools/Ecal/interface/EcalLaserHandler.h"
0002
0003 #include "CondTools/Ecal/interface/EcalPedestalsHandler.h"
0004 #include "FWCore/ParameterSet/interface/ParameterSetfwd.h"
0005
0006 #include <cstring>
0007 #include <iostream>
0008 #include <fstream>
0009
0010 #include "TFile.h"
0011 #include "TTree.h"
0012
0013 const Int_t kChannels = 75848, kEBChannels = 61200, kEEChannels = 14648, kGains = 3;
0014 const Int_t Nbpedxml = 81;
0015 const Int_t gainValues[kGains] = {12, 6, 1};
0016
0017 popcon::EcalPedestalsHandler::EcalPedestalsHandler(const edm::ParameterSet& ps)
0018 : m_name(ps.getUntrackedParameter<std::string>("name", "EcalPedestalsHandler")) {
0019 edm::LogInfo("EcalPedestals Source handler constructor\n");
0020 m_firstRun = static_cast<unsigned int>(atoi(ps.getParameter<std::string>("firstRun").c_str()));
0021 m_lastRun = static_cast<unsigned int>(atoi(ps.getParameter<std::string>("lastRun").c_str()));
0022 m_sid = ps.getParameter<std::string>("OnlineDBSID");
0023 m_user = ps.getParameter<std::string>("OnlineDBUser");
0024 m_pass = ps.getParameter<std::string>("OnlineDBPassword");
0025 m_locationsource = ps.getParameter<std::string>("LocationSource");
0026 m_location = ps.getParameter<std::string>("Location");
0027 m_gentag = ps.getParameter<std::string>("GenTag");
0028 m_runtag = ps.getParameter<std::string>("RunTag");
0029 m_filename = ps.getUntrackedParameter<std::string>("filename", "EcalPedestals.txt");
0030 m_runtype = ps.getUntrackedParameter<int>("RunType", 1);
0031 m_corrected = ps.getUntrackedParameter<bool>("corrected", false);
0032
0033 edm::LogInfo("EcalPedestalsHandler") << m_sid << "/"
0034 << "/" << m_location << "/" << m_gentag;
0035 }
0036
0037 popcon::EcalPedestalsHandler::~EcalPedestalsHandler() {}
0038
0039 void popcon::EcalPedestalsHandler::getNewObjects() {
0040 edm::LogInfo("------- Ecal - > getNewObjects\n");
0041 if (m_locationsource == "P5") {
0042 getNewObjectsP5();
0043 } else if (m_locationsource == "H2") {
0044 getNewObjectsH2();
0045 } else if (m_locationsource == "File") {
0046 readPedestalFile();
0047 } else if (m_locationsource == "MC") {
0048 readPedestalMC();
0049 } else if (m_locationsource == "2017") {
0050 readPedestal2017();
0051 } else if (m_locationsource == "Tree") {
0052 readPedestalTree();
0053 } else if (m_locationsource == "Timestamp") {
0054 readPedestalTimestamp();
0055 } else {
0056 edm::LogInfo(" unknown location ") << m_locationsource << " give up ";
0057 exit(-1);
0058 }
0059 }
0060
0061 bool popcon::EcalPedestalsHandler::checkPedestal(EcalPedestals::Item* item) {
0062
0063 bool result = true;
0064 if (item->rms_x12 > 3 || item->rms_x12 <= 0)
0065 result = false;
0066 if (item->rms_x6 > 2 || item->rms_x6 <= 0)
0067 result = false;
0068 if (item->rms_x1 > 1 || item->rms_x1 <= 0)
0069 result = false;
0070 if (item->mean_x12 > 300 || item->mean_x12 <= 100)
0071 result = false;
0072 if (item->mean_x1 > 300 || item->mean_x1 <= 100)
0073 result = false;
0074 if (item->mean_x6 > 300 || item->mean_x6 <= 100)
0075 result = false;
0076 return result;
0077 }
0078
0079
0080
0081 void popcon::EcalPedestalsHandler::getNewObjectsP5() {
0082 std::ostringstream ss;
0083 ss << "ECAL ";
0084
0085 unsigned int max_since = 0;
0086 max_since = static_cast<unsigned int>(tagInfo().lastInterval.since);
0087 edm::LogInfo("max_since : ") << max_since;
0088 Ref ped_db = lastPayload();
0089
0090
0091 EcalPedestals* peds = new EcalPedestals();
0092 edm::LogInfo("retrieved last payload ");
0093
0094 for (int iEta = -EBDetId::MAX_IETA; iEta <= EBDetId::MAX_IETA; ++iEta) {
0095 if (iEta == 0)
0096 continue;
0097 for (int iPhi = EBDetId::MIN_IPHI; iPhi <= EBDetId::MAX_IPHI; ++iPhi) {
0098
0099 if (EBDetId::validDetId(iEta, iPhi)) {
0100 EBDetId ebdetid(iEta, iPhi, EBDetId::ETAPHIMODE);
0101 EcalPedestals::const_iterator it = ped_db->find(ebdetid.rawId());
0102 EcalPedestals::Item aped = (*it);
0103
0104
0105 EcalPedestals::Item item;
0106 item.mean_x1 = aped.mean_x1;
0107 item.rms_x1 = aped.rms_x1;
0108 item.mean_x6 = aped.mean_x6;
0109 item.rms_x6 = aped.rms_x6;
0110 item.mean_x12 = aped.mean_x12;
0111 item.rms_x12 = aped.rms_x12;
0112
0113 peds->insert(std::make_pair(ebdetid.rawId(), item));
0114 }
0115 }
0116 }
0117
0118 for (int iX = EEDetId::IX_MIN; iX <= EEDetId::IX_MAX; ++iX) {
0119 for (int iY = EEDetId::IY_MIN; iY <= EEDetId::IY_MAX; ++iY) {
0120
0121 if (EEDetId::validDetId(iX, iY, 1)) {
0122 EEDetId eedetidpos(iX, iY, 1);
0123
0124 EcalPedestals::const_iterator it = ped_db->find(eedetidpos.rawId());
0125 EcalPedestals::Item aped = (*it);
0126
0127
0128
0129
0130
0131 EcalPedestals::Item item;
0132 item.mean_x1 = aped.mean_x1;
0133 item.rms_x1 = aped.rms_x1;
0134 item.mean_x6 = aped.mean_x6;
0135 item.rms_x6 = aped.rms_x6;
0136 item.mean_x12 = aped.mean_x12;
0137 item.rms_x12 = aped.rms_x12;
0138 peds->insert(std::make_pair(eedetidpos.rawId(), item));
0139 }
0140 if (EEDetId::validDetId(iX, iY, -1)) {
0141 EEDetId eedetidneg(iX, iY, -1);
0142
0143 EcalPedestals::const_iterator it = ped_db->find(eedetidneg.rawId());
0144 EcalPedestals::Item aped = (*it);
0145
0146
0147
0148
0149 EcalPedestals::Item item;
0150 item.mean_x1 = aped.mean_x1;
0151 item.rms_x1 = aped.rms_x1;
0152 item.mean_x6 = aped.mean_x6;
0153 item.rms_x6 = aped.rms_x6;
0154 item.mean_x12 = aped.mean_x12;
0155 item.rms_x12 = aped.rms_x12;
0156 peds->insert(std::make_pair(eedetidneg.rawId(), item));
0157 }
0158 }
0159 }
0160
0161
0162
0163 edm::LogInfo("Retrieving run list from ONLINE DB ... ");
0164 econn = new EcalCondDBInterface(m_sid, m_user, m_pass);
0165 edm::LogInfo("Connection done");
0166
0167
0168 RunList my_runlist;
0169 RunTag my_runtag;
0170 LocationDef my_locdef;
0171 RunTypeDef my_rundef;
0172
0173 my_locdef.setLocation(m_location);
0174
0175 my_rundef.setRunType(m_runtag);
0176 my_runtag.setLocationDef(my_locdef);
0177 my_runtag.setRunTypeDef(my_rundef);
0178 my_runtag.setGeneralTag(m_gentag);
0179
0180
0181
0182 MonVersionDef monverdef;
0183 monverdef.setMonitoringVersion("test01");
0184
0185 MonRunTag mon_tag;
0186
0187 mon_tag.setGeneralTag("CMSSW-offline-private");
0188 mon_tag.setMonVersionDef(monverdef);
0189 MonRunList mon_list;
0190 mon_list.setMonRunTag(mon_tag);
0191 mon_list.setRunTag(my_runtag);
0192
0193 unsigned int min_run = 0;
0194 if (m_firstRun < max_since) {
0195 min_run = max_since + 1;
0196 } else {
0197 min_run = m_firstRun;
0198 }
0199
0200 unsigned int max_run = m_lastRun;
0201 mon_list = econn->fetchMonRunList(my_runtag, mon_tag, min_run, max_run);
0202
0203 std::vector<MonRunIOV> mon_run_vec = mon_list.getRuns();
0204 int mon_runs = mon_run_vec.size();
0205 edm::LogInfo("number of Mon runs is : ") << mon_runs;
0206
0207 if (mon_runs > 0) {
0208 int krmax = std::min(mon_runs, 30);
0209 for (int kr = 0; kr < krmax; kr++) {
0210 edm::LogInfo("-kr------: ") << kr;
0211
0212 unsigned int irun = static_cast<unsigned int>(mon_run_vec[kr].getRunIOV().getRunNumber());
0213 edm::LogInfo("retrieve the data for run number: ") << mon_run_vec[kr].getRunIOV().getRunNumber();
0214 if (mon_run_vec[kr].getSubRunNumber() <= 1) {
0215
0216 RunIOV runiov_prime = mon_run_vec[kr].getRunIOV();
0217
0218 std::map<EcalLogicID, MonPedestalsDat> dataset_mon;
0219 econn->fetchDataSet(&dataset_mon, &mon_run_vec[kr]);
0220 edm::LogInfo("OMDS record for run ") << irun << " is made of " << dataset_mon.size();
0221 int nEB = 0, nEE = 0, nEBbad = 0, nEEbad = 0;
0222 typedef std::map<EcalLogicID, MonPedestalsDat>::const_iterator CImon;
0223 EcalLogicID ecid_xt;
0224 MonPedestalsDat rd_ped;
0225
0226
0227 int nbad = 0;
0228 for (CImon p = dataset_mon.begin(); p != dataset_mon.end(); p++) {
0229 ecid_xt = p->first;
0230 rd_ped = p->second;
0231 int sm_num = ecid_xt.getID1();
0232 int xt_num = ecid_xt.getID2();
0233 int yt_num = ecid_xt.getID3();
0234
0235 EcalPedestals::Item item;
0236 item.mean_x1 = rd_ped.getPedMeanG1();
0237 item.rms_x1 = rd_ped.getPedRMSG1();
0238 item.mean_x6 = rd_ped.getPedMeanG6();
0239 item.rms_x6 = rd_ped.getPedRMSG6();
0240 item.mean_x12 = rd_ped.getPedMeanG12();
0241 item.rms_x12 = rd_ped.getPedRMSG12();
0242
0243
0244
0245
0246 if (ecid_xt.getName() == "EB_crystal_number") {
0247 nEB++;
0248 if (!checkPedestal(&item))
0249 nEBbad++;
0250 } else {
0251 nEE++;
0252 if (!checkPedestal(&item))
0253 nEEbad++;
0254 }
0255
0256
0257
0258 if (!checkPedestal(&item)) {
0259 nbad++;
0260 if (nbad < 10)
0261 std::cout << "BAD LIST: channel " << sm_num << "/" << xt_num << "/" << yt_num << "ped/rms "
0262 << item.mean_x12 << "/" << item.rms_x12 << std::endl;
0263 }
0264
0265
0266
0267
0268
0269
0270
0271
0272
0273
0274
0275
0276
0277
0278
0279
0280
0281
0282
0283 }
0284
0285
0286
0287
0288
0289 if (nbad < (dataset_mon.size() * 0.05) && (nEB > 10200 || nEE > 2460)) {
0290 for (CImon p = dataset_mon.begin(); p != dataset_mon.end(); p++) {
0291 ecid_xt = p->first;
0292 rd_ped = p->second;
0293 int sm_num = ecid_xt.getID1();
0294 int xt_num = ecid_xt.getID2();
0295 int yt_num = ecid_xt.getID3();
0296
0297 EcalPedestals::Item item;
0298 item.mean_x1 = rd_ped.getPedMeanG1();
0299 item.rms_x1 = rd_ped.getPedRMSG1();
0300 item.mean_x6 = rd_ped.getPedMeanG6();
0301 item.rms_x6 = rd_ped.getPedRMSG6();
0302 item.mean_x12 = rd_ped.getPedMeanG12();
0303 item.rms_x12 = rd_ped.getPedRMSG12();
0304
0305 if (ecid_xt.getName() == "EB_crystal_number") {
0306
0307 EBDetId ebdetid(sm_num, xt_num, EBDetId::SMCRYSTALMODE);
0308
0309
0310 if (item.mean_x1 == -1 || item.rms_x1 == -1 || item.mean_x6 == -1 || item.rms_x6 == -1 ||
0311 item.mean_x12 == -1 || item.rms_x12 == -1 || item.mean_x1 == 0 || item.rms_x1 == 0 ||
0312 item.mean_x6 == 0 || item.rms_x6 == 0 || item.mean_x12 == 0 || item.rms_x12 == 0) {
0313
0314
0315 unsigned int hieb = ebdetid.hashedIndex();
0316 EcalPedestals::Item previous_ped = peds->barrel(hieb);
0317 if (item.mean_x1 == -1 || item.mean_x1 == 0)
0318 item.mean_x1 = previous_ped.mean_x1;
0319 if (item.rms_x1 == -1 || item.rms_x1 == 0)
0320 item.rms_x1 = previous_ped.rms_x1;
0321 if (item.mean_x6 == -1 || item.mean_x6 == 0)
0322 item.mean_x6 = previous_ped.mean_x6;
0323 if (item.rms_x6 == -1 || item.rms_x6 == 0)
0324 item.rms_x6 = previous_ped.rms_x6;
0325 if (item.mean_x12 == -1 || item.mean_x12 == 0)
0326 item.mean_x12 = previous_ped.mean_x12;
0327 if (item.rms_x12 == -1 || item.rms_x12 == 0)
0328 item.rms_x12 = previous_ped.rms_x12;
0329 }
0330
0331
0332
0333 peds->insert(std::make_pair(ebdetid.rawId(), item));
0334 } else {
0335
0336
0337
0338 if (EEDetId::validDetId(xt_num, yt_num, sm_num)) {
0339 EEDetId eedetid(xt_num, yt_num, sm_num);
0340
0341
0342 if (item.mean_x1 == -1 || item.rms_x1 == -1 || item.mean_x6 == -1 || item.rms_x6 == -1 ||
0343 item.mean_x12 == -1 || item.rms_x12 == -1 || item.mean_x1 == 0 || item.rms_x1 == 0 ||
0344 item.mean_x6 == 0 || item.rms_x6 == 0 || item.mean_x12 == 0 || item.rms_x12 == 0) {
0345
0346
0347 unsigned int hiee = eedetid.hashedIndex();
0348 EcalPedestals::Item previous_ped = peds->endcap(hiee);
0349 if (item.mean_x1 == -1 || item.mean_x1 == 0)
0350 item.mean_x1 = previous_ped.mean_x1;
0351 if (item.rms_x1 == -1 || item.rms_x1 == 0)
0352 item.rms_x1 = previous_ped.rms_x1;
0353 if (item.mean_x6 == -1 || item.mean_x6 == 0)
0354 item.mean_x6 = previous_ped.mean_x6;
0355 if (item.rms_x6 == -1 || item.rms_x6 == 0)
0356 item.rms_x6 = previous_ped.rms_x6;
0357 if (item.mean_x12 == -1 || item.mean_x12 == 0)
0358 item.mean_x12 = previous_ped.mean_x12;
0359 if (item.rms_x12 == -1 || item.rms_x12 == 0)
0360 item.rms_x12 = previous_ped.rms_x12;
0361 }
0362
0363
0364 peds->insert(std::make_pair(eedetid.rawId(), item));
0365 }
0366 }
0367 }
0368
0369 edm::LogInfo("Generating popcon record for run ") << irun << "..." << std::flush;
0370
0371
0372
0373
0374
0375 EcalPedestals* pedtemp = new EcalPedestals();
0376 for (int iEta = -EBDetId::MAX_IETA; iEta <= EBDetId::MAX_IETA; ++iEta) {
0377 if (iEta == 0)
0378 continue;
0379 for (int iPhi = EBDetId::MIN_IPHI; iPhi <= EBDetId::MAX_IPHI; ++iPhi) {
0380
0381 if (EBDetId::validDetId(iEta, iPhi)) {
0382 EBDetId ebdetid(iEta, iPhi);
0383 unsigned int hiee = ebdetid.hashedIndex();
0384 EcalPedestals::Item aped = peds->barrel(hiee);
0385
0386
0387 EcalPedestals::Item item;
0388 item.mean_x1 = aped.mean_x1;
0389 item.rms_x1 = aped.rms_x1;
0390 item.mean_x6 = aped.mean_x6;
0391 item.rms_x6 = aped.rms_x6;
0392 item.mean_x12 = aped.mean_x12;
0393 item.rms_x12 = aped.rms_x12;
0394
0395 pedtemp->insert(std::make_pair(ebdetid.rawId(), item));
0396 if ((iEta == -1 || iEta == 1) && iPhi == 20) {
0397 float x = aped.mean_x12;
0398 edm::LogInfo("channel:") << iEta << "/" << iPhi << "/" << hiee << " ped mean 12=" << x;
0399 }
0400 }
0401 }
0402 }
0403
0404 for (int iX = EEDetId::IX_MIN; iX <= EEDetId::IX_MAX; ++iX) {
0405 for (int iY = EEDetId::IY_MIN; iY <= EEDetId::IY_MAX; ++iY) {
0406
0407 if (EEDetId::validDetId(iX, iY, 1)) {
0408 EEDetId eedetid(iX, iY, 1);
0409 unsigned int hiee = eedetid.hashedIndex();
0410 EcalPedestals::Item aped = peds->endcap(hiee);
0411
0412 EcalPedestals::Item item;
0413 item.mean_x1 = aped.mean_x1;
0414 item.rms_x1 = aped.rms_x1;
0415 item.mean_x6 = aped.mean_x6;
0416 item.rms_x6 = aped.rms_x6;
0417 item.mean_x12 = aped.mean_x12;
0418 item.rms_x12 = aped.rms_x12;
0419
0420 pedtemp->insert(std::make_pair(eedetid.rawId(), item));
0421 }
0422 if (EEDetId::validDetId(iX, iY, -1)) {
0423 EEDetId eedetid(iX, iY, -1);
0424 unsigned int hiee = eedetid.hashedIndex();
0425 EcalPedestals::Item aped = peds->endcap(hiee);
0426
0427 EcalPedestals::Item item;
0428 item.mean_x1 = aped.mean_x1;
0429 item.rms_x1 = aped.rms_x1;
0430 item.mean_x6 = aped.mean_x6;
0431 item.rms_x6 = aped.rms_x6;
0432 item.mean_x12 = aped.mean_x12;
0433 item.rms_x12 = aped.rms_x12;
0434
0435 pedtemp->insert(std::make_pair(eedetid.rawId(), item));
0436 }
0437 }
0438 }
0439
0440 Time_t snc = (Time_t)irun;
0441 m_to_transfer.push_back(std::make_pair((EcalPedestals*)pedtemp, snc));
0442
0443 ss << "Run=" << irun << "_WAS_GOOD_" << std::endl;
0444 m_userTextLog = ss.str() + ";";
0445 }
0446 else {
0447 edm::LogInfo("Run ") << irun << " was BAD !!!! not sent to the DB";
0448 if (nbad >= (dataset_mon.size() * 0.05))
0449 edm::LogInfo(" number of bad channels = ") << nbad;
0450 if (nEB <= 10200)
0451 edm::LogInfo(" number of EB channels = ") << nEB;
0452 if (nEE <= 2440)
0453 edm::LogInfo(" number of EE channels = ") << nEE;
0454 ss << "Run=" << irun << "_WAS_BAD_" << std::endl;
0455 m_userTextLog = ss.str() + ";";
0456 }
0457 }
0458 }
0459
0460 delete econn;
0461 delete peds;
0462 }
0463 edm::LogInfo("Ecal - > end of getNewObjects -----------\n");
0464 }
0465
0466
0467
0468 void popcon::EcalPedestalsHandler::getNewObjectsH2() {
0469 unsigned int max_since = 0;
0470 max_since = static_cast<unsigned int>(tagInfo().lastInterval.since);
0471 edm::LogInfo("max_since : ") << max_since;
0472 Ref ped_db = lastPayload();
0473
0474 edm::LogInfo("retrieved last payload ");
0475
0476
0477 EcalPedestals* peds = new EcalPedestals();
0478
0479
0480
0481
0482
0483
0484
0485
0486 int ixmin = 86;
0487 int ixmax = 95;
0488 int iymin = 46;
0489 int iymax = 55;
0490 for (int iX = ixmin; iX <= ixmax; ++iX) {
0491 for (int iY = iymin; iY <= iymax; ++iY) {
0492 if (EEDetId::validDetId(iX, iY, 1)) {
0493 EEDetId eedetidpos(iX, iY, 1);
0494 unsigned int hiee = eedetidpos.hashedIndex();
0495 EcalPedestals::Item aped = ped_db->endcap(hiee);
0496
0497
0498 EcalPedestals::Item item;
0499 item.mean_x1 = aped.mean_x1;
0500 item.rms_x1 = aped.rms_x1;
0501 item.mean_x6 = aped.mean_x6;
0502 item.rms_x6 = aped.rms_x6;
0503 item.mean_x12 = aped.mean_x12;
0504 item.rms_x12 = aped.rms_x12;
0505 peds->insert(std::make_pair(eedetidpos.rawId(), item));
0506 if (iX == ixmin && iY == iymin)
0507 std::cout << "ped12 " << item.mean_x12 << std::endl;
0508 }
0509 }
0510 }
0511
0512 edm::LogInfo("We just retrieved the last valid record from DB ");
0513
0514
0515
0516 edm::LogInfo("Retrieving run list from ONLINE DB ... ");
0517
0518 edm::LogInfo("Making connection...") << std::flush;
0519 econn = new EcalCondDBInterface(m_sid, m_user, m_pass);
0520 edm::LogInfo("Done.");
0521
0522 if (!econn) {
0523 edm::LogInfo(" connection parameters ") << m_sid;
0524 throw cms::Exception("OMDS not available");
0525 }
0526
0527
0528 RunList my_runlist;
0529 RunTag my_runtag;
0530 LocationDef my_locdef;
0531 RunTypeDef my_rundef;
0532
0533 my_locdef.setLocation("H2_07");
0534 my_rundef.setRunType("PEDESTAL");
0535 my_runtag.setLocationDef(my_locdef);
0536 my_runtag.setRunTypeDef(my_rundef);
0537 my_runtag.setGeneralTag("LOCAL");
0538
0539
0540
0541 MonVersionDef monverdef;
0542 monverdef.setMonitoringVersion("test01");
0543
0544 MonRunTag mon_tag;
0545 mon_tag.setGeneralTag("CMSSW");
0546 mon_tag.setMonVersionDef(monverdef);
0547 MonRunList mon_list;
0548 mon_list.setMonRunTag(mon_tag);
0549 mon_list.setRunTag(my_runtag);
0550
0551 unsigned int min_run = max_since + 1;
0552
0553 unsigned int max_run = m_lastRun;
0554 mon_list = econn->fetchMonRunList(my_runtag, mon_tag, min_run, max_run);
0555
0556 std::vector<MonRunIOV> mon_run_vec = mon_list.getRuns();
0557 size_t mon_runs = mon_run_vec.size();
0558 edm::LogInfo("number of Mon runs is : ") << mon_runs;
0559
0560 if (mon_runs > 0) {
0561 for (size_t kr = 0; kr < mon_runs; kr++) {
0562 unsigned int irun = static_cast<unsigned int>(mon_run_vec[kr].getRunIOV().getRunNumber());
0563
0564 edm::LogInfo("here is first sub run : ") << mon_run_vec[kr].getSubRunNumber();
0565 edm::LogInfo("here is the run number: ") << mon_run_vec[kr].getRunIOV().getRunNumber();
0566
0567 edm::LogInfo(" retrieve the data for a given run");
0568
0569 if (mon_run_vec[kr].getSubRunNumber() <= 1) {
0570
0571 RunIOV runiov_prime = mon_run_vec[kr].getRunIOV();
0572
0573
0574 std::map<EcalLogicID, MonPedestalsDat> dataset_mon;
0575 econn->fetchDataSet(&dataset_mon, &mon_run_vec[kr]);
0576 std::cout << "OMDS record for run " << irun << " is made of " << dataset_mon.size() << std::endl;
0577 typedef std::map<EcalLogicID, MonPedestalsDat>::const_iterator CImon;
0578 EcalLogicID ecid_xt;
0579 MonPedestalsDat rd_ped;
0580
0581
0582
0583 int ix = 0;
0584 int iy = 0;
0585
0586 for (CImon p = dataset_mon.begin(); p != dataset_mon.end(); p++) {
0587 ecid_xt = p->first;
0588 rd_ped = p->second;
0589
0590 int xt_num = ecid_xt.getID2();
0591
0592
0593
0594
0595 ix = 95 - (xt_num - 1) / 20;
0596 iy = 46 + (xt_num - 1) % 20;
0597
0598 EcalPedestals::Item item;
0599 item.mean_x1 = rd_ped.getPedMeanG1();
0600 item.rms_x1 = rd_ped.getPedRMSG1();
0601 item.mean_x6 = rd_ped.getPedMeanG6();
0602 item.rms_x6 = rd_ped.getPedRMSG6();
0603 item.mean_x12 = rd_ped.getPedMeanG12();
0604 item.rms_x12 = rd_ped.getPedRMSG12();
0605
0606 EEDetId eedetidpos(ix, iy, 1);
0607
0608
0609
0610
0611
0612 peds->insert(std::make_pair(eedetidpos.rawId(), item));
0613 if (ix == ixmin && iy == iymin)
0614 std::cout << "ped12 " << item.mean_x12 << std::endl;
0615 }
0616
0617 edm::LogInfo("Generating popcon record for run ") << irun << "..." << std::flush;
0618
0619
0620
0621
0622
0623
0624 EcalPedestals* pedtemp = new EcalPedestals();
0625
0626 for (int iX = ixmin; iX <= ixmax; ++iX) {
0627 for (int iY = iymin; iY <= iymax; ++iY) {
0628 if (EEDetId::validDetId(iX, iY, 1)) {
0629 EEDetId eedetidpos(iX, iY, 1);
0630 unsigned int hiee = eedetidpos.hashedIndex();
0631 EcalPedestals::Item aped = peds->endcap(hiee);
0632
0633 EcalPedestals::Item item;
0634 item.mean_x1 = aped.mean_x1;
0635 item.rms_x1 = aped.rms_x1;
0636 item.mean_x6 = aped.mean_x6;
0637 item.rms_x6 = aped.rms_x6;
0638 item.mean_x12 = aped.mean_x12;
0639 item.rms_x12 = aped.rms_x12;
0640
0641 pedtemp->insert(std::make_pair(eedetidpos.rawId(), item));
0642 if (iX == ixmin && iY == iymin)
0643 std::cout << "ped12 " << item.mean_x12 << std::endl;
0644 }
0645 }
0646 }
0647
0648 Time_t snc = (Time_t)irun;
0649
0650 m_to_transfer.push_back(std::make_pair((EcalPedestals*)pedtemp, snc));
0651
0652 edm::LogInfo("Ecal - > end of getNewObjectsH2 -----------\n");
0653 }
0654 }
0655 }
0656 delete econn;
0657 delete peds;
0658 }
0659
0660
0661 void popcon::EcalPedestalsHandler::readPedestalFile() {
0662 edm::LogInfo(" reading the input file ") << m_filename;
0663 std::ifstream fInput;
0664 fInput.open(m_filename);
0665 if (!fInput.is_open()) {
0666 edm::LogInfo("ERROR : cannot open file ") << m_filename;
0667 exit(1);
0668 }
0669
0670 int hashedId;
0671 float EBmean12[kEBChannels], EBrms12[kEBChannels], EBmean6[kEBChannels], EBrms6[kEBChannels], EBmean1[kEBChannels],
0672 EBrms1[kEBChannels];
0673
0674
0675 for (int iChannel = 0; iChannel < kEBChannels; iChannel++) {
0676 fInput >> hashedId >> EBmean12[iChannel] >> EBrms12[iChannel] >> EBmean6[iChannel] >> EBrms6[iChannel] >>
0677 EBmean1[iChannel] >> EBrms1[iChannel];
0678 if (hashedId != iChannel + 1) {
0679 edm::LogInfo("File") << m_filename << " strange hash " << hashedId << " while iChannel " << iChannel;
0680 exit(-1);
0681 }
0682 }
0683
0684
0685 float EEmean12[kEEChannels], EErms12[kEEChannels], EEmean6[kEEChannels], EErms6[kEEChannels], EEmean1[kEEChannels],
0686 EErms1[kEEChannels];
0687 for (int iChannel = 0; iChannel < kEEChannels; iChannel++) {
0688 fInput >> hashedId >> EEmean12[iChannel] >> EErms12[iChannel] >> EEmean6[iChannel] >> EErms6[iChannel] >>
0689 EEmean1[iChannel] >> EErms1[iChannel];
0690 if (hashedId != iChannel + kEBChannels + 1) {
0691 edm::LogInfo("File") << m_filename << " strange hash " << hashedId << " while iChannel " << iChannel;
0692 exit(-1);
0693 }
0694 }
0695 fInput.close();
0696
0697 EcalPedestals* ped = new EcalPedestals();
0698
0699 for (int iEta = -EBDetId::MAX_IETA; iEta <= EBDetId::MAX_IETA; ++iEta) {
0700 if (iEta == 0)
0701 continue;
0702 for (int iPhi = EBDetId::MIN_IPHI; iPhi <= EBDetId::MAX_IPHI; ++iPhi) {
0703 if (EBDetId::validDetId(iEta, iPhi)) {
0704 EBDetId ebdetid(iEta, iPhi);
0705 unsigned int hieb = ebdetid.hashedIndex();
0706 EcalPedestals::Item item;
0707 item.mean_x1 = EBmean1[hieb];
0708 item.rms_x1 = EBrms1[hieb];
0709 item.mean_x6 = EBmean6[hieb];
0710 item.rms_x6 = EBrms6[hieb];
0711 item.mean_x12 = EBmean12[hieb];
0712 item.rms_x12 = EBrms12[hieb];
0713 ped->insert(std::make_pair(ebdetid.rawId(), item));
0714 }
0715 }
0716 }
0717
0718
0719
0720 for (int iz = -1; iz < 2; iz = iz + 2) {
0721 for (int iX = EEDetId::IX_MIN; iX <= EEDetId::IX_MAX; ++iX) {
0722 for (int iY = EEDetId::IY_MIN; iY <= EEDetId::IY_MAX; ++iY) {
0723 if (EEDetId::validDetId(iX, iY, iz)) {
0724 EEDetId eedetid(iX, iY, iz);
0725 unsigned int hiee = eedetid.hashedIndex();
0726
0727 EcalPedestals::Item item;
0728 item.mean_x1 = EEmean1[hiee];
0729 item.rms_x1 = EErms1[hiee];
0730 item.mean_x6 = EEmean6[hiee];
0731 item.rms_x6 = EErms6[hiee];
0732 item.mean_x12 = EEmean12[hiee];
0733 item.rms_x12 = EErms12[hiee];
0734 ped->insert(std::make_pair(eedetid.rawId(), item));
0735 }
0736 }
0737 }
0738 }
0739
0740
0741 unsigned int irun = m_firstRun;
0742 Time_t snc = (Time_t)irun;
0743 m_to_transfer.push_back(std::make_pair((EcalPedestals*)ped, snc));
0744
0745 edm::LogInfo("Ecal - > end of readPedestalFile -----------\n");
0746 }
0747
0748
0749 void popcon::EcalPedestalsHandler::readPedestalMC() {
0750 edm::LogInfo(" reading the input file ") << m_filename;
0751 std::ifstream fxml;
0752 fxml.open(m_filename);
0753 if (!fxml.is_open()) {
0754 edm::LogInfo("ERROR : cannot open file ") << m_filename;
0755 exit(1);
0756 }
0757 std::ofstream fout;
0758 fout.open("Pedestal.check");
0759
0760 float EBmean12[kEBChannels], EBrms12[kEBChannels], EBmean6[kEBChannels], EBrms6[kEBChannels], EBmean1[kEBChannels],
0761 EBrms1[kEBChannels];
0762
0763 double RingMean[28][2][3], RingRMS[28][2][3];
0764 int NbVal[28][2][3];
0765 for (int ring = 0; ring < 28; ring++) {
0766 for (int side = 0; side < 2; side++) {
0767 for (int igain = 0; igain < kGains; igain++) {
0768 RingMean[ring][side][igain] = 0.;
0769 RingRMS[ring][side][igain] = 0.;
0770 NbVal[ring][side][igain] = 0;
0771 }
0772 }
0773 }
0774 std::string dummyLine, mean12, rms12, bid;
0775 for (int i = 0; i < 9; i++)
0776 std::getline(fxml, dummyLine);
0777
0778 for (int iEBChannel = 0; iEBChannel < kEBChannels; iEBChannel++) {
0779 EBDetId ebdetid = EBDetId::unhashIndex(iEBChannel);
0780 int ieta = ebdetid.ieta();
0781 int ring = (abs(ieta) - 1) / 5;
0782 if (ring < 0 || ring > 16)
0783 edm::LogInfo("EB channel ") << iEBChannel << " ring " << ring;
0784 int izz = 0;
0785 if (ieta > 0)
0786 izz = 1;
0787 fxml >> bid;
0788 std::string stt = bid.substr(10, 15);
0789 std::istringstream m12(stt);
0790 m12 >> EBmean12[iEBChannel];
0791 fxml >> bid;
0792 stt = bid.substr(9, 15);
0793 std::istringstream r12(stt);
0794 r12 >> EBrms12[iEBChannel];
0795 if (EBrms12[iEBChannel] != 0. && EBrms12[iEBChannel] < 5.) {
0796 RingMean[ring][izz][0] += EBrms12[iEBChannel];
0797 RingRMS[ring][izz][0] += EBrms12[iEBChannel] * EBrms12[iEBChannel];
0798 NbVal[ring][izz][0]++;
0799 }
0800 fxml >> bid;
0801 stt = bid.substr(9, 15);
0802 std::istringstream m6(stt);
0803 m6 >> EBmean6[iEBChannel];
0804 fxml >> bid;
0805 stt = bid.substr(8, 15);
0806 std::istringstream r6(stt);
0807 r6 >> EBrms6[iEBChannel];
0808 if (EBrms6[iEBChannel] != 0. && EBrms6[iEBChannel] < 5.) {
0809 RingMean[ring][izz][1] += EBrms6[iEBChannel];
0810 RingRMS[ring][izz][1] += EBrms6[iEBChannel] * EBrms6[iEBChannel];
0811 NbVal[ring][izz][1]++;
0812 }
0813 fxml >> bid;
0814 stt = bid.substr(9, 15);
0815 std::istringstream m1(stt);
0816 m1 >> EBmean1[iEBChannel];
0817 fxml >> bid;
0818 stt = bid.substr(8, 15);
0819 std::istringstream r1(stt);
0820 r1 >> EBrms1[iEBChannel];
0821 if (EBrms1[iEBChannel] != 0. && EBrms1[iEBChannel] < 5.) {
0822 RingMean[ring][izz][2] += EBrms1[iEBChannel];
0823 RingRMS[ring][izz][2] += EBrms1[iEBChannel] * EBrms1[iEBChannel];
0824 NbVal[ring][izz][2]++;
0825 }
0826 if (iEBChannel % 10000 == 0)
0827 fout << " EB channel " << iEBChannel << " " << EBmean12[iEBChannel] << " " << EBrms12[iEBChannel] << " "
0828 << EBmean6[iEBChannel] << " " << EBrms6[iEBChannel] << " " << EBmean1[iEBChannel] << " "
0829 << EBrms1[iEBChannel] << std::endl;
0830 for (int i = 0; i < 3; i++)
0831 std::getline(fxml, dummyLine);
0832 }
0833
0834
0835 std::ifstream fCrystal;
0836 fCrystal.open("Crystal");
0837 if (!fCrystal.is_open()) {
0838 edm::LogInfo("ERROR : cannot open file Crystal");
0839 exit(1);
0840 }
0841 int ringEE[kEEChannels];
0842 for (int iChannel = 0; iChannel < kEEChannels; iChannel++) {
0843 fCrystal >> ringEE[iChannel];
0844 int ring = abs(ringEE[iChannel]) - 1;
0845 if (ring < 17 || ring > 27) {
0846 edm::LogInfo(" EE channel ") << iChannel << " ring " << ringEE[iChannel];
0847 exit(-1);
0848 }
0849 }
0850 fCrystal.close();
0851
0852 float EEmean12[kEEChannels], EErms12[kEEChannels], EEmean6[kEEChannels], EErms6[kEEChannels], EEmean1[kEEChannels],
0853 EErms1[kEEChannels];
0854 for (int i = 0; i < 6; i++)
0855 std::getline(fxml, dummyLine);
0856 for (int iEEChannel = 0; iEEChannel < kEEChannels; iEEChannel++) {
0857
0858 fxml >> bid;
0859 std::string stt = bid.substr(10, 15);
0860 std::istringstream m12(stt);
0861 m12 >> EEmean12[iEEChannel];
0862 int ring = abs(ringEE[iEEChannel]) - 1;
0863 if (ring < 17 || ring > 27)
0864 edm::LogInfo("EE channel ") << iEEChannel << " ring " << ring;
0865 int izz = 1;
0866 if (iEEChannel < 7324)
0867 izz = 0;
0868 fxml >> bid;
0869 stt = bid.substr(9, 15);
0870 std::istringstream r12(stt);
0871 r12 >> EErms12[iEEChannel];
0872 if (EErms12[iEEChannel] != 0. && EErms12[iEEChannel] < 5.) {
0873 RingMean[ring][izz][0] += EErms12[iEEChannel];
0874 RingRMS[ring][izz][0] += EErms12[iEEChannel] * EErms12[iEEChannel];
0875 NbVal[ring][izz][0]++;
0876 }
0877 fxml >> bid;
0878 stt = bid.substr(9, 15);
0879 std::istringstream m6(stt);
0880 m6 >> EEmean6[iEEChannel];
0881 fxml >> bid;
0882 stt = bid.substr(8, 15);
0883 std::istringstream r6(stt);
0884 r6 >> EErms6[iEEChannel];
0885 if (EErms6[iEEChannel] != 0. && EErms6[iEEChannel] < 5.) {
0886 RingMean[ring][izz][1] += EErms6[iEEChannel];
0887 RingRMS[ring][izz][1] += EErms6[iEEChannel] * EErms6[iEEChannel];
0888 NbVal[ring][izz][1]++;
0889 }
0890 fxml >> bid;
0891 stt = bid.substr(9, 15);
0892 std::istringstream m1(stt);
0893 m1 >> EEmean1[iEEChannel];
0894 fxml >> bid;
0895 stt = bid.substr(8, 15);
0896 std::istringstream r1(stt);
0897 r1 >> EErms1[iEEChannel];
0898 if (EErms1[iEEChannel] != 0. && EErms1[iEEChannel] < 5.) {
0899 RingMean[ring][izz][2] += EErms1[iEEChannel];
0900 RingRMS[ring][izz][2] += EErms1[iEEChannel] * EErms1[iEEChannel];
0901 NbVal[ring][izz][2]++;
0902 }
0903 if (iEEChannel % 1000 == 0)
0904 fout << " EE channel " << iEEChannel << " " << EEmean12[iEEChannel] << " " << EErms12[iEEChannel] << " "
0905 << EEmean6[iEEChannel] << " " << EErms6[iEEChannel] << " " << EEmean1[iEEChannel] << " "
0906 << EErms1[iEEChannel] << std::endl;
0907 for (int i = 0; i < 3; i++)
0908 std::getline(fxml, dummyLine);
0909 }
0910
0911 fxml.close();
0912
0913 for (int gain = 0; gain < kGains; gain++) {
0914 fout << "\n"
0915 << "**** Gain **** " << gainValues[gain] << "\n";
0916 for (int ring = 0; ring < 28; ring++) {
0917 for (int side = 0; side < 2; side++) {
0918 if (NbVal[ring][side][gain] <= 0) {
0919 edm::LogInfo(" No entry for ring ") << ring;
0920 exit(-1);
0921 }
0922 RingMean[ring][side][gain] /= (double)NbVal[ring][side][gain];
0923 double x = RingMean[ring][side][gain];
0924 RingRMS[ring][side][gain] /= (double)NbVal[ring][side][gain];
0925 double rms = sqrt(RingRMS[ring][side][gain] - x * x);
0926 RingRMS[ring][side][gain] = rms;
0927 fout << " ring " << ring + 1 << " mean " << x << " rms " << rms << " ";
0928 }
0929 fout << std::endl;
0930 if (ring == 16)
0931 fout << "***** End caps ***** EE- EE+" << std::endl;
0932 }
0933 }
0934
0935
0936
0937 EcalPedestals* ped = new EcalPedestals();
0938
0939 for (int iEta = -EBDetId::MAX_IETA; iEta <= EBDetId::MAX_IETA; ++iEta) {
0940 if (iEta == 0)
0941 continue;
0942 for (int iPhi = EBDetId::MIN_IPHI; iPhi <= EBDetId::MAX_IPHI; ++iPhi) {
0943 if (EBDetId::validDetId(iEta, iPhi)) {
0944 EBDetId ebdetid(iEta, iPhi);
0945 unsigned int hieb = ebdetid.hashedIndex();
0946 EcalPedestals::Item item;
0947 item.mean_x1 = 200.;
0948 item.mean_x6 = 200.;
0949 item.mean_x12 = 200.;
0950 if (m_corrected) {
0951 int ring = (abs(iEta) - 1) / 5;
0952 if (ring < 0 || ring > 16)
0953 edm::LogInfo("EB channel ") << hieb << " ring " << ring;
0954 int side = 0;
0955 if (iEta > 0)
0956 side = 1;
0957 if (EBrms1[hieb] == 0 || EBrms1[hieb] > RingMean[ring][side][2] + 3 * RingRMS[ring][side][2]) {
0958 fout << " EB channel " << hieb << " eta " << iEta << " phi " << iPhi << " ring " << ring + 1
0959 << " gain 1 rms " << EBrms1[hieb] << " replaced by " << RingMean[ring][side][2] << std::endl;
0960 item.rms_x1 = RingMean[ring][side][2];
0961 } else
0962 item.rms_x1 = EBrms1[hieb];
0963 if (EBrms6[hieb] == 0 || EBrms6[hieb] > RingMean[ring][side][1] + 3 * RingRMS[ring][side][1]) {
0964 fout << " EB channel " << hieb << " eta " << iEta << " phi " << iPhi << " ring " << ring + 1
0965 << " gain 6 rms " << EBrms6[hieb] << " replaced by " << RingMean[ring][side][1] << std::endl;
0966 item.rms_x6 = RingMean[ring][side][1];
0967 } else
0968 item.rms_x6 = EBrms6[hieb];
0969 if (EBrms12[hieb] == 0 || EBrms12[hieb] > RingMean[ring][side][0] + 3 * RingRMS[ring][side][0]) {
0970 fout << " EB channel " << hieb << " eta " << iEta << " phi " << iPhi << " ring " << ring + 1
0971 << " gain 12 rms " << EBrms12[hieb] << " replaced by " << RingMean[ring][side][0] << std::endl;
0972 item.rms_x12 = RingMean[ring][side][0];
0973 } else
0974 item.rms_x12 = EBrms12[hieb];
0975 if (hieb > 4534 && hieb < 4540)
0976 edm::LogInfo(" Channel ") << hieb << " ring " << ring << " 12 " << EBrms12[hieb] << " mean "
0977 << RingMean[ring][side][0] << " rms " << RingRMS[ring][side][0] << " 6 "
0978 << EBrms6[hieb] << " mean " << RingMean[ring][side][1] << " rms "
0979 << RingRMS[ring][side][1] << " 1 " << EBrms1[hieb] << " mean "
0980 << RingMean[ring][side][2] << " rms " << RingRMS[ring][side][2];
0981 }
0982 else {
0983 item.rms_x1 = EBrms1[hieb];
0984 item.rms_x6 = EBrms6[hieb];
0985 item.rms_x12 = EBrms12[hieb];
0986 }
0987 if (item.rms_x1 > 4. || item.rms_x6 > 4. || item.rms_x12 > 4.)
0988 edm::LogInfo(" Channel ") << hieb << " 12 " << item.rms_x12 << " 6 " << item.rms_x6 << " 1 " << item.rms_x1;
0989 ped->insert(std::make_pair(ebdetid.rawId(), item));
0990 }
0991 }
0992 }
0993
0994
0995 for (int iz = -1; iz < 2; iz = iz + 2) {
0996 for (int iX = EEDetId::IX_MIN; iX <= EEDetId::IX_MAX; ++iX) {
0997 for (int iY = EEDetId::IY_MIN; iY <= EEDetId::IY_MAX; ++iY) {
0998 if (EEDetId::validDetId(iX, iY, iz)) {
0999 EEDetId eedetid(iX, iY, iz);
1000 unsigned int hiee = eedetid.hashedIndex();
1001
1002 EcalPedestals::Item item;
1003 item.mean_x1 = 200.;
1004 item.mean_x6 = 200.;
1005 item.mean_x12 = 200.;
1006 if (m_corrected) {
1007 int ring = abs(ringEE[hiee]) - 1;
1008 if (ring < 17 || ring > 27)
1009 edm::LogInfo("EE channel ") << hiee << " ring " << ring;
1010 if (EErms1[hiee] == 0 || EErms1[hiee] > RingMean[ring][iz][2] + 3 * RingRMS[ring][iz][2]) {
1011 fout << " EE channel " << hiee << " x " << iX << " y " << iY << " z " << iz << " ring " << ring + 1
1012 << " gain 1 rms " << EErms1[hiee] << " replaced by " << RingMean[ring][iz][2] << std::endl;
1013 item.rms_x1 = RingMean[ring][iz][2];
1014 } else
1015 item.rms_x1 = EErms1[hiee];
1016 if (EErms6[hiee] == 0 || EErms6[hiee] > RingMean[ring][iz][1] + 3 * RingRMS[ring][iz][1]) {
1017 fout << " EE channel " << hiee << " x " << iX << " y " << iY << " z " << iz << " ring " << ring + 1
1018 << " gain 6 rms " << EErms6[hiee] << " replaced by " << RingMean[ring][iz][1] << std::endl;
1019 item.rms_x6 = RingMean[ring][iz][1];
1020 } else
1021 item.rms_x6 = EErms6[hiee];
1022 if (EErms12[hiee] == 0 || EErms12[hiee] > RingMean[ring][iz][0] + 3 * RingRMS[ring][iz][0]) {
1023 fout << " EE channel " << hiee << " x " << iX << " y " << iY << " z " << iz << " ring " << ring + 1
1024 << " gain 12 rms " << EErms12[hiee] << " replaced by " << RingMean[ring][iz][0] << std::endl;
1025 item.rms_x12 = RingMean[ring][iz][0];
1026 } else
1027 item.rms_x12 = EErms12[hiee];
1028 }
1029 else {
1030 item.rms_x1 = EErms1[hiee];
1031 item.rms_x6 = EErms6[hiee];
1032 item.rms_x12 = EErms12[hiee];
1033 }
1034 ped->insert(std::make_pair(eedetid.rawId(), item));
1035 }
1036 }
1037 }
1038 }
1039 fout.close();
1040
1041 unsigned int irun = m_firstRun;
1042 Time_t snc = (Time_t)irun;
1043 m_to_transfer.push_back(std::make_pair((EcalPedestals*)ped, snc));
1044
1045 edm::LogInfo("Ecal - > end of readPedestalMC -----------\n");
1046 }
1047
1048
1049
1050 void popcon::EcalPedestalsHandler::readPedestal2017() {
1051 bool debug = false;
1052 edm::LogInfo(" reading local Pedestal run (2017 way)! ") << m_filename;
1053
1054
1055 Ref ped_db = lastPayload();
1056 EcalPedestals* peds = new EcalPedestals();
1057 edm::LogInfo("retrieved last payload ");
1058
1059 for (int iEta = -EBDetId::MAX_IETA; iEta <= EBDetId::MAX_IETA; ++iEta) {
1060 if (iEta == 0)
1061 continue;
1062 for (int iPhi = EBDetId::MIN_IPHI; iPhi <= EBDetId::MAX_IPHI; ++iPhi) {
1063
1064 if (EBDetId::validDetId(iEta, iPhi)) {
1065 EBDetId ebdetid(iEta, iPhi, EBDetId::ETAPHIMODE);
1066 EcalPedestals::const_iterator it = ped_db->find(ebdetid.rawId());
1067 EcalPedestals::Item aped = (*it);
1068
1069 EcalPedestals::Item item;
1070 item.mean_x1 = aped.mean_x1;
1071 item.rms_x1 = aped.rms_x1;
1072 item.mean_x6 = aped.mean_x6;
1073 item.rms_x6 = aped.rms_x6;
1074 item.mean_x12 = aped.mean_x12;
1075 item.rms_x12 = aped.rms_x12;
1076 peds->insert(std::make_pair(ebdetid.rawId(), item));
1077 }
1078 }
1079 }
1080 for (int iX = EEDetId::IX_MIN; iX <= EEDetId::IX_MAX; ++iX) {
1081 for (int iY = EEDetId::IY_MIN; iY <= EEDetId::IY_MAX; ++iY) {
1082
1083 if (EEDetId::validDetId(iX, iY, 1)) {
1084 EEDetId eedetidpos(iX, iY, 1);
1085 EcalPedestals::const_iterator it = ped_db->find(eedetidpos.rawId());
1086 EcalPedestals::Item aped = (*it);
1087
1088 EcalPedestals::Item item;
1089 item.mean_x1 = aped.mean_x1;
1090 item.rms_x1 = aped.rms_x1;
1091 item.mean_x6 = aped.mean_x6;
1092 item.rms_x6 = aped.rms_x6;
1093 item.mean_x12 = aped.mean_x12;
1094 item.rms_x12 = aped.rms_x12;
1095 peds->insert(std::make_pair(eedetidpos.rawId(), item));
1096 }
1097 if (EEDetId::validDetId(iX, iY, -1)) {
1098 EEDetId eedetidneg(iX, iY, -1);
1099 EcalPedestals::const_iterator it = ped_db->find(eedetidneg.rawId());
1100 EcalPedestals::Item aped = (*it);
1101
1102 EcalPedestals::Item item;
1103 item.mean_x1 = aped.mean_x1;
1104 item.rms_x1 = aped.rms_x1;
1105 item.mean_x6 = aped.mean_x6;
1106 item.rms_x6 = aped.rms_x6;
1107 item.mean_x12 = aped.mean_x12;
1108 item.rms_x12 = aped.rms_x12;
1109 peds->insert(std::make_pair(eedetidneg.rawId(), item));
1110 }
1111 }
1112 }
1113
1114 edm::LogInfo(" reading the input file ") << m_filename;
1115 std::ifstream fInput;
1116 fInput.open(m_filename);
1117 if (!fInput.is_open()) {
1118 edm::LogInfo("ERROR : cannot open file ") << m_filename;
1119 exit(1);
1120 }
1121
1122 int hashedId;
1123 float EBmean12[kEBChannels], EBrms12[kEBChannels], EBmean6[kEBChannels], EBrms6[kEBChannels], EBmean1[kEBChannels],
1124 EBrms1[kEBChannels];
1125
1126
1127 for (int iChannel = 0; iChannel < kEBChannels; iChannel++) {
1128 fInput >> hashedId >> EBmean12[iChannel] >> EBrms12[iChannel] >> EBmean6[iChannel] >> EBrms6[iChannel] >>
1129 EBmean1[iChannel] >> EBrms1[iChannel];
1130 if (hashedId != iChannel + 1) {
1131 edm::LogInfo("File ") << m_filename << " strange hash " << hashedId << " while iChannel " << iChannel;
1132 exit(-1);
1133 }
1134 }
1135
1136
1137 float EEmean12[kEEChannels], EErms12[kEEChannels], EEmean6[kEEChannels], EErms6[kEEChannels], EEmean1[kEEChannels],
1138 EErms1[kEEChannels];
1139 for (int iChannel = 0; iChannel < kEEChannels; iChannel++) {
1140 fInput >> hashedId >> EEmean12[iChannel] >> EErms12[iChannel] >> EEmean6[iChannel] >> EErms6[iChannel] >>
1141 EEmean1[iChannel] >> EErms1[iChannel];
1142 if (hashedId != iChannel + kEBChannels + 1) {
1143 edm::LogInfo("File ") << m_filename << " strange hash " << hashedId << " while iChannel " << iChannel;
1144 exit(-1);
1145 }
1146 }
1147 fInput.close();
1148
1149 EcalPedestals* ped = new EcalPedestals();
1150
1151 for (int iEta = -EBDetId::MAX_IETA; iEta <= EBDetId::MAX_IETA; ++iEta) {
1152 if (iEta == 0)
1153 continue;
1154 for (int iPhi = EBDetId::MIN_IPHI; iPhi <= EBDetId::MAX_IPHI; ++iPhi) {
1155 if (EBDetId::validDetId(iEta, iPhi)) {
1156 EBDetId ebdetid(iEta, iPhi);
1157 unsigned int hieb = ebdetid.hashedIndex();
1158 EcalPedestals::Item item;
1159 EcalPedestals::Item previous_ped = peds->barrel(hieb);
1160 if (debug & (EBmean12[hieb] == -999. || EBrms12[hieb] == -999. || EBmean6[hieb] == -999. ||
1161 EBrms6[hieb] == -999. || EBmean1[hieb] == -999. || EBrms1[hieb] == -999.))
1162 edm::LogInfo(" bad EB channel eta ")
1163 << iEta << " phi " << iPhi << " " << EBmean12[hieb] << " " << EBrms12[hieb] << " " << EBmean6[hieb] << " "
1164 << EBrms6[hieb] << " " << EBmean1[hieb] << " " << EBrms1[hieb];
1165 if (EBmean1[hieb] != -999.)
1166 item.mean_x1 = EBmean1[hieb];
1167 else
1168 item.mean_x1 = previous_ped.mean_x1;
1169 if (EBrms1[hieb] != -999.)
1170 item.rms_x1 = EBrms1[hieb];
1171 else
1172 item.rms_x1 = previous_ped.rms_x1;
1173 if (EBmean6[hieb] != -999.)
1174 item.mean_x6 = EBmean6[hieb];
1175 else
1176 item.mean_x6 = previous_ped.mean_x6;
1177 if (EBrms6[hieb] != -999.)
1178 item.rms_x6 = EBrms6[hieb];
1179 else
1180 item.rms_x6 = previous_ped.rms_x6;
1181 if (EBmean12[hieb] != -999.)
1182 item.mean_x12 = EBmean12[hieb];
1183 else
1184 item.mean_x12 = previous_ped.mean_x12;
1185 if (EBrms12[hieb] != -999.)
1186 item.rms_x12 = EBrms12[hieb];
1187 else
1188 item.rms_x12 = previous_ped.rms_x12;
1189 ped->insert(std::make_pair(ebdetid.rawId(), item));
1190 }
1191 }
1192 }
1193
1194
1195
1196 for (int iz = -1; iz < 2; iz = iz + 2) {
1197 for (int iX = EEDetId::IX_MIN; iX <= EEDetId::IX_MAX; ++iX) {
1198 for (int iY = EEDetId::IY_MIN; iY <= EEDetId::IY_MAX; ++iY) {
1199 if (EEDetId::validDetId(iX, iY, iz)) {
1200 EEDetId eedetid(iX, iY, iz);
1201 unsigned int hiee = eedetid.hashedIndex();
1202
1203 EcalPedestals::Item item;
1204 EcalPedestals::Item previous_ped = peds->endcap(hiee);
1205 if (debug & (EEmean12[hiee] == -999. || EErms12[hiee] == -999. || EEmean6[hiee] == -999. ||
1206 EErms6[hiee] == -999. || EEmean1[hiee] == -999. || EErms1[hiee] == -999.))
1207 edm::LogInfo(" bad EE channel x ")
1208 << iX << " y " << iY << " z" << iz << " " << EEmean12[hiee] << " " << EErms12[hiee] << " "
1209 << EEmean6[hiee] << " " << EErms6[hiee] << " " << EEmean1[hiee] << " " << EErms1[hiee];
1210 if (EEmean1[hiee] != -999.)
1211 item.mean_x1 = EEmean1[hiee];
1212 else
1213 item.mean_x1 = previous_ped.mean_x1;
1214 if (EErms1[hiee] != -999.)
1215 item.rms_x1 = EErms1[hiee];
1216 else
1217 item.rms_x1 = previous_ped.rms_x1;
1218 if (EEmean6[hiee] != -999.)
1219 item.mean_x6 = EEmean6[hiee];
1220 else
1221 item.mean_x6 = previous_ped.mean_x6;
1222 if (EErms6[hiee] != -999.)
1223 item.rms_x6 = EErms6[hiee];
1224 else
1225 item.rms_x6 = previous_ped.rms_x6;
1226 if (EEmean12[hiee] != -999.)
1227 item.mean_x12 = EEmean12[hiee];
1228 else
1229 item.mean_x12 = previous_ped.mean_x12;
1230 if (EErms12[hiee] != -999.)
1231 item.rms_x12 = EErms12[hiee];
1232 else
1233 item.rms_x12 = previous_ped.rms_x12;
1234 ped->insert(std::make_pair(eedetid.rawId(), item));
1235 }
1236 }
1237 }
1238 }
1239
1240
1241 unsigned int irun = m_firstRun;
1242 Time_t snc = (Time_t)irun;
1243 m_to_transfer.push_back(std::make_pair((EcalPedestals*)ped, snc));
1244
1245 edm::LogInfo("Ecal - > end of readPedestal2017 -----------\n");
1246 }
1247
1248
1249 void popcon::EcalPedestalsHandler::readPedestalTree() {
1250 edm::LogInfo(" reading the root file ") << m_filename;
1251 TFile* hfile = new TFile(m_filename.c_str());
1252
1253 TTree* treeChan = (TTree*)hfile->Get("PedChan");
1254 int iChannel = 0, ix = 0, iy = 0, iz = 0;
1255 treeChan->SetBranchAddress("Channels", &iChannel);
1256 treeChan->SetBranchAddress("x", &ix);
1257 treeChan->SetBranchAddress("y", &iy);
1258 treeChan->SetBranchAddress("z", &iz);
1259 int neventsChan = (int)treeChan->GetEntries();
1260 edm::LogInfo("PedChan nb entries ") << neventsChan;
1261 int ringEB[kEBChannels], sideEB[kEBChannels], ixEE[kEEChannels], iyEE[kEEChannels], izEE[kEEChannels];
1262 for (int entry = 0; entry < neventsChan; entry++) {
1263 treeChan->GetEntry(entry);
1264 if (entry < kEBChannels) {
1265 ringEB[iChannel] = (abs(ix) - 1) / 5;
1266 sideEB[iChannel] = 1;
1267 if (ix < 0)
1268 sideEB[iChannel] = 0;
1269 if (entry % 10000 == 0)
1270 edm::LogInfo(" EB channel ") << iChannel << " eta " << ix << " phi " << iy << " side " << sideEB[iChannel]
1271 << " ring " << ringEB[iChannel];
1272 } else {
1273 ixEE[iChannel] = ix;
1274 iyEE[iChannel] = iy;
1275 izEE[iChannel] = iz;
1276 if (entry % 1000 == 0)
1277 edm::LogInfo(" EE channel ") << iChannel << " x " << ixEE[iChannel] << " y " << iyEE[iChannel] << " z "
1278 << izEE[iChannel];
1279 }
1280 }
1281
1282 Int_t pedxml[Nbpedxml] = {271948,
1283 273634,
1284 273931,
1285 274705,
1286 275403,
1287 276108,
1288 276510,
1289 277169,
1290 278123,
1291 278183,
1292 278246,
1293 278389,
1294 278499,
1295 278693,
1296 278858,
1297 278888,
1298 278931,
1299 279728,
1300 280129,
1301 280263,
1302 280941,
1303 281753,
1304 282631,
1305 282833,
1306 283199,
1307 283766,
1308
1309 286535,
1310 293513,
1311 293632,
1312 293732,
1313 295507,
1314 295672,
1315 296391,
1316 296917,
1317 297388,
1318 298481,
1319 299279,
1320 299710,
1321 300186,
1322 300581,
1323 301191,
1324 302006,
1325 302293,
1326 302605,
1327 303436,
1328 303848,
1329 304211,
1330 304680,
1331 305117,
1332 305848,
1333 306176,
1334
1335 313760,
1336 315434,
1337 315831,
1338 316299,
1339 316694,
1340 316963,
1341 317399,
1342 317669,
1343 318249,
1344 318747,
1345 319111,
1346 319365,
1347 319700,
1348 320098,
1349 320515,
1350 320905,
1351 321184,
1352 321480,
1353 321855,
1354 322151,
1355 322653,
1356 323261,
1357 323802,
1358 324250,
1359 324632,
1360 325909,
1361 326038,
1362 326652,
1363 326979,
1364 327271};
1365
1366 Int_t run16Index = 0;
1367
1368 Int_t fed[kChannels], chan[kChannels], id, run, run_type, seq_id, las_id, fill_num, run_num_infill, run_time,
1369 run_time_stablebeam, nxt, time[54];
1370 Float_t ped[kChannels], pedrms[kChannels], lumi, bfield;
1371 TTree* tree = (TTree*)hfile->Get("T");
1372 tree->Print();
1373 tree->SetBranchAddress("id", &id);
1374 tree->SetBranchAddress("run", &run);
1375 tree->SetBranchAddress("run_type", &run_type);
1376 tree->SetBranchAddress("seq_id", &seq_id);
1377 tree->SetBranchAddress("las_id", &las_id);
1378 tree->SetBranchAddress("fill_num", &fill_num);
1379 tree->SetBranchAddress("run_num_infill", &run_num_infill);
1380 tree->SetBranchAddress("run_time", &run_time);
1381 tree->SetBranchAddress("run_time_stablebeam", &run_time_stablebeam);
1382 tree->SetBranchAddress("lumi", &lumi);
1383 tree->SetBranchAddress("bfield", &bfield);
1384 tree->SetBranchAddress("nxt", &nxt);
1385 tree->SetBranchAddress("time", time);
1386 tree->SetBranchAddress("fed", fed);
1387 tree->SetBranchAddress("chan", chan);
1388 tree->SetBranchAddress("ped", ped);
1389 tree->SetBranchAddress("pedrms", pedrms);
1390 int nevents = (int)tree->GetEntries();
1391 edm::LogInfo(" nb entries ") << nevents;
1392 std::ofstream fout;
1393 fout.open("copyTreePedestals.txt");
1394 if (!fout.is_open()) {
1395 edm::LogInfo("ERROR : cannot open file copyTreePedestals.txt");
1396 exit(1);
1397 }
1398 Double_t EAmean1[kChannels], EArms1[kChannels], EAmean6[kChannels], EArms6[kChannels], EAmean12[kChannels],
1399 EArms12[kChannels];
1400 Int_t RunEntry = 0, EAentry[kChannels];
1401 for (int ich = 0; ich < kChannels; ich++) {
1402 EAmean12[ich] = 0;
1403 EArms12[ich] = 0;
1404 EAentry[ich] = 0;
1405 }
1406 tree->GetEntry(0);
1407 fout << " first run " << run << " fill " << fill_num << " B field " << bfield << " run type " << run_type
1408 << " seq_id " << seq_id << " las_id " << las_id << " run_num_infill " << run_num_infill << " lumi " << lumi
1409 << " nb of Crystals " << nxt << std::endl;
1410 for (int ich = 0; ich < kChannels; ich++) {
1411 if (ped[ich] != 0.) {
1412 if (ich < kEBChannels)
1413 fout << " channel " << ich << " FED " << fed[ich] << " chan " << chan[ich] << " pedestal " << ped[ich]
1414 << " RMS " << pedrms[ich] << std::endl;
1415 else
1416 fout << " channel " << ich << " EE channel " << ich - kEBChannels << " FED " << fed[ich] << " chan "
1417 << chan[ich] << " pedestal " << ped[ich] << " RMS " << pedrms[ich] << std::endl;
1418 }
1419 }
1420
1421 int run_type_kept = m_runtype;
1422 int first_run_kept = (int)m_firstRun;
1423 int last_run_kept = (int)m_lastRun;
1424 int runold = run;
1425 int firsttimeFED = -1;
1426
1427 for (int entry = 0; entry < nevents; entry++) {
1428 tree->GetEntry(entry);
1429 if (run < first_run_kept) {
1430 fout << " entry " << entry << " run " << run << " sequence " << seq_id << " run_time " << run_time
1431 << " before first wanted " << m_firstRun << std::endl;
1432 runold = run;
1433 continue;
1434 }
1435 if (run > last_run_kept) {
1436 fout << " entry " << entry << " run " << run << " sequence " << seq_id << " run_time " << run_time
1437 << " after last wanted " << m_lastRun << std::endl;
1438 runold = run;
1439 break;
1440 }
1441 if (run_type != run_type_kept) {
1442 fout << " entry " << entry << " run " << run << " sequence " << seq_id << " run_time " << run_time << " run type "
1443 << run_type << std::endl;
1444 continue;
1445 }
1446 if (nxt != kChannels) {
1447 fout << " entry " << entry << " run " << run << " sequence " << seq_id << " run_time " << run_time
1448 << " *********** Number of channels " << nxt << std::endl;
1449 continue;
1450 }
1451 if (bfield < 3.79) {
1452 fout << " entry " << entry << " run " << run << " sequence " << seq_id << " run_time " << run_time
1453 << " *********** bfield = " << bfield << std::endl;
1454
1455 }
1456 if (run_type_kept == 1) {
1457 int time_seq = 0;
1458 for (int ifed = 0; ifed < 54; ifed++) {
1459 if (time[ifed] < run_time_stablebeam) {
1460 if (time_seq == 0)
1461 fout << " entry " << entry << " run " << run << " sequence " << seq_id << " run_time " << run_time
1462 << " *********** sequence before stable beam at " << run_time_stablebeam << " FED " << ifed << " : "
1463 << time[ifed];
1464 else
1465 fout << " FED " << ifed << " : " << time[ifed];
1466 time_seq++;
1467 }
1468 }
1469 if (time_seq != 0) {
1470 fout << " total nb " << time_seq << std::endl;
1471 continue;
1472 }
1473 }
1474
1475
1476
1477
1478 if (run == runold) {
1479 RunEntry++;
1480 for (int ich = 0; ich < kChannels; ich++) {
1481 if (ped[ich] < 300 && ped[ich] > 100) {
1482 EAmean12[ich] += ped[ich];
1483 EArms12[ich] += pedrms[ich];
1484 EAentry[ich]++;
1485 }
1486 }
1487 } else {
1488
1489
1490
1491 if (RunEntry == 0 || (run_type_kept == 2 && RunEntry < 6))
1492 fout << " skiped run " << runold << " not enough entries : " << RunEntry << std::endl;
1493 else {
1494 fout << " entry " << entry - 1 << " run " << runold << " nb of events " << RunEntry;
1495 firsttimeFED = time[0];
1496 for (int ifed = 0; ifed < 54; ifed++) {
1497 fout << " " << time[ifed];
1498 if (firsttimeFED < time[ifed])
1499 firsttimeFED = time[ifed];
1500 }
1501 fout << std::endl;
1502
1503
1504 bool foundNew = false;
1505 for (int i = run16Index; i < Nbpedxml; i++) {
1506 if (runold > pedxml[i]) {
1507 fout << " found a new gain 1, 6 file " << pedxml[i] << " at index " << i << std::endl;
1508 run16Index++;
1509 foundNew = true;
1510 if (runold < pedxml[i + 1])
1511 break;
1512 }
1513 }
1514 if (foundNew) {
1515 int Indexxml = run16Index - 1;
1516 fout << " opening Pedestals_" << pedxml[Indexxml] << ".xml at index " << Indexxml << std::endl;
1517 std::ifstream fxml;
1518 fxml.open(Form("Pedestals_%i.xml", pedxml[Indexxml]));
1519 if (!fxml.is_open()) {
1520 edm::LogInfo("ERROR : cannot open file Pedestals_") << pedxml[Indexxml] << ".xml";
1521 exit(1);
1522 }
1523 std::string dummyLine, mean12, rms12, bid;
1524 for (int i = 0; i < 9; i++)
1525 std::getline(fxml, dummyLine);
1526
1527 for (int iEBChannel = 0; iEBChannel < kEBChannels; iEBChannel++) {
1528 fxml >> mean12 >> rms12 >> bid;
1529
1530
1531
1532
1533
1534
1535
1536
1537 std::string stt = bid.substr(9, 15);
1538 std::istringstream m6(stt);
1539 m6 >> EAmean6[iEBChannel];
1540 fxml >> bid;
1541 stt = bid.substr(8, 15);
1542 std::istringstream r6(stt);
1543 r6 >> EArms6[iEBChannel];
1544 fxml >> bid;
1545 stt = bid.substr(9, 15);
1546 std::istringstream m1(stt);
1547 m1 >> EAmean1[iEBChannel];
1548 fxml >> bid;
1549 stt = bid.substr(8, 15);
1550 std::istringstream r1(stt);
1551 r1 >> EArms1[iEBChannel];
1552 if (iEBChannel % 10000 == 0)
1553 fout << " EB channel " << iEBChannel << " " << mean12 << " " << rms12 << " " << EAmean6[iEBChannel] << " "
1554 << EArms6[iEBChannel] << " " << EAmean1[iEBChannel] << " " << EArms1[iEBChannel] << std::endl;
1555 for (int i = 0; i < 3; i++)
1556 std::getline(fxml, dummyLine);
1557 }
1558 for (int i = 0; i < 6; i++)
1559 std::getline(fxml, dummyLine);
1560 for (int iEEChannel = 0; iEEChannel < kEEChannels; iEEChannel++) {
1561 int ich = iEEChannel + kEBChannels;
1562 fxml >> mean12 >> rms12 >> bid;
1563 std::string stt = bid.substr(9, 15);
1564 std::istringstream m6(stt);
1565 m6 >> EAmean6[ich];
1566 fxml >> bid;
1567 stt = bid.substr(8, 15);
1568 std::istringstream r6(stt);
1569 r6 >> EArms6[ich];
1570 fxml >> bid;
1571 stt = bid.substr(9, 15);
1572 std::istringstream m1(stt);
1573 m1 >> EAmean1[ich];
1574 fxml >> bid;
1575 stt = bid.substr(8, 15);
1576 std::istringstream r1(stt);
1577 r1 >> EArms1[ich];
1578 if (iEEChannel % 1000 == 0)
1579 fout << " EE channel " << iEEChannel << " " << mean12 << " " << rms12 << " " << EAmean6[ich] << " "
1580 << EArms6[ich] << " " << EAmean1[ich] << " " << EArms1[ich] << std::endl;
1581 for (int i = 0; i < 3; i++)
1582 std::getline(fxml, dummyLine);
1583 }
1584
1585 fxml.close();
1586 }
1587
1588
1589 EcalPedestals* pedestal = new EcalPedestals();
1590 EcalPedestals::Item item;
1591 for (int ich = 0; ich < kChannels; ich++) {
1592 if (EAentry[ich] != 0) {
1593 EAmean12[ich] /= EAentry[ich];
1594 EArms12[ich] /= EAentry[ich];
1595 } else {
1596 EAmean12[ich] = 200.;
1597 EArms12[ich] = 0.;
1598 }
1599 if (ich % 10000 == 0)
1600 fout << " channel " << ich << " ped " << EAmean12[ich] << " RMS " << EArms12[ich] << std::endl;
1601
1602 item.mean_x1 = EAmean1[ich];
1603 item.rms_x1 = EArms1[ich];
1604 item.mean_x6 = EAmean6[ich];
1605 item.rms_x6 = EArms6[ich];
1606 item.mean_x12 = EAmean12[ich];
1607 item.rms_x12 = EArms12[ich];
1608 if (ich < kEBChannels) {
1609
1610 EBDetId ebdetid = EBDetId::unhashIndex(ich);
1611 pedestal->insert(std::make_pair(ebdetid.rawId(), item));
1612 } else {
1613
1614 int iChannel = ich - kEBChannels;
1615 EEDetId eedetid = EEDetId::unhashIndex(iChannel);
1616 pedestal->insert(std::make_pair(eedetid.rawId(), item));
1617 }
1618 }
1619 Time_t snc = (Time_t)runold;
1620 m_to_transfer.push_back(std::make_pair((EcalPedestals*)pedestal, snc));
1621 }
1622
1623 runold = run;
1624 RunEntry = 1;
1625 for (int ich = 0; ich < kChannels; ich++) {
1626 if (ped[ich] < 300 && ped[ich] > 100) {
1627 EAmean12[ich] = ped[ich];
1628 EArms12[ich] = pedrms[ich];
1629 EAentry[ich] = 1;
1630 } else {
1631 EAmean12[ich] = 0;
1632 EArms12[ich] = 0;
1633 EAentry[ich] = 0;
1634 }
1635 }
1636 }
1637 }
1638
1639 fout << " last entry fill " << fill_num << " run " << runold << " nb of events " << RunEntry << " time " << run_time
1640 << " " << run_time_stablebeam << " " << time[0] << " run type " << run_type << std::endl;
1641 for (int ifed = 0; ifed < 54; ifed++)
1642 fout << " " << time[ifed];
1643 fout << std::endl;
1644 EcalPedestals* pedestal = new EcalPedestals();
1645 EcalPedestals::Item item;
1646 for (int ich = 0; ich < kChannels; ich++) {
1647 if (EAentry[ich] != 0) {
1648 EAmean12[ich] /= EAentry[ich];
1649 EArms12[ich] /= EAentry[ich];
1650 } else {
1651 EAmean12[ich] = 200.;
1652 EArms12[ich] = 0.;
1653 }
1654 if (ich % 10000 == 0)
1655 fout << " channel " << ich << " ped " << EAmean12[ich] << " RMS " << EArms12[ich] << std::endl;
1656
1657
1658
1659 item.mean_x1 = EAmean1[ich];
1660 item.rms_x1 = EArms1[ich];
1661 item.mean_x6 = EAmean6[ich];
1662 item.rms_x6 = EArms6[ich];
1663 item.mean_x12 = EAmean12[ich];
1664 item.rms_x12 = EArms12[ich];
1665 if (ich < kEBChannels) {
1666
1667 EBDetId ebdetid = EBDetId::unhashIndex(ich);
1668 pedestal->insert(std::make_pair(ebdetid.rawId(), item));
1669 } else {
1670
1671 int iChannel = ich - kEBChannels;
1672 EEDetId eedetid = EEDetId::unhashIndex(iChannel);
1673 pedestal->insert(std::make_pair(eedetid.rawId(), item));
1674 }
1675 }
1676 Time_t snc = (Time_t)runold;
1677 m_to_transfer.push_back(std::make_pair((EcalPedestals*)pedestal, snc));
1678 edm::LogInfo("Ecal - > end of readPedestalTree -----------\n");
1679 }
1680
1681
1682 void popcon::EcalPedestalsHandler::readPedestalTimestamp() {
1683 bool debug = false;
1684 edm::LogInfo(" reading the root file ") << m_filename;
1685 TFile* hfile = new TFile(m_filename.c_str());
1686
1687 TTree* treeChan = (TTree*)hfile->Get("PedChan");
1688 int iChannel = 0, ix = 0, iy = 0, iz = 0;
1689 treeChan->SetBranchAddress("Channels", &iChannel);
1690 treeChan->SetBranchAddress("x", &ix);
1691 treeChan->SetBranchAddress("y", &iy);
1692 treeChan->SetBranchAddress("z", &iz);
1693 int neventsChan = (int)treeChan->GetEntries();
1694 edm::LogInfo("PedChan nb entries ") << neventsChan;
1695 int ringEB[kEBChannels], sideEB[kEBChannels], ixEE[kEEChannels], iyEE[kEEChannels], izEE[kEEChannels];
1696 for (int entry = 0; entry < neventsChan; entry++) {
1697 treeChan->GetEntry(entry);
1698 if (entry < kEBChannels) {
1699 ringEB[iChannel] = (abs(ix) - 1) / 5;
1700 sideEB[iChannel] = 1;
1701 if (ix < 0)
1702 sideEB[iChannel] = 0;
1703 if (debug && entry % 10000 == 0)
1704 edm::LogInfo(" EB channel ") << iChannel << " eta " << ix << " phi " << iy << " side " << sideEB[iChannel]
1705 << " ring " << ringEB[iChannel];
1706 } else {
1707 ixEE[iChannel] = ix;
1708 iyEE[iChannel] = iy;
1709 izEE[iChannel] = iz;
1710 if (debug && entry % 1000 == 0)
1711 edm::LogInfo(" EE channel ") << iChannel << " x " << ixEE[iChannel] << " y " << iyEE[iChannel] << " z "
1712 << izEE[iChannel];
1713 }
1714 }
1715
1716 Int_t pedxml[Nbpedxml] = {271948,
1717 273634,
1718 273931,
1719 274705,
1720 275403,
1721 276108,
1722 276510,
1723 277169,
1724 278123,
1725 278183,
1726 278246,
1727 278389,
1728 278499,
1729 278693,
1730 278858,
1731 278888,
1732 278931,
1733 279728,
1734 280129,
1735 280263,
1736 280941,
1737 281753,
1738 282631,
1739 282833,
1740 283199,
1741 283766,
1742
1743 286535,
1744 293513,
1745 293632,
1746 293732,
1747 295507,
1748 295672,
1749 296391,
1750 296917,
1751 297388,
1752 298481,
1753 299279,
1754 299710,
1755 300186,
1756 300581,
1757 301191,
1758 302006,
1759 302293,
1760 302605,
1761 303436,
1762 303848,
1763 304211,
1764 304680,
1765 305117,
1766 305848,
1767 306176,
1768
1769 313760,
1770 315434,
1771 315831,
1772 316299,
1773 316694,
1774 316963,
1775 317399,
1776 317669,
1777 318249,
1778 318747,
1779 319111,
1780 319365,
1781 319700,
1782 320098,
1783 320515,
1784 320905,
1785 321184,
1786 321480,
1787 321855,
1788 322151,
1789 322653,
1790 323261,
1791 323802,
1792 324250,
1793 324632,
1794 325909,
1795 326038,
1796 326652,
1797 326979,
1798 327271};
1799
1800 Int_t run16Index = 0;
1801
1802 Int_t fed[kChannels], chan[kChannels], id, run, run_type, seq_id, las_id, fill_num, run_num_infill, run_time,
1803 run_time_stablebeam, nxt, time[54];
1804 Float_t ped[kChannels], pedrms[kChannels], lumi, bfield;
1805 TTree* tree = (TTree*)hfile->Get("T");
1806 tree->Print();
1807 tree->SetBranchAddress("id", &id);
1808 tree->SetBranchAddress("run", &run);
1809 tree->SetBranchAddress("run_type", &run_type);
1810 tree->SetBranchAddress("seq_id", &seq_id);
1811 tree->SetBranchAddress("las_id", &las_id);
1812 tree->SetBranchAddress("fill_num", &fill_num);
1813 tree->SetBranchAddress("run_num_infill", &run_num_infill);
1814 tree->SetBranchAddress("run_time", &run_time);
1815 tree->SetBranchAddress("run_time_stablebeam", &run_time_stablebeam);
1816 tree->SetBranchAddress("lumi", &lumi);
1817 tree->SetBranchAddress("bfield", &bfield);
1818 tree->SetBranchAddress("nxt", &nxt);
1819 tree->SetBranchAddress("time", time);
1820 tree->SetBranchAddress("fed", fed);
1821 tree->SetBranchAddress("chan", chan);
1822 tree->SetBranchAddress("ped", ped);
1823 tree->SetBranchAddress("pedrms", pedrms);
1824 int nevents = (int)tree->GetEntries();
1825 edm::LogInfo(" nb entries ") << nevents;
1826 std::ofstream fout;
1827 fout.open("copyTimestampPedestals.txt");
1828 if (!fout.is_open()) {
1829 edm::LogInfo("ERROR : cannot open file copyTimestampPedestals.txt");
1830 exit(1);
1831 }
1832 Double_t EAmean1[kChannels], EArms1[kChannels], EAmean6[kChannels], EArms6[kChannels], EAmean12[kChannels],
1833 EArms12[kChannels];
1834 for (int ich = 0; ich < kChannels; ich++) {
1835 EAmean12[ich] = 200.;
1836 EArms12[ich] = 0.;
1837 }
1838 tree->GetEntry(0);
1839 fout << " first run " << run << " fill " << fill_num << " B field " << bfield << " run type " << run_type
1840 << " seq_id " << seq_id << " las_id " << las_id << " run_num_infill " << run_num_infill << " lumi " << lumi
1841 << " nb of Crystals " << nxt << std::endl;
1842 if (debug) {
1843 for (int ich = 0; ich < kChannels; ich++) {
1844 if (ped[ich] != 0.) {
1845 if (ich < kEBChannels)
1846 fout << " channel " << ich << " FED " << fed[ich] << " chan " << chan[ich] << " pedestal " << ped[ich]
1847 << " RMS " << pedrms[ich] << std::endl;
1848 else
1849 fout << " channel " << ich << " EE channel " << ich - kEBChannels << " FED " << fed[ich] << " chan "
1850 << chan[ich] << " pedestal " << ped[ich] << " RMS " << pedrms[ich] << std::endl;
1851 }
1852 }
1853 }
1854
1855 int runold = -1, fillold = -1, firsttimeFEDold = -1;
1856 int firsttimeFED = -1, firstFillSequence = 0;
1857 bool firstSeqBeforeStable = false;
1858 int transfer = 0;
1859 int first_run_kept = (int)m_firstRun;
1860 int last_run_kept = (int)m_lastRun;
1861 for (int entry = 0; entry < nevents; entry++) {
1862 tree->GetEntry(entry);
1863 if (nxt != kChannels) {
1864
1865 fout << " entry " << entry << " run " << run << " sequence " << seq_id
1866 << " *********** Number of channels " << nxt;
1867
1868 fout << " rejected" << std::endl;
1869 continue;
1870
1871
1872 }
1873 if (run_type != 1) {
1874 fout << " entry " << entry << " run " << run << " sequence " << seq_id
1875 << " *********** run_type ( 1 coll, 2 cosm, 3 circ, 4 test ) = " << run_type << std::endl;
1876 continue;
1877 }
1878 if (las_id != 447) {
1879 fout << " entry " << entry << " run " << run << " sequence " << seq_id
1880 << " *********** laser wave length = " << las_id << std::endl;
1881 continue;
1882 }
1883
1884
1885
1886
1887
1888 if (bfield < 3.79) {
1889 fout << " entry " << entry << " run " << run << " sequence " << seq_id << " *********** bfield = " << bfield
1890 << std::endl;
1891
1892 }
1893 fout << " entry " << entry << " run " << run;
1894 if (run_type == 1)
1895 fout << " fill " << fill_num;
1896 fout << " sequence " << seq_id;
1897 if (run_type == 1) {
1898 fout << " stable " << run_time_stablebeam;
1899 if (run_time_stablebeam < first_run_kept) {
1900 fout << " before first wanted " << m_firstRun << std::endl;
1901 continue;
1902 }
1903 }
1904 firsttimeFED = time[0];
1905 for (int ifed = 0; ifed < 54; ifed++) {
1906 if (time[ifed] > firsttimeFEDold && time[ifed] < firsttimeFED)
1907 firsttimeFED = time[ifed];
1908 }
1909 if (firsttimeFED < first_run_kept) {
1910 fout << " time " << firsttimeFED << " before first wanted " << m_firstRun << std::endl;
1911 continue;
1912 }
1913 if (firsttimeFED > last_run_kept) {
1914 fout << " entry " << entry << " time " << firsttimeFED << " after last wanted " << m_lastRun << std::endl;
1915 break;
1916 }
1917 fout << " time " << firsttimeFED << std::endl;
1918 if (firsttimeFED <= firsttimeFEDold) {
1919 edm::LogInfo(" Problem finding the IOV : old one ") << firsttimeFEDold << " new one " << firsttimeFED;
1920 for (int ifed = 0; ifed < 54; ifed++)
1921 edm::LogInfo("Time ") << time[ifed] << " ignore this entry ";
1922 continue;
1923 }
1924 firsttimeFEDold = firsttimeFED;
1925
1926
1927 if (fill_num != fillold) {
1928 firstSeqBeforeStable = false;
1929 firstFillSequence = 0;
1930 } else
1931 firstFillSequence++;
1932 if (run_type == 1) {
1933 if (run_time_stablebeam > 0) {
1934 if (firsttimeFED < run_time_stablebeam) {
1935 fout << " data taken before stable beam, skip it" << std::endl;
1936 firstSeqBeforeStable = true;
1937 runold = run;
1938 fillold = fill_num;
1939 continue;
1940 }
1941 } else
1942 fout << " *** entry " << entry << " run_time_stablebeam " << run_time_stablebeam << std::endl;
1943 if (firstSeqBeforeStable) {
1944 firstSeqBeforeStable = false;
1945 firsttimeFED = run_time_stablebeam;
1946 fout << " first full sequence after stable; change the IOV " << firsttimeFED << std::endl;
1947 }
1948 if (firstFillSequence == 0) {
1949 if (firsttimeFED > run_time_stablebeam) {
1950 fout << " first full sequence " << firsttimeFED << " after stable " << run_time_stablebeam
1951 << "; change the IOV " << std::endl;
1952 firsttimeFED = run_time_stablebeam;
1953 }
1954 }
1955 }
1956
1957 for (int ich = 0; ich < kChannels; ich++) {
1958 if (ped[ich] < 300 && ped[ich] > 100) {
1959 EAmean12[ich] = ped[ich];
1960 EArms12[ich] = pedrms[ich];
1961 }
1962 }
1963
1964 bool foundNew = false;
1965 if (run != runold) {
1966 for (int i = run16Index; i < Nbpedxml; i++) {
1967 if (run > pedxml[i]) {
1968 fout << " found a new gain 1, 6 file " << pedxml[i] << " at index " << i << std::endl;
1969 run16Index++;
1970 foundNew = true;
1971
1972 if (run < pedxml[i + 1])
1973 break;
1974 }
1975 }
1976 if (foundNew) {
1977 int Indexxml = run16Index - 1;
1978 fout << " opening Pedestals_" << pedxml[Indexxml] << ".xml at index " << Indexxml << std::endl;
1979 std::ifstream fxml;
1980 fxml.open(Form("Pedestals_%i.xml", pedxml[Indexxml]));
1981 if (!fxml.is_open()) {
1982 edm::LogInfo("ERROR : cannot open file Pedestals_") << pedxml[Indexxml] << ".xml";
1983 exit(1);
1984 }
1985 std::string dummyLine, mean12, rms12, bid;
1986 for (int i = 0; i < 9; i++)
1987 std::getline(fxml, dummyLine);
1988
1989 for (int iEBChannel = 0; iEBChannel < kEBChannels; iEBChannel++) {
1990 fxml >> mean12 >> rms12 >> bid;
1991 std::string stt = bid.substr(9, 15);
1992 std::istringstream m6(stt);
1993 m6 >> EAmean6[iEBChannel];
1994 fxml >> bid;
1995 stt = bid.substr(8, 15);
1996 std::istringstream r6(stt);
1997 r6 >> EArms6[iEBChannel];
1998 fxml >> bid;
1999 stt = bid.substr(9, 15);
2000 std::istringstream m1(stt);
2001 m1 >> EAmean1[iEBChannel];
2002 fxml >> bid;
2003 stt = bid.substr(8, 15);
2004 std::istringstream r1(stt);
2005 r1 >> EArms1[iEBChannel];
2006 if (debug && iEBChannel % 10000 == 0)
2007 fout << " EB channel " << iEBChannel << " " << mean12 << " " << rms12 << " " << EAmean6[iEBChannel] << " "
2008 << EArms6[iEBChannel] << " " << EAmean1[iEBChannel] << " " << EArms1[iEBChannel] << std::endl;
2009 for (int i = 0; i < 3; i++)
2010 std::getline(fxml, dummyLine);
2011 }
2012 for (int i = 0; i < 6; i++)
2013 std::getline(fxml, dummyLine);
2014 for (int iEEChannel = 0; iEEChannel < kEEChannels; iEEChannel++) {
2015 int ich = iEEChannel + kEBChannels;
2016 fxml >> mean12 >> rms12 >> bid;
2017 std::string stt = bid.substr(9, 15);
2018 std::istringstream m6(stt);
2019 m6 >> EAmean6[ich];
2020 fxml >> bid;
2021 stt = bid.substr(8, 15);
2022 std::istringstream r6(stt);
2023 r6 >> EArms6[ich];
2024 fxml >> bid;
2025 stt = bid.substr(9, 15);
2026 std::istringstream m1(stt);
2027 m1 >> EAmean1[ich];
2028 fxml >> bid;
2029 stt = bid.substr(8, 15);
2030 std::istringstream r1(stt);
2031 r1 >> EArms1[ich];
2032 if (debug && iEEChannel % 1000 == 0)
2033 fout << " EE channel " << iEEChannel << " " << mean12 << " " << rms12 << " " << EAmean6[ich] << " "
2034 << EArms6[ich] << " " << EAmean1[ich] << " " << EArms1[ich] << std::endl;
2035 for (int i = 0; i < 3; i++)
2036 std::getline(fxml, dummyLine);
2037 }
2038 fxml.close();
2039 }
2040 }
2041
2042 EcalPedestals* pedestal = new EcalPedestals();
2043 EcalPedestals::Item item;
2044 for (int ich = 0; ich < kChannels; ich++) {
2045 if (debug && ich % 10000 == 0)
2046 fout << " channel " << ich << " ped " << EAmean12[ich] << " RMS " << EArms12[ich] << std::endl;
2047
2048 item.mean_x1 = EAmean1[ich];
2049 item.rms_x1 = EArms1[ich];
2050 item.mean_x6 = EAmean6[ich];
2051 item.rms_x6 = EArms6[ich];
2052 item.mean_x12 = EAmean12[ich];
2053 item.rms_x12 = EArms12[ich];
2054 if (ich < kEBChannels) {
2055
2056 EBDetId ebdetid = EBDetId::unhashIndex(ich);
2057 pedestal->insert(std::make_pair(ebdetid.rawId(), item));
2058 } else {
2059
2060 int iChannel = ich - kEBChannels;
2061 EEDetId eedetid = EEDetId::unhashIndex(iChannel);
2062 pedestal->insert(std::make_pair(eedetid.rawId(), item));
2063 }
2064 }
2065 uint64_t iov = (uint64_t)firsttimeFED << 32;
2066 Time_t snc = (Time_t)iov;
2067 transfer++;
2068 fout << " entry " << entry << " transfer " << transfer << " iov " << iov << std::endl;
2069 m_to_transfer.push_back(std::make_pair((EcalPedestals*)pedestal, snc));
2070 fout << " m_to_transfer " << firsttimeFED << std::endl;
2071 runold = run;
2072 fillold = fill_num;
2073 }
2074
2075 edm::LogInfo("Ecal - > end of readPedestalTimestamp -----------\n");
2076 }