ecalsrcondtools Namespace Reference

Functions
void	importParameterSet (EcalSRSettings &sr, const edm::ParameterSet &ps)
void	importSrpConfigFile (EcalSRSettings &sr, std::istream &f, bool debug=false)
double	normalizeWeights (int hwWeight)
string	tokenize (const string &s, const string &delim, int &pos)
std::string	trim (std::string s)

Function Documentation

importParameterSet()

void ecalsrcondtools::importParameterSet	(	EcalSRSettings &	sr,
		const edm::ParameterSet &	ps
	)

Converts CMSSW python file selective readout setting ("parameter set") into a condition database object. Configuration from parameter set covers only part of the config, mainly the configuration needed for SR emulation in the MC. The parameters not supported by python configuration are left untouched in the sr object.

Parameters

sr	[in] ECAL selective readout setting object to set
ps	CMSSW parameter set containing the SR parameters to set

Definition at line 80 of file EcalSRCondTools.cc.

References EcalSRSettings::actions_, filterCSVwithJSON::copy, EcalSRSettings::dccNormalizedWeights_, EcalSRSettings::deltaEta_, EcalSRSettings::deltaPhi_, EcalSRSettings::ebDccAdcToGeV_, EcalSRSettings::ecalDccZs1stSample_, EcalSRSettings::eeDccAdcToGeV_, edm::ParameterSet::getParameter(), EcalSRSettings::srpHighInterestChannelZS_, EcalSRSettings::srpLowInterestChannelZS_, EcalSRSettings::symetricZS_, and w().

Referenced by module::EcalSRCondTools::analyze(), and EcalSelectiveReadoutProducer::EcalSelectiveReadoutProducer().

                                                                         {
    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");
  }

importSrpConfigFile()

void ecalsrcondtools::importSrpConfigFile	(	EcalSRSettings &	sr,
		std::istream &	f,
		bool	debug = false
	)

Imports an SRP configuration file (stored in database "CLOB") into a Selective readout setting object.

Parameters

sr	[in] ECAL selective readout setting object to set
f	configuration file stream. A stringstream can be used if the configuration is available as an stl string of a c-string: stringstream buf; buf << s;
debug	verbosity flag. If true, imported parameter are displayed on stdout.

Definition at line 118 of file EcalSRCondTools.cc.

References EcalSRSettings::actions_, cms::cuda::assert(), EcalSRSettings::automaticMasks_, EcalSRSettings::automaticSrpSelect_, EcalSRSettings::bxOffsets_, gather_cfg::cout, ztail::d, EcalSRSettings::dccMasks_, dccNum, EcalSRSettings::deltaEta_, EcalSRSettings::deltaPhi_, Exception, f, mps_splice::line, nChs, EcalSRSettings::nDccs_, EcalSRSettings::nSrps_, EcalSRSettings::nTccs_, EcalSRSettings::srfMasks_, EcalSRSettings::srpMasksFromConfig_, EcalSRSettings::substitutionSrfs_, EcalSRSettings::tccMasksFromConfig_, tccNum, EcalSRSettings::testerDccTestSrpIds_, EcalSRSettings::testerSrpEmuSrpIds_, EcalSRSettings::testerSrpTestSrpIds_, EcalSRSettings::testerTccEmuSrpIds_, tokenize(), trim(), and relativeConstraints::value.

Referenced by module::EcalSRCondTools::analyze(), and popcon::EcalSRPHandler::getNewObjects().

                                                                      {
    //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();
  }

normalizeWeights()

double ecalsrcondtools::normalizeWeights

(

int

hwWeight

)

convert hardware weights (interger weights) into normalized weights. The former reprensentation is used in DCC firmware and in online databaser, while the later is used in offline software.

Definition at line 398 of file EcalSRCondTools.cc.

                                        {
    //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.;
  }

tokenize()

string ecalsrcondtools::tokenize	(	const string &	s,
		const string &	delim,
		int &	pos
	)

Definition at line 53 of file EcalSRCondTools.cc.

References spr::find(), and alignCSCRings::s.

Referenced by importSrpConfigFile().

                                                                  {
    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);
  }

trim()

std::string ecalsrcondtools::trim

(

std::string

s

)

Definition at line 68 of file EcalSRCondTools.cc.

References alignCSCRings::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);
  }