DTConfigDBProducer.cc

Go to the documentation of this file.

#include "L1TriggerConfig/DTTPGConfigProducers/src/DTConfigDBProducer.h"

#include "DataFormats/MuonDetId/interface/DTChamberId.h"
#include "DataFormats/MuonDetId/interface/DTLayerId.h"
#include "DataFormats/MuonDetId/interface/DTSuperLayerId.h"

#include "CondFormats/DTObjects/interface/DTCCBConfig.h"
#include "CondFormats/DTObjects/interface/DTKeyedConfig.h"
#include "CondFormats/DataRecord/interface/DTCCBConfigRcd.h"
#include "CondFormats/DataRecord/interface/DTKeyedConfigListRcd.h"
#include "CondFormats/DataRecord/interface/DTT0Rcd.h"
#include "CondFormats/DataRecord/interface/DTTPGParametersRcd.h"

#include "L1TriggerConfig/DTTPGConfig/interface/DTConfigManagerRcd.h"
#include "L1TriggerConfig/DTTPGConfigProducers/src/DTPosNegType.h"

#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/Framework/interface/MakerMacros.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/Utilities/interface/Exception.h"

#include <iomanip>
#include <iostream>

using std::cout;
using std::endl;
using std::unique_ptr;
using std::vector;

//
// constructors and destructor
//

DTConfigDBProducer::DTConfigDBProducer(const edm::ParameterSet &p) {
  // tell the framework what record is being produced
  setWhatProduced(this, &DTConfigDBProducer::produce);

  cfgConfig = p.getParameter<bool>("cfgConfig");

  // get and store parameter set and config manager pointer
  m_ps = p;

  // debug flags
  m_debugDB = p.getParameter<bool>("debugDB");
  m_debugBti = p.getParameter<int>("debugBti");
  m_debugTraco = p.getParameter<int>("debugTraco");
  m_debugTSP = p.getParameter<bool>("debugTSP");
  m_debugTST = p.getParameter<bool>("debugTST");
  m_debugTU = p.getParameter<bool>("debugTU");
  m_debugSC = p.getParameter<bool>("debugSC");
  m_debugLUTs = p.getParameter<bool>("debugLUTs");
  m_debugPed = p.getParameter<bool>("debugPed");

  m_UseT0 = p.getParameter<bool>("UseT0"); // CB check for a better way to do it
}

DTConfigDBProducer::~DTConfigDBProducer() {}

//
// member functions
//

std::unique_ptr<DTConfigManager>
DTConfigDBProducer::produce(const DTConfigManagerRcd &iRecord) {
  using namespace edm;

  std::unique_ptr<DTConfigManager> dtConfig =
      std::unique_ptr<DTConfigManager>(new DTConfigManager());
  DTConfigManager &dttpgConfig = *(dtConfig.get());

  // DB specific requests
  bool tracoLutsFromDB = m_ps.getParameter<bool>("TracoLutsFromDB");
  bool useBtiAcceptParam = m_ps.getParameter<bool>("UseBtiAcceptParam");

  // set specific DB requests
  dttpgConfig.setLutFromDB(tracoLutsFromDB);
  dttpgConfig.setUseAcceptParam(useBtiAcceptParam);

  // set debug
  edm::ParameterSet conf_ps =
      m_ps.getParameter<edm::ParameterSet>("DTTPGParameters");
  bool dttpgdebug = conf_ps.getUntrackedParameter<bool>("Debug");
  dttpgConfig.setDTTPGDebug(dttpgdebug);

  int code;
  if (cfgConfig) {
    dttpgConfig.setLutFromDB(false);
    configFromCfg(dttpgConfig);
    code = 2;
  } else {
    code = readDTCCBConfig(iRecord, dttpgConfig);
    readDBPedestalsConfig(iRecord, dttpgConfig);
    // 110628 SV add config check
    if (code != -1 && checkDTCCBConfig(dttpgConfig) > 0)
      code = -1;
  }
  // cout << "DTConfigDBProducer::produce CODE " << code << endl;
  if (code == -1) {
    dttpgConfig.setCCBConfigValidity(false);
  } else if (code == 2) {
    LogVerbatim("DTTPG") << "DTConfigDBProducer::produce : Trivial : " << endl
                         << "configurations has been read from cfg" << endl;
  } else if (code == 0) {
    LogVerbatim("DTTPG") << "DTConfigDBProducer::produce : " << endl
                         << "Configurations successfully read from OMDS"
                         << endl;
  } else {
    LogProblem("DTTPG") << "DTConfigDBProducer::produce : " << endl
                        << "Wrong configuration return CODE" << endl;
  }

  return dtConfig;
}

void DTConfigDBProducer::readDBPedestalsConfig(
    const DTConfigManagerRcd &iRecord, DTConfigManager &dttpgConfig) {

  edm::ESHandle<DTTPGParameters> dttpgParams;
  iRecord.getRecord<DTTPGParametersRcd>().get(dttpgParams);

  DTConfigPedestals pedestals;
  pedestals.setDebug(m_debugPed);

  if (m_UseT0) {

    edm::ESHandle<DTT0> t0i;
    iRecord.getRecord<DTT0Rcd>().get(t0i);

    pedestals.setUseT0(true);
    pedestals.setES(dttpgParams.product(), t0i.product());
    // cout << "checkDTCCBConfig CODE is " << checkDTCCBConfig() << endl;

  } else {

    pedestals.setUseT0(false);
    pedestals.setES(dttpgParams.product());
  }

  dttpgConfig.setDTConfigPedestals(pedestals);
}

int DTConfigDBProducer::checkDTCCBConfig(DTConfigManager &dttpgConfig) {
  // 110627 SV test if configuration from CCB has correct number of chips,
  // return error code:
  // check_cfg_code = 1 : NO correct BTI number
  // check_cfg_code = 2 : NO correct TRACO number
  // check_cfg_code = 3 : NO correct valid TSS number
  // check_cfg_code = 4 : NO correct valid TSM number

  int check_cfg_code = 0;

  // do not take chambers from MuonGeometryRecord to avoid geometry dependency
  for (int iwh = -2; iwh <= 2; iwh++) {
    for (int ise = 1; ise <= 12; ise++) {
      for (int ist = 1; ist <= 4; ist++) {

        check_cfg_code = 0;
        DTChamberId chid(iwh, ist, ise);

        // retrive number of configurated chip
        int nbti = dttpgConfig.getDTConfigBtiMap(chid).size();
        int ntraco = dttpgConfig.getDTConfigTracoMap(chid).size();
        int ntss = dttpgConfig.getDTConfigTSPhi(chid)->nValidTSS();
        int ntsm = dttpgConfig.getDTConfigTSPhi(chid)->nValidTSM();

        // check BTIs
        if ((ist == 1 && nbti != 168) || (ist == 2 && nbti != 192) ||
            (ist == 3 && nbti != 224) ||
            (ist == 4 &&
             (ise == 1 || ise == 2 || ise == 3 || ise == 5 || ise == 6 ||
              ise == 7 || ise == 8 || ise == 12) &&
             nbti != 192) ||
            (ist == 4 && (ise == 9 || ise == 11) && nbti != 96) ||
            (ist == 4 && ise == 10 && nbti != 128) ||
            (ist == 4 && ise == 4 && nbti != 160)) {
          check_cfg_code = 1;
          return check_cfg_code;
        }

        // check TRACOs
        if ((ist == 1 && ntraco != 13) || (ist == 2 && ntraco != 16) ||
            (ist == 3 && ntraco != 20) ||
            (ist == 4 &&
             (ise == 1 || ise == 2 || ise == 3 || ise == 5 || ise == 6 ||
              ise == 7 || ise == 8 || ise == 12) &&
             ntraco != 24) ||
            (ist == 4 && (ise == 9 || ise == 11) && ntraco != 12) ||
            (ist == 4 && ise == 10 && ntraco != 16) ||
            (ist == 4 && ise == 4 && ntraco != 20)) {
          check_cfg_code = 2;
          return check_cfg_code;
        }

        // check TSS
        if ((ist == 1 && ntss != 4) || (ist == 2 && ntss != 4) ||
            (ist == 3 && ntss != 5) ||
            (ist == 4 &&
             (ise == 1 || ise == 2 || ise == 3 || ise == 5 || ise == 6 ||
              ise == 7 || ise == 8 || ise == 12) &&
             ntss != 6) ||
            (ist == 4 && (ise == 9 || ise == 11) && ntss != 3) ||
            (ist == 4 && ise == 10 && ntss != 4) ||
            (ist == 4 && ise == 4 && ntss != 5)) {
          check_cfg_code = 3;
          return check_cfg_code;
        }

        // check TSM
        if (ntsm != 1) {
          check_cfg_code = 4;
          return check_cfg_code;
        }

        // if(check_cfg_code){
        // cout << "nbti " << nbti << " ntraco " << ntraco << " ntss " << ntss
        // << " ntsm " << ntsm << endl; cout << "Check: ch " << ist << " sec "
        // << ise << " wh " << iwh << " == >check_cfg_code " << check_cfg_code
        // << endl;
        //}
      } // end st loop
    }   // end sec loop

    // SV MB4 has two more chambers
    for (int ise = 13; ise <= 14; ise++) {

      DTChamberId chid(iwh, 4, ise);

      int nbti = dttpgConfig.getDTConfigBtiMap(chid).size();
      int ntraco = dttpgConfig.getDTConfigTracoMap(chid).size();
      int ntss = dttpgConfig.getDTConfigTSPhi(chid)->nValidTSS();
      int ntsm = dttpgConfig.getDTConfigTSPhi(chid)->nValidTSM();

      if ((ise == 13 && nbti != 160) || (ise == 14 && nbti != 128)) {
        check_cfg_code = 1;
        return check_cfg_code;
      }
      if ((ise == 13 && ntraco != 20) || (ise == 14 && ntraco != 16)) {
        check_cfg_code = 2;
        return check_cfg_code;
      }
      if ((ise == 13 && ntss != 5) || (ise == 14 && ntss != 4)) {
        check_cfg_code = 3;
        return check_cfg_code;
      }
      if (ntsm != 1) {
        check_cfg_code = 4;
        return check_cfg_code;
      }
      // if(check_cfg_code){
      // cout << "nbti " << nbti << " ntraco " << ntraco << " ntss " << ntss <<
      // " ntsm " << ntsm << endl; cout << "Check: ch " << 4 << " sec " << ise
      // << " wh " << iwh << " == >check_cfg_code " << check_cfg_code << endl;
      //}
    } // end sec 13 14

  } // end wh loop

  // cout << "CheckDTCCB: config OK! check_cfg_code = " << check_cfg_code <<
  // endl;
  return check_cfg_code;
}

int DTConfigDBProducer::readDTCCBConfig(const DTConfigManagerRcd &iRecord,
                                        DTConfigManager &dttpgConfig) {
  using namespace edm::eventsetup;

  // initialize CCB validity flag
  dttpgConfig.setCCBConfigValidity(true);

  // get DTCCBConfigRcd from DTConfigManagerRcd (they are dependent records)
  edm::ESHandle<DTCCBConfig> ccb_conf;
  iRecord.getRecord<DTCCBConfigRcd>().get(ccb_conf);
  int ndata = std::distance(ccb_conf->begin(), ccb_conf->end());

  const DTKeyedConfigListRcd &keyRecord =
      iRecord.getRecord<DTKeyedConfigListRcd>();

  if (m_debugDB) {
    cout << ccb_conf->version() << endl;
    cout << ndata << " data in the container" << endl;
  }

  edm::ValidityInterval iov(
      iRecord.getRecord<DTCCBConfigRcd>().validityInterval());
  unsigned int currValidityStart = iov.first().eventID().run();
  unsigned int currValidityEnd = iov.last().eventID().run();

  if (m_debugDB)
    cout << "valid since run " << currValidityStart << " to run "
         << currValidityEnd << endl;

  // if there are no data in the container, configuration from cfg files...
  if (ndata == 0) {
    return -1;
  }

  // get DTTPGMap for retrieving bti number and traco number
  edm::ParameterSet conf_map =
      m_ps.getUntrackedParameter<edm::ParameterSet>("DTTPGMap");

  // loop over chambers
  DTCCBConfig::ccb_config_map configKeys(ccb_conf->configKeyMap());
  DTCCBConfig::ccb_config_iterator iter = configKeys.begin();
  DTCCBConfig::ccb_config_iterator iend = configKeys.end();

  // 110628 SV check that number of CCB is equal to total number of chambers
  if (ccb_conf->configKeyMap().size() != 250) // check the number of chambers!!!
    return -1;

  // read data from CCBConfig
  while (iter != iend) {
    // 110628 SV moved here from constructor, to check config consistency for
    // EVERY chamber initialize flags to check if data are present in OMDS
    flagDBBti = false;
    flagDBTraco = false;
    flagDBTSS = false;
    flagDBTSM = false;
    flagDBLUTS = false;

    // get chamber id
    const DTCCBId &ccbId = iter->first;
    if (m_debugDB)
      cout << " Filling configuration for chamber : wh " << ccbId.wheelId
           << " st " << ccbId.stationId << " se " << ccbId.sectorId << " -> "
           << endl;

    // get chamber type and id from ccbId
    int mbtype =
        DTPosNegType::getCT(ccbId.wheelId, ccbId.sectorId, ccbId.stationId);
    int posneg =
        DTPosNegType::getPN(ccbId.wheelId, ccbId.sectorId, ccbId.stationId);
    if (m_debugDB)
      cout << "Chamber type : " << mbtype << " posneg : " << posneg << endl;
    DTChamberId chambid(ccbId.wheelId, ccbId.stationId, ccbId.sectorId);

    // get brick identifiers list
    const std::vector<int> &ccbConf = iter->second;
    std::vector<int>::const_iterator cfgIter = ccbConf.begin();
    std::vector<int>::const_iterator cfgIend = ccbConf.end();

    // TSS-TSM buffers
    unsigned short int tss_buffer[7][31];
    unsigned short int tsm_buffer[9];
    int ntss = 0;

    // loop over configuration bricks
    while (cfgIter != cfgIend) {
      // get brick identifier
      int id = *cfgIter++;
      if (m_debugDB)
        cout << " BRICK " << id << endl;

      // create strings list
      std::vector<std::string> list;
      cfgCache.getData(keyRecord, id, list);

      // loop over strings
      std::vector<std::string>::const_iterator s_iter = list.begin();
      std::vector<std::string>::const_iterator s_iend = list.end();
      while (s_iter != s_iend) {
        if (m_debugDB)
          cout << "        ----> " << *s_iter << endl;

        // copy string in unsigned int buffer
        std::string str = *s_iter++;
        unsigned short int buffer[100]; // 2 bytes
        int c = 0;
        const char *cstr = str.c_str();
        const char *ptr = cstr + 2;
        const char *end = cstr + str.length();
        while (ptr < end) {
          char c1 = *ptr++;
          int i1 = 0;
          if ((c1 >= '0') && (c1 <= '9'))
            i1 = c1 - '0';
          if ((c1 >= 'a') && (c1 <= 'f'))
            i1 = 10 + c1 - 'a';
          if ((c1 >= 'A') && (c1 <= 'F'))
            i1 = 10 + c1 - 'A';
          char c2 = *ptr++;
          int i2 = 0;
          if ((c2 >= '0') && (c2 <= '9'))
            i2 = c2 - '0';
          if ((c2 >= 'a') && (c2 <= 'f'))
            i2 = 10 + c2 - 'a';
          if ((c2 >= 'A') && (c2 <= 'F'))
            i2 = 10 + c2 - 'A';
          buffer[c] = (i1 * 16) + i2;
          c++;
        } // end loop over string

        // BTI configuration string
        if (buffer[2] == 0x54) {
          if (m_debugDB)
            cout << "BTI STRING found in DB" << endl;

          // BTI configuration read for BTI
          flagDBBti = true;

          // compute sl and bti number from board and chip
          int brd = buffer[3];  // Board Nr.
          int chip = buffer[4]; // Chip Nr.

          if (brd > 7) {
            cout << "Not existing board ... " << brd << endl;
            return -1; // Non-existing board
          }
          if (chip > 31) {
            cout << "Not existing chip... " << chip << endl;
            return -1; // Non existing chip
          }

          // Is it Phi or Theta board?
          bool ThetaSL, PhiSL;
          PhiSL = false;
          ThetaSL = false;
          switch (mbtype) {
          case 1: // mb1
            if (brd == 6 || brd == 7) {
              ThetaSL = true;
              brd -= 6;
            } else if ((brd < 3 && chip < 32) || (brd == 3 && chip < 8))
              PhiSL = true;
            break;
          case 2: // mb2
            if (brd == 6 || brd == 7) {
              ThetaSL = true;
              brd -= 6;
            } else if (brd < 4 && chip < 32)
              PhiSL = true;
            break;
          case 3: // mb3
            if (brd == 6 || brd == 7) {
              ThetaSL = true;
              brd -= 6;
            } else if (brd < 5 && chip < 32)
              PhiSL = true;
            break;
          case 4: // mb4-s, mb4_8
            if (brd < 6 && chip < 32)
              PhiSL = true;
            break;
          case 5: // mb4-9
            if (brd < 3 && chip < 32)
              PhiSL = true;
            break;
          case 6: // mb4-4
            if (brd < 5 && chip < 32)
              PhiSL = true;
            break;
          case 7: // mb4-10
            if (brd < 4 && chip < 32)
              PhiSL = true;
            break;
          }
          if (!PhiSL && !ThetaSL) {
            cout << "MB type " << mbtype << endl;
            cout << "Board " << brd << " chip " << chip << endl;
            cout << "Not phi SL nor Theta SL" << endl;
            return -1; // Not PhiSL nor ThetaSL
          }

          // compute SL number and bti number
          int isl = 0;
          int ibti = 0;
          if (PhiSL) {
            if ((chip % 8) < 4)
              isl = 1; // Phi1
            else
              isl = 3; // Phi2
            ibti = brd * 16 + (int)(chip / 8) * 4 + (chip % 4);
          } else if (ThetaSL) {
            isl = 2; // Theta
            if ((chip % 8) < 4)
              ibti = brd * 32 + chip - 4 * (int)(chip / 8);
            else
              ibti = brd * 32 + chip + 12 - 4 * (int)(chip / 8);
          }

          // BTI config constructor from strings
          DTConfigBti bticonf(m_debugBti, buffer);

          dttpgConfig.setDTConfigBti(DTBtiId(chambid, isl, ibti + 1), bticonf);

          if (m_debugDB)
            cout << "Filling BTI config for chamber : wh " << chambid.wheel()
                 << ", st " << chambid.station() << ", se " << chambid.sector()
                 << "... sl " << isl << ", bti " << ibti + 1 << endl;
        }

        // TRACO configuration string
        if (buffer[2] == 0x15) {
          if (m_debugDB)
            cout << "TRACO STRING found in DB" << endl;
          // TRACO configuration read from OMDS
          flagDBTraco = true;

          // TRACO config constructor from strings
          int traco_brd = buffer[3];  // Board Nr.;
          int traco_chip = buffer[4]; // Chip Nr.;
          int itraco = traco_brd * 4 + traco_chip + 1;
          DTConfigTraco tracoconf(m_debugTraco, buffer);
          dttpgConfig.setDTConfigTraco(DTTracoId(chambid, itraco), tracoconf);

          if (m_debugDB)
            cout << "Filling TRACO config for chamber : wh " << chambid.wheel()
                 << ", st " << chambid.station() << ", se " << chambid.sector()
                 << ", board " << traco_brd << ", chip " << traco_chip
                 << ", traco " << itraco << endl;
        }

        // TSS configuration string
        if (buffer[2] == 0x16) {
          if (m_debugDB)
            cout << "TSS STRING found in DB" << endl;
          // TSS configuration read from OMDS
          flagDBTSS = true;

          unsigned short int itss = buffer[3];
          for (int i = 0; i < 31; i++)
            tss_buffer[itss][i] = buffer[i];
          ntss++;
        }

        // TSM configuration string
        if (buffer[2] == 0x17) {
          if (m_debugDB)
            cout << "TSM STRING found in DB" << endl;

          // TSM configuration read from OMDS
          flagDBTSM = true;

          for (int i = 0; i < 9; i++)
            tsm_buffer[i] = buffer[i];
        }

        // LUT configuration string
        if (buffer[2] == 0xA8) {
          if (m_debugDB)
            cout << "LUT STRING found in DB" << endl;

          // LUT parameters read from OMDS
          flagDBLUTS = true;
          DTConfigLUTs lutconf(m_debugLUTs, buffer);
          // lutconf.setDebug(m_debugLUTs);
          dttpgConfig.setDTConfigLUTs(chambid, lutconf);
        }

      } // end string iteration
    }   // end brick iteration

    // TSS + TSM configurations are set in DTConfigTSPhi constructor
    if (flagDBTSM && flagDBTSS) {
      DTConfigTSPhi tsphiconf(m_debugTSP, tss_buffer, ntss, tsm_buffer);
      dttpgConfig.setDTConfigTSPhi(chambid, tsphiconf);
    }

    // get configuration for TSTheta, SC and TU from .cfg
    edm::ParameterSet conf_ps =
        m_ps.getParameter<edm::ParameterSet>("DTTPGParameters");
    edm::ParameterSet tups =
        conf_ps.getParameter<edm::ParameterSet>("TUParameters");

    // TSTheta configuration from .cfg
    DTConfigTSTheta tsthetaconf(
        tups.getParameter<edm::ParameterSet>("TSThetaParameters"));
    tsthetaconf.setDebug(m_debugTST);
    dttpgConfig.setDTConfigTSTheta(chambid, tsthetaconf);

    // SC configuration from .cfg
    DTConfigSectColl sectcollconf(
        conf_ps.getParameter<edm::ParameterSet>("SectCollParameters"));
    sectcollconf.setDebug(m_debugSC);
    dttpgConfig.setDTConfigSectColl(
        DTSectCollId(chambid.wheel(), chambid.sector()), sectcollconf);

    // TU configuration from .cfg
    DTConfigTrigUnit trigunitconf(tups);
    trigunitconf.setDebug(m_debugTU);
    dttpgConfig.setDTConfigTrigUnit(chambid, trigunitconf);

    ++iter;

    // 110628 SV moved inside CCB loop to check for every chamber
    // moved to exception handling no attempt to configure from cfg is DB is
    // missing SV comment exception handling and activate flag in
    // DTConfigManager
    if (!flagDBBti || !flagDBTraco || !flagDBTSS || !flagDBTSM) {
      return -1;
    }
    if (!flagDBLUTS && dttpgConfig.lutFromDB() == true) {
      return -1;
    }
  } // end loop over CCB

  return 0;
}

std::string DTConfigDBProducer::mapEntryName(const DTChamberId &chambid) const {
  int iwh = chambid.wheel();
  std::ostringstream os;
  os << "wh";
  if (iwh < 0) {
    os << 'm' << -iwh;
  } else {
    os << iwh;
  }
  os << "st" << chambid.station() << "se" << chambid.sector();
  return os.str();
}

void DTConfigDBProducer::configFromCfg(DTConfigManager &dttpgConfig) {

  // ... but still set CCB validity flag to let the emulator run
  dttpgConfig.setCCBConfigValidity(true);

  // create config classes&C.
  edm::ParameterSet conf_ps =
      m_ps.getParameter<edm::ParameterSet>("DTTPGParameters");
  edm::ParameterSet conf_map =
      m_ps.getUntrackedParameter<edm::ParameterSet>("DTTPGMap");
  bool dttpgdebug = conf_ps.getUntrackedParameter<bool>("Debug");
  DTConfigSectColl sectcollconf(
      conf_ps.getParameter<edm::ParameterSet>("SectCollParameters"));
  edm::ParameterSet tups =
      conf_ps.getParameter<edm::ParameterSet>("TUParameters");
  DTConfigBti bticonf(tups.getParameter<edm::ParameterSet>("BtiParameters"));
  DTConfigTraco tracoconf(
      tups.getParameter<edm::ParameterSet>("TracoParameters"));
  DTConfigTSTheta tsthetaconf(
      tups.getParameter<edm::ParameterSet>("TSThetaParameters"));
  DTConfigTSPhi tsphiconf(
      tups.getParameter<edm::ParameterSet>("TSPhiParameters"));
  DTConfigTrigUnit trigunitconf(tups);
  DTConfigLUTs lutconf(tups.getParameter<edm::ParameterSet>("LutParameters"));

  for (int iwh = -2; iwh <= 2; ++iwh) {
    for (int ist = 1; ist <= 4; ++ist) {
      for (int ise = 1; ise <= 12; ++ise) {
        DTChamberId chambid(iwh, ist, ise);
        vector<int> nmap = conf_map.getUntrackedParameter<vector<int>>(
            mapEntryName(chambid).c_str());

        if (dttpgdebug) {
          cout << " Filling configuration for chamber : wh " << chambid.wheel()
               << ", st " << chambid.station() << ", se " << chambid.sector()
               << endl;
        }

        // fill the bti map
        if (!flagDBBti) {
          for (int isl = 1; isl <= 3; isl++) {
            int ncell = nmap[isl - 1];
            //    cout << ncell <<" , ";
            for (int ibti = 0; ibti < ncell; ibti++) {
              dttpgConfig.setDTConfigBti(DTBtiId(chambid, isl, ibti + 1),
                                         bticonf);
              if (dttpgdebug)
                cout << "Filling BTI config for chamber : wh "
                     << chambid.wheel() << ", st " << chambid.station()
                     << ", se " << chambid.sector() << "... sl " << isl
                     << ", bti " << ibti + 1 << endl;
            }
          }
        }

        // fill the traco map
        if (!flagDBTraco) {
          int ntraco = nmap[3];
          // cout << ntraco << " }" << endl;
          for (int itraco = 0; itraco < ntraco; itraco++) {
            dttpgConfig.setDTConfigTraco(DTTracoId(chambid, itraco + 1),
                                         tracoconf);
            if (dttpgdebug)
              cout << "Filling TRACO config for chamber : wh "
                   << chambid.wheel() << ", st " << chambid.station() << ", se "
                   << chambid.sector() << ", traco " << itraco + 1 << endl;
          }
        }

        // fill TS & TrigUnit
        if (!flagDBTSS || !flagDBTSM) {
          dttpgConfig.setDTConfigTSTheta(chambid, tsthetaconf);
          dttpgConfig.setDTConfigTSPhi(chambid, tsphiconf);
          dttpgConfig.setDTConfigTrigUnit(chambid, trigunitconf);
        }
      }
    }
  }

  for (int iwh = -2; iwh <= 2; ++iwh) {
    for (int ise = 13; ise <= 14; ++ise) {
      int ist = 4;
      DTChamberId chambid(iwh, ist, ise);
      vector<int> nmap = conf_map.getUntrackedParameter<vector<int>>(
          mapEntryName(chambid).c_str());

      if (dttpgdebug) {
        cout << " Filling configuration for chamber : wh " << chambid.wheel()
             << ", st " << chambid.station() << ", se " << chambid.sector()
             << endl;
      }

      // fill the bti map
      if (!flagDBBti) {
        for (int isl = 1; isl <= 3; isl++) {
          int ncell = nmap[isl - 1];
          //    cout << ncell <<" , ";
          for (int ibti = 0; ibti < ncell; ibti++) {
            dttpgConfig.setDTConfigBti(DTBtiId(chambid, isl, ibti + 1),
                                       bticonf);
            if (dttpgdebug)
              cout << "Filling BTI config for chamber : wh " << chambid.wheel()
                   << ", st " << chambid.station() << ", se "
                   << chambid.sector() << "... sl " << isl << ", bti "
                   << ibti + 1 << endl;
          }
        }
      }

      // fill the traco map
      if (!flagDBTraco) {
        int ntraco = nmap[3];
        //       cout << ntraco << " }" << endl;
        for (int itraco = 0; itraco < ntraco; itraco++) {
          dttpgConfig.setDTConfigTraco(DTTracoId(chambid, itraco + 1),
                                       tracoconf);
          if (dttpgdebug)
            cout << "Filling TRACO config for chamber : wh " << chambid.wheel()
                 << ", st " << chambid.station() << ", se " << chambid.sector()
                 << ", traco " << itraco + 1 << endl;
        }
      }

      // fill TS & TrigUnit
      if (!flagDBTSS || !flagDBTSM) {
        dttpgConfig.setDTConfigTSTheta(chambid, tsthetaconf);
        dttpgConfig.setDTConfigTSPhi(chambid, tsphiconf);
        dttpgConfig.setDTConfigTrigUnit(chambid, trigunitconf);
      }
    }
  }

  // loop on Sector Collectors
  for (int wh = -2; wh <= 2; wh++)
    for (int se = 1; se <= 12; se++)
      dttpgConfig.setDTConfigSectColl(DTSectCollId(wh, se), sectcollconf);

  // fake collection of pedestals
  dttpgConfig.setDTConfigPedestals(buildTrivialPedestals());

  return;
}

DTConfigPedestals DTConfigDBProducer::buildTrivialPedestals() {
  DTTPGParameters *m_tpgParams = new DTTPGParameters();

  int counts = m_ps.getParameter<int>("bxOffset");
  float fine = m_ps.getParameter<double>("finePhase");

  if (m_debugPed)
    cout << "DTConfigTrivialProducer::buildPedestals()" << endl;

  // DTTPGParameters tpgParams;
  for (int iwh = -2; iwh <= 2; ++iwh) {
    for (int ist = 1; ist <= 4; ++ist) {
      for (int ise = 1; ise <= 14; ++ise) {
        if (ise > 12 && ist != 4)
          continue;

        DTChamberId chId(iwh, ist, ise);
        m_tpgParams->set(chId, counts, fine, DTTimeUnits::ns);
      }
    }
  }

  DTConfigPedestals tpgPedestals;
  tpgPedestals.setUseT0(false);
  tpgPedestals.setES(m_tpgParams);

  return tpgPedestals;
}