CSCDQM_Utility.cc

Go to the documentation of this file.

/*  =====================================================================================
 *
 *       Filename:  CSCDQM_Utility.cc
 *
 *    Description:  Histogram Utility code
 *
 *        Version:  1.0
 *        Created:  04/18/2008 03:39:49 PM
 *       Revision:  none
 *       Compiler:  gcc
 *
 *         Author:  Valdas Rapsevicius (VR), Valdas.Rapsevicius@cern.ch
 *        Company:  CERN, CH
 *
 *  =====================================================================================
 */
 
#ifdef CSC_RENDER_PLUGIN
#include "CSCDQM_Utility.h"
#else
#include "CSCDQM_Utility.h"
#endif
 
#include <cstdint>
 
namespace cscdqm {
 
  int Utility::getCSCTypeBin(const std::string& cstr) {
    if (cstr == "ME-4/2")
      return 0;
    if (cstr == "ME-4/1")
      return 1;
    if (cstr == "ME-3/2")
      return 2;
    if (cstr == "ME-3/1")
      return 3;
    if (cstr == "ME-2/2")
      return 4;
    if (cstr == "ME-2/1")
      return 5;
    if (cstr == "ME-1/3")
      return 6;
    if (cstr == "ME-1/2")
      return 7;
    if (cstr == "ME-1/1")
      return 8;
    if (cstr == "ME+1/1")
      return 9;
    if (cstr == "ME+1/2")
      return 10;
    if (cstr == "ME+1/3")
      return 11;
    if (cstr == "ME+2/1")
      return 12;
    if (cstr == "ME+2/2")
      return 13;
    if (cstr == "ME+3/1")
      return 14;
    if (cstr == "ME+3/2")
      return 15;
    if (cstr == "ME+4/1")
      return 16;
    if (cstr == "ME+4/2")
      return 17;
    return 0;
  }
 
  std::string Utility::getCSCTypeLabel(int endcap, int station, int ring) {
    std::string label = "Unknown";
    std::ostringstream st;
    if ((endcap > 0) && (station > 0) && (ring > 0)) {
      if (endcap == 1) {
        st << "ME+" << station << "/" << ring;
        label = st.str();
      } else if (endcap == 2) {
        st << "ME-" << station << "/" << ring;
        label = st.str();
      } else {
        label = "Unknown";
      }
    }
    return label;
  }
 
  int Utility::tokenize(const std::string& str, std::vector<std::string>& tokens, const std::string& delimiters) {
    std::string::size_type lastPos = str.find_first_not_of(delimiters, 0);
    std::string::size_type pos = str.find_first_of(delimiters, lastPos);
    while (std::string::npos != pos || std::string::npos != lastPos) {
      tokens.push_back(str.substr(lastPos, pos - lastPos));
      lastPos = str.find_first_not_of(delimiters, pos);
      pos = str.find_first_of(delimiters, lastPos);
    }
    return tokens.size();
  }
 
  void Utility::splitString(const std::string& str, const std::string& delim, std::vector<std::string>& results) {
    std::string::size_type lastPos = str.find_first_not_of(delim, 0);
    std::string::size_type pos = str.find_first_of(delim, lastPos);
    while (std::string::npos != pos || std::string::npos != lastPos) {
      results.push_back(str.substr(lastPos, pos - lastPos));
      lastPos = str.find_first_not_of(delim, pos);
      pos = str.find_first_of(delim, lastPos);
    }
  }
 
  void Utility::trimString(std::string& str) {
    std::string::size_type pos = str.find_last_not_of(' ');
    if (pos != std::string::npos) {
      str.erase(pos + 1);
      pos = str.find_first_not_of(' ');
      if (pos != std::string::npos) {
        str.erase(0, pos);
      }
    } else {
      str.erase(str.begin(), str.end());
    }
  }
 
  bool Utility::regexMatch(const TPRegexp& re_expression, const std::string& message) {
    TPRegexp* re = const_cast<TPRegexp*>(&re_expression);
    return re->MatchB(message);
  }
 
  bool Utility::regexMatch(const std::string& expression, const std::string& message) {
    return regexMatch(TPRegexp(expression), message);
  }
 
  void Utility::regexReplace(const std::string& expression, std::string& message, const std::string replace) {
    Utility::regexReplace(TPRegexp(expression), message, replace);
  }
 
  void Utility::regexReplace(const TPRegexp& re_expression, std::string& message, const std::string replace) {
    TString s(message);
    TPRegexp* re = const_cast<TPRegexp*>(&re_expression);
    re->Substitute(s, replace);
    message = static_cast<const char*>(s);
  }
 
  std::string Utility::regexReplaceStr(const std::string& expression,
                                       const std::string& message,
                                       const std::string replace) {
    return regexReplaceStr(TPRegexp(expression), message, replace);
  }
 
  std::string Utility::regexReplaceStr(const TPRegexp& re_expression,
                                       const std::string& message,
                                       const std::string replace) {
    TString s(message);
    TPRegexp* re = const_cast<TPRegexp*>(&re_expression);
    re->Substitute(s, replace);
    return s.Data();
  }
 
#undef get16bits
#if (defined(__GNUC__) && defined(__i386__)) || defined(__WATCOMC__) || defined(_MSC_VER) || defined(__BORLANDC__) || \
    defined(__TURBOC__)
#define get16bits(d) (*((const uint16_t*)(d)))
#endif
 
#if !defined(get16bits)
#define get16bits(d) ((((uint32_t)(((const uint8_t*)(d))[1])) << 8) + (uint32_t)(((const uint8_t*)(d))[0]))
#endif
 
  uint32_t Utility::fastHash(const char* data, int len) {
    uint32_t hash = len, tmp;
    int rem;
 
    if (len <= 0 || data == nullptr)
      return 0;
    rem = len & 3;
    len >>= 2;
 
    /* Main loop */
    for (; len > 0; len--) {
      hash += get16bits(data);
      tmp = (get16bits(data + 2) << 11) ^ hash;
      hash = (hash << 16) ^ tmp;
      data += 2 * sizeof(uint16_t);
      hash += hash >> 11;
    }
 
    /* Handle end cases */
    switch (rem) {
      case 3:
        hash += get16bits(data);
        hash ^= hash << 16;
        hash ^= data[sizeof(uint16_t)] << 18;
        hash += hash >> 11;
        break;
      case 2:
        hash += get16bits(data);
        hash ^= hash << 11;
        hash += hash >> 17;
        break;
      case 1:
        hash += *data;
        hash ^= hash << 10;
        hash += hash >> 1;
    }
 
    /* Force "avalanching" of final 127 bits */
    hash ^= hash << 3;
    hash += hash >> 5;
    hash ^= hash << 4;
    hash += hash >> 17;
    hash ^= hash << 25;
    hash += hash >> 6;
 
    return hash;
  }
 
  short Utility::checkOccupancy(const unsigned int N,
                                const unsigned int n,
                                const double low_threshold,
                                const double high_threshold,
                                const double low_sigfail,
                                const double high_sigfail) {
    if (N > 0) {
      double eps_meas = (1.0 * n) / (1.0 * N);
      if (eps_meas < low_threshold) {
        double S = Utility::SignificanceLevelLow(N, n, low_threshold);
        if (S > low_sigfail)
          return -1;
      } else if (eps_meas > high_threshold) {
        double S = Utility::SignificanceLevelHigh(N, n);
        if (S > high_sigfail)
          return 1;
      }
    }
    return 0;
  }
 
  bool Utility::checkError(const unsigned int N, const unsigned int n, const double threshold, const double sigfail) {
    if (N > 0) {
      const double eps_meas = (1.0 * n) / (1.0 * N);
      if (eps_meas > threshold) {
        if (Utility::SignificanceLevelLow(N, n, threshold) > sigfail) {
          return true;
        }
      }
    }
    return false;
  }
 
  double Utility::SignificanceLevelLow(const unsigned int N, const unsigned int n, const double eps) {
    double l_eps = eps;
    if (l_eps <= 0.0)
      l_eps = 0.000001;
    if (l_eps >= 1.0)
      l_eps = 0.999999;
 
    double eps_meas = (1.0 * n) / (1.0 * N);
    double a = 1.0, b = 1.0;
 
    if (n > 0) {
      for (unsigned int r = 0; r < n; r++)
        a = a * (eps_meas / l_eps);
    }
 
    if (n < N) {
      for (unsigned int r = 0; r < (N - n); r++)
        b = b * (1 - eps_meas) / (1 - l_eps);
    }
 
    return sqrt(2.0 * log(a * b));
  }
 
  double Utility::SignificanceLevelHigh(const unsigned int N, const unsigned int n) {
    if (N > n)
      return 0.0;
    double no = 1.0 * n, ne = 1.0 * N;
    return sqrt(2.0 * (no * (log(no / ne) - 1) + ne));
  }
 
  int Utility::getRUIfromDDUId(unsigned ddu_id) {
    int rui = -1;
    const unsigned postLS1_map[] = {841, 842, 843, 844, 845, 846, 847, 848, 849, 831, 832, 833,
                                    834, 835, 836, 837, 838, 839, 861, 862, 863, 864, 865, 866,
                                    867, 868, 869, 851, 852, 853, 854, 855, 856, 857, 858, 859};
    if ((ddu_id >= FEDNumbering::MINCSCDDUFEDID) && (ddu_id <= FEDNumbering::MAXCSCDDUFEDID)) {
      for (int i = 0; i < 36; i++) {
        if (ddu_id == postLS1_map[i]) {
          rui = i + 1;
          return rui;
        }
      }
    } else {
      rui = ddu_id & 0xFF;
    }
    return rui;
  }
 
}  // namespace cscdqm