EcalSRCondTools.cc

Go to the documentation of this file.

//emacs settings:-*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil -*-
/*
 *
 * author: Ph Gras. June, 2010
 */
 
#include "SimCalorimetry/EcalSelectiveReadoutProducers/interface/EcalSRCondTools.h"
 
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/ServiceRegistry/interface/Service.h"
#include "CondCore/DBOutputService/interface/PoolDBOutputService.h"
 
#include "CondFormats/EcalObjects/interface/EcalSRSettings.h"
#include "CondFormats/DataRecord/interface/EcalSRSettingsRcd.h"
#include "CondFormats/EcalObjects/interface/EcalTPGPhysicsConst.h"
#include "CondFormats/DataRecord/interface/EcalTPGPhysicsConstRcd.h"
 
#include <string>
#include <fstream>
#include <iostream>
#include <algorithm>
 
constexpr int tccNum[12][12] = {
    /* EE- */
    {36, 19, 20, 21, 22, 23, 18, 1, 2, 3, 4, 5},       //SRP 1
    {24, 25, 26, 27, 28, 29, 6, 7, 8, 9, 10, 11},      //SRP 2
    {30, 31, 32, 33, 34, 35, 12, 13, 14, 15, 16, 17},  //SRP 3
    /* EB- */
    {54, 37, 38, 39, 40, 41, -1, -1, -1, -1, -1, -1},  //SRP 4
    {42, 43, 44, 45, 46, 47, -1, -1, -1, -1, -1, -1},  //SRP 5
    {48, 49, 50, 51, 52, 53, -1, -1, -1, -1, -1, -1},  //SRP 6
    /* EB+ */
    {72, 55, 56, 57, 58, 59, -1, -1, -1, -1, -1, -1},  //SRP 7
    {60, 61, 62, 63, 64, 65, -1, -1, -1, -1, -1, -1},  //SRP 8
    {66, 67, 68, 69, 70, 71, -1, -1, -1, -1, -1, -1},  //SRP 9
    /* EE+ */
    {90, 73, 74, 75, 76, 77, 108, 91, 92, 93, 94, 95},      //SRP 10
    {78, 79, 80, 81, 82, 83, 96, 97, 98, 99, 100, 101},     //SRP 11
    {84, 85, 86, 87, 88, 89, 102, 103, 104, 105, 106, 107}  //SRP 12
};
 
constexpr int dccNum[12][12] = {
    {1, 2, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1},     //SRP 1
    {4, 5, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1},     //SRP 2
    {7, 8, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1},     //SRP 3
    {10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1},  //SRP 4
    {16, 17, 18, 19, 20, 21, -1, -1, -1, -1, -1, -1},  //SRP 5
    {22, 23, 24, 25, 26, 27, -1, -1, -1, -1, -1, -1},  //SRP 6
    {28, 29, 30, 31, 32, 33, -1, -1, -1, -1, -1, -1},  //SRP 7
    {34, 35, 36, 37, 38, 39, -1, -1, -1, -1, -1, -1},  //SRP 8
    {40, 41, 42, 43, 44, 45, -1, -1, -1, -1, -1, -1},  //SRP 9
    {46, 47, 48, -1, -1, -1, -1, -1, -1, -1, -1, -1},  //SRP 10
    {49, 50, 51, -1, -1, -1, -1, -1, -1, -1, -1, -1},  //SRP 11
    {52, 53, 54, -1, -1, -1, -1, -1, -1, -1, -1, -1}   //SRP 12
};
 
using namespace std;
 
EcalSRCondTools::EcalSRCondTools(const edm::ParameterSet& ps) : ps_(ps), done_(false) {}
 
EcalSRCondTools::~EcalSRCondTools() {}
 
void EcalSRCondTools::analyze(const edm::Event& event, const edm::EventSetup& es) {
  if (done_)
    return;
  EcalSRSettings* sr = new EcalSRSettings;
 
  string mode = ps_.getParameter<string>("mode");
 
  bool iomode_write = true;
  if (mode == "online_config" || mode == "combine_config") {
    string fname = ps_.getParameter<string>("onlineSrpConfigFile");
    ifstream f(fname.c_str());
    if (!f.good()) {
      throw cms::Exception("EcalSRCondTools") << "Failed to open file " << fname;
    }
    importSrpConfigFile(*sr, f, true);
  }
 
  if (mode == "python_config" || mode == "combine_config") {
    importParameterSet(*sr, ps_);
  }
 
  if (mode == "read") {
    iomode_write = false;
  }
 
  if (!(mode == "python_config" || mode == "online_config" || mode == "combine_config" || (mode == "read"))) {
    throw cms::Exception("Config") << "Invalid value," << mode << ",  for parameter mode. "
                                   << "Valid values: online_config, python_config, combine_config, read";
  }
 
  if (iomode_write) {
    sr->bxGlobalOffset_ = ps_.getParameter<int>("bxGlobalOffset");
    sr->automaticSrpSelect_ = ps_.getParameter<int>("automaticSrpSelect");
    sr->automaticMasks_ = ps_.getParameter<int>("automaticMasks");
 
    edm::Service<cond::service::PoolDBOutputService> db;
    if (!db.isAvailable()) {
      throw cms::Exception("CondDBAccess") << "Failed to connect to PoolDBOutputService\n";
    }
    //fillup DB
    //create new infinite IOV
    cond::Time_t firstSinceTime = db->beginOfTime();
    db->writeOne(sr, firstSinceTime, "EcalSRSettingsRcd");
    done_ = true;
  } else {  //read mode
    edm::ESHandle<EcalSRSettings> hSr;
    es.get<EcalSRSettingsRcd>().get(hSr);
    if (!hSr.isValid()) {
      cout << "EcalSRSettings record not found. Check the Cond DB Global tag.\n";
    } else {
      const EcalSRSettings* ssr = hSr.product();
      cout << "ECAL Seletive readout settings:\n";
      cout << *ssr << "\n" << endl;
    }
 
    //trigger tower thresholds (from FENIX configuration):
    edm::ESHandle<EcalTPGPhysicsConst> hTp;
    es.get<EcalTPGPhysicsConstRcd>().get(hTp);
    if (!hTp.isValid()) {
      cout << "EcalTPGPhysicsConst record not found. Check the Cond DB Global tag.\n";
    } else {
      const EcalTPGPhysicsConst* tp = hTp.product();
      const EcalTPGPhysicsConstMap& mymap = tp->getMap();
      if (mymap.size() != 2) {
        cout << "Error: TPG physics record is of unexpected size: " << mymap.size()
             << " elements instead of two (one for EB, one for EE)\n";
      } else {
        EcalTPGPhysicsConstMap::const_iterator it = mymap.begin();
        cout << "----------------------------------------------------------------------\n"
                "Trigger tower Et thresholds extracted from TPG configuration \n"
                "(EcalSRCondTools modules supports only read mode for these parameters):\n\n";
        cout << "EB: "
             << "LT = " << it->second.ttf_threshold_Low << " GeV "
             << "HT = " << it->second.ttf_threshold_High << " GeV\n";
        ++it;
        cout << "EE: "
             << "LT = " << it->second.ttf_threshold_Low << " GeV "
             << "HT = " << it->second.ttf_threshold_High << " GeV\n";
      }
    }
  }
  delete sr;
}
 
void EcalSRCondTools::importParameterSet(EcalSRSettings& sr, const edm::ParameterSet& ps) {
  sr.deltaPhi_.resize(1);
  sr.deltaPhi_[0] = ps.getParameter<int>("deltaPhi");
  sr.deltaEta_.resize(1);
  sr.deltaEta_[0] = ps.getParameter<int>("deltaEta");
  sr.ecalDccZs1stSample_.resize(1);
  sr.ecalDccZs1stSample_[0] = ps.getParameter<int>("ecalDccZs1stSample");
  sr.ebDccAdcToGeV_ = ps.getParameter<double>("ebDccAdcToGeV");
  sr.eeDccAdcToGeV_ = ps.getParameter<double>("eeDccAdcToGeV");
  sr.dccNormalizedWeights_.resize(1);
  const std::vector<double>& w = ps.getParameter<std::vector<double> >("dccNormalizedWeights");
  sr.dccNormalizedWeights_[0].resize(w.size());
  std::copy(w.begin(), w.end(), sr.dccNormalizedWeights_[0].begin());
  sr.symetricZS_.resize(1);
  sr.symetricZS_[0] = ps.getParameter<bool>("symetricZS");
  sr.srpLowInterestChannelZS_.resize(2);
  const int eb = 0;
  const int ee = 1;
  sr.srpLowInterestChannelZS_[eb] = ps.getParameter<double>("srpBarrelLowInterestChannelZS");
  sr.srpLowInterestChannelZS_[ee] = ps.getParameter<double>("srpEndcapLowInterestChannelZS");
  sr.srpHighInterestChannelZS_.resize(2);
  sr.srpHighInterestChannelZS_[eb] = ps.getParameter<double>("srpBarrelHighInterestChannelZS");
  sr.srpHighInterestChannelZS_[ee] = ps.getParameter<double>("srpEndcapHighInterestChannelZS");
  //sr.trigPrimBypass_.resize(1);
  //sr.trigPrimBypass_[0] = ps.getParameter<bool >("trigPrimBypass");
  //sr.trigPrimBypassMode_.resize(1);
  //sr.trigPrimBypassMode_[0] = ps.getParameter<int >("trigPrimBypassMode");
  //sr.trigPrimBypassLTH_.resize(1);
  //sr.trigPrimBypassLTH_[0] = ps.getParameter<double >("trigPrimBypassLTH");
  //sr.trigPrimBypassHTH_.resize(1);
  //sr.trigPrimBypassHTH_[0] = ps.getParameter<double >("trigPrimBypassHTH");
  //sr.trigPrimBypassWithPeakFinder_.resize(1);
  //sr.trigPrimBypassWithPeakFinder_[0] = ps.getParameter<bool >("trigPrimBypassWithPeakFinder");
  //sr.defaultTtf_.resize(1);
  //sr.defaultTtf_[0] = ps.getParameter<int >("defaultTtf");
  sr.actions_ = ps.getParameter<std::vector<int> >("actions");
}
 
void EcalSRCondTools::importSrpConfigFile(EcalSRSettings& sr, std::istream& f, bool d) {
  //initialize vectors:
  sr.deltaEta_ = vector<int>(1, 0);
  sr.deltaPhi_ = vector<int>(1, 0);
  sr.actions_ = vector<int>(4, 0);
  sr.tccMasksFromConfig_ = vector<short>(EcalSRSettings::nTccs_, 0);
  sr.srpMasksFromConfig_ = vector<vector<short> >(EcalSRSettings::nSrps_, vector<short>(8, 0));
  sr.dccMasks_ = vector<short>(EcalSRSettings::nDccs_);
  sr.srfMasks_ = vector<short>(EcalSRSettings::nDccs_);
  sr.substitutionSrfs_ = vector<vector<short> >(EcalSRSettings::nSrps_, vector<short>(68, 0));
  sr.testerTccEmuSrpIds_ = vector<int>(EcalSRSettings::nSrps_, 0);
  sr.testerSrpEmuSrpIds_ = vector<int>(EcalSRSettings::nSrps_, 0);
  sr.testerDccTestSrpIds_ = vector<int>(EcalSRSettings::nSrps_, 0);
  sr.testerSrpTestSrpIds_ = vector<int>(EcalSRSettings::nSrps_, 0);
  sr.bxOffsets_ = vector<short>(EcalSRSettings::nSrps_, 0);
  sr.automaticMasks_ = 0;
  sr.automaticSrpSelect_ = 0;
 
  //string line;
  int iLine = 0;
  int iValueSet = -1;
  const int nValueSets = 6 * EcalSRSettings::nSrps_ + 9;
  string line;
  stringstream sErr("");
  while (!f.eof() && sErr.str().empty()) {
    getline(f, line);
    ++iLine;
    line = trim(line);
    if (line[0] == '#' || line.empty()) {  //comment line and empty line to ignore
      continue;
    } else {
      ++iValueSet;
    }
    if (iValueSet >= nValueSets)
      break;
    uint32_t value;
    string sValue;
    int pos = 0;
    int iCh = 0;
    int nChs[nValueSets] = {
        //TCC masks: 0-11
        12,
        12,
        12,
        12,
        12,
        12,
        12,
        12,
        12,
        12,
        12,
        12,
        //SRP masks: 12-23
        8,
        8,
        8,
        8,
        8,
        8,
        8,
        8,
        8,
        8,
        8,
        8,
        //DCC masks: 24-35
        12,
        12,
        12,
        12,
        12,
        12,
        12,
        12,
        12,
        12,
        12,
        12,
        //SRF Masks: 36-47
        6,
        6,
        6,
        6,
        6,
        6,
        6,
        6,
        6,
        6,
        6,
        6,
        //substitution SRFs: 48-59
        68,
        68,
        68,
        68,
        68,
        68,
        68,
        68,
        68,
        68,
        68,
        68,
        //Tester card to emulate or test: 60-71
        4,
        4,
        4,
        4,
        4,
        4,
        4,
        4,
        4,
        4,
        4,
        4,
        //Bx offsets: 72
        12,
        //algo type: 73
        1,
        //action flags: 74
        4,
        //pattern file directory: 75
        1,
        //VME slots: 76
        12,
        //card types: 77
        12,
        //config Mode
        1,
        //VME Interface card
        1,
        //Spy Mode
        12,
    };
 
    while (((sValue = tokenize(line, " \t", pos)) != string("")) && (iCh < nChs[iValueSet]) && sErr.str().empty()) {
      value = strtoul(sValue.c_str(), nullptr, 0);
      const int iSrp = iValueSet % EcalSRSettings::nSrps_;
      if (iValueSet < 12) {  //TCC
        assert((unsigned)iSrp < sizeof(tccNum) / sizeof(tccNum[0]));
        assert((unsigned)iCh < sizeof(tccNum[0]) / sizeof(tccNum[0][0]));
        int tcc = tccNum[iSrp][iCh];
        if (tcc >= 0) {
          if (d)
            cout << "tccMasksFromConfig_[" << tcc << "] <- " << value << "\n";
          sr.tccMasksFromConfig_[tcc - 1] = value;
        }
      } else if (iValueSet < 24) {  //SRP-SRP
        if (d)
          cout << "srpMasks_[" << iSrp << "][" << iCh << "] <- " << value << "\n";
        sr.srpMasksFromConfig_[iSrp][iCh] = value;
      } else if (iValueSet < 36) {  //DCC output
        assert((unsigned)iSrp < sizeof(dccNum) / sizeof(dccNum[0]));
        assert((unsigned)iCh < sizeof(dccNum[0]) / sizeof(dccNum[0][0]));
        int dcc = dccNum[iSrp][iCh];
        if (dcc > 0) {
          assert((unsigned)(dcc - 1) < sr.dccMasks_.size());
          if (d)
            cout << "dccMasks_[" << (dcc - 1) << "] <- " << value << "\n";
          sr.dccMasks_[dcc - 1] = value;
        }
      } else if (iValueSet < 48) {  //SRF masks
        assert((unsigned)iSrp < sizeof(dccNum) / sizeof(dccNum[0]));
        assert((unsigned)iCh < sizeof(dccNum[0]) / sizeof(dccNum[0][0]));
        int dcc = dccNum[iSrp][iCh];
        if (dcc > 0) {
          if (d)
            cout << "srfMasks_[" << (dcc - 1) << "] <- " << value << "\n";
          assert((unsigned)(dcc - 1) < sr.srfMasks_.size());
          sr.srfMasks_[dcc - 1] = value;
        }
      } else if (iValueSet < 60) {  //substiution SRFs
        assert((unsigned)iSrp < sr.substitutionSrfs_.size());
        assert((unsigned)iCh < sr.substitutionSrfs_[0].size());
        if (d)
          cout << "substitutionMasks_[" << iSrp << "][" << iCh << "] <- " << value << "\n";
        sr.substitutionSrfs_[iSrp][iCh] = value;
      } else if (iValueSet < 72) {  //Tester card config
        switch (iCh) {
          case 0:
            assert((unsigned)iSrp < sr.testerTccEmuSrpIds_.size());
            if (d)
              cout << "testerTccEmuSrpIds_[" << iSrp << "] <- " << value << "\n";
            sr.testerTccEmuSrpIds_[iSrp] = value;
            break;
          case 1:
            assert((unsigned)iSrp < sr.testerSrpEmuSrpIds_.size());
            if (d)
              cout << "testerSrpEmuSrpIds_[" << iSrp << "] <- " << value << "\n";
            sr.testerSrpEmuSrpIds_[iSrp] = value;
            break;
          case 2:
            assert((unsigned)iSrp < sr.testerDccTestSrpIds_.size());
            if (d)
              cout << "testerDccTestSrpIds_[" << iSrp << "] <- " << value << "\n";
            sr.testerDccTestSrpIds_[iSrp] = value;
            break;
          case 3:
            assert((unsigned)iSrp < sr.testerSrpTestSrpIds_.size());
            if (d)
              cout << "testerSrpTestSrpIds_[" << iSrp << "] <- " << value << "\n";
            sr.testerSrpTestSrpIds_[iSrp] = value;
            break;
          default:
            sErr << "Syntax error in SRP system configuration "
                 << " line " << iLine << ".";
        }
      } else if (iValueSet < 73) {  //bx offsets
        assert((unsigned)iCh < sr.bxOffsets_.size());
        if (d)
          cout << "bxOffset_[" << iCh << "] <- " << value << "\n";
        sr.bxOffsets_[iCh] = value;
      } else if (iValueSet < 74) {  //algo type
        int algo = value;
        switch (algo) {
          case 0:
            sr.deltaEta_[0] = sr.deltaPhi_[0] = 1;
            break;
          case 1:
            sr.deltaEta_[0] = sr.deltaPhi_[0] = 2;
            break;
          default:
            throw cms::Exception("OutOfRange")
                << "Value of parameter algo ," << algo << ", is invalid. Valid values are 0 and 1.";
        }
        if (d)
          cout << "deltaEta_[0] <- " << sr.deltaEta_[0] << "\t"
               << "deltaPhi_[0] <- " << sr.deltaPhi_[0] << "\n";
      } else if (iValueSet < 75) {  //action flags
        assert((unsigned)iCh < sr.actions_.size());
        if (d)
          cout << "actions_[" << iCh << "] <- " << value << "\n";
        sr.actions_[iCh] = value;
      } else if (iValueSet < 76) {  //pattern file directory
                                    //  emuDir_ = sValue;
                                    //  if(d) cout << "emuDir_ <= "
                                    //         << value << "\n";
      } else if (iValueSet < 77) {  //VME slots
        //  slotIds_[iCh] = value;
        //  if(d) cout << "slotIds_[" << iCh << "] <= "
        //         << value << "\n";
      } else if (iValueSet < 78) {  //card types
        //  cardTypes_[iCh] = sValue[0];
        //  if(d) cout << "cardTypes_[" << iCh << "] <= "
        //         << value << "\n";
      } else if (iValueSet < 79) {  //config mode
                                    //TODO validity check on value
        //  configMode_ = (ConfigMode)value;
        //  if(d) cout << "config mode <= " << value << "\n";
      } else if (iValueSet < 80) {  //VME I/F
                                    //TODO validity check on value
                                    //     vmeInterface_ = (Vme::type_t)value;
                                    //if(d) cout << "Vme Interface code <= " << value << "\n";
      } else if (iValueSet < 81) {  //Spy Mode
                                    //TODO validity check on value
                                    //  spyMode_[iCh] = value & 0x3;
                                    //  if(d) cout << "Spy mode <= " << value << "\n";
      } else {                      //should never be reached!
        assert(false);
      }
      ++iCh;
    }
    if (iCh != nChs[iValueSet]) {  //error
      sErr << "Syntax error in imported SRP system configuration file "
              /*<< filename <<*/ " line "
           << iLine << ".";
    }
  }
  if (sErr.str().empty() && iValueSet != (nValueSets - 1)) {  //error
    sErr << "Syntax Error in imported SRP system configuration file "
            /*<< filename <<*/ " line "
         << iLine << ".";
  }
  if (!sErr.str().empty())
    throw cms::Exception("SyntaxError") << sErr.str();
}
 
double EcalSRCondTools::normalizeWeights(int hwWeight) {
  //Fix sign bit in case only the 12 least significant bits of hwWeight were set
  //(hardware reprensentation uses only 12 bits)
  if (hwWeight & (1 << 11))
    hwWeight |= ~0xEFF;
  return hwWeight / 1024.;
}
 
string EcalSRCondTools::tokenize(const string& s, const string& delim, int& pos) {
  if (pos < 0)
    return "";
  int pos0 = pos;
  int len = s.size();
  //eats delimeters at beginning of the string
  while (pos0 < len && find(delim.begin(), delim.end(), s[pos0]) != delim.end()) {
    ++pos0;
  }
  if (pos0 == len)
    return "";
  pos = s.find_first_of(delim, pos0);
  return s.substr(pos0, (pos > 0 ? pos : len) - pos0);
}
 
std::string EcalSRCondTools::trim(std::string s) {
  std::string::size_type pos0 = s.find_first_not_of(" \t");
  if (pos0 == string::npos) {
    pos0 = 0;
  }
  string::size_type pos1 = s.find_last_not_of(" \t") + 1;
  if (pos1 == string::npos) {
    pos1 = pos0;
  }
  return s.substr(pos0, pos1 - pos0);
}