cscdqm::Utility Class Reference

General and CSCDQM Framework related utility routines. More...

#include <CSCDQM_Utility.h>

Static Public Member Functions
static bool	checkError (const unsigned int N, const unsigned int n, const double threshold, const double sigfail)
	Check the hypothesis that error events (n) value above threshold comparing with the expected 0 and statistics is enough. More...
static short	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)
	Check the hypothesis that observed events (n) value is too low or too high comparing with the expected N. More...
static uint32_t	fastHash (const char *data, int len)
	Calculate super fast hash (from http://www.azillionmonkeys.com/qed/hash.html) More...
static uint32_t	fastHash (const char *data)
static int	getCSCTypeBin (const std::string &cstr)
	Get CSC y-axis position from chamber string. More...
static std::string	getCSCTypeLabel (int endcap, int station, int ring)
	Get CSC label from CSC parameters. More...
static bool	regexMatch (const std::string &expression, const std::string &message)
	Match RegExp expression string against string message and return result. More...
static bool	regexMatch (const TPRegexp &re_expression, const std::string &message)
	Match RegExp expression against string message and return result. More...
static void	regexReplace (const std::string &expression, std::string &message, const std::string replace="")
	Replace string part that matches RegExp expression with some string. More...
static void	regexReplace (const TPRegexp &re_expression, std::string &message, const std::string replace="")
	Replace string part that matches RegExp expression with some string. More...
static std::string	regexReplaceStr (const std::string &expression, const std::string &message, const std::string replace="")
	Replace string part that matches RegExp expression with some string. More...
static std::string	regexReplaceStr (const TPRegexp &re_expression, const std::string &message, const std::string replace="")
	Replace string part that matches RegExp expression with some string. More...
static double	SignificanceLevelHigh (const unsigned int N, const unsigned int n)
	Calculate error significance alpha for the given number of events based on reference number of errors for "hot" elements: actual number of events have to be larger then the reference. More...
static double	SignificanceLevelLow (const unsigned int N, const unsigned int n, const double eps)
	Calculate error significance alpha for the given number of errors based on reference number of errors for "cold" elements: actual number of events have to be less then the reference. More...
static void	splitString (const std::string &str, const std::string &delim, std::vector< std::string > &results)
	Split string according to delimiter. More...
static int	tokenize (const std::string &str, std::vector< std::string > &tokens, const std::string &delimiters=" ")
	Break string into tokens. More...
static void	trimString (std::string &str)
	Trim string. More...

Detailed Description

General and CSCDQM Framework related utility routines.

Definition at line 69 of file CSCDQM_Utility.h.

Member Function Documentation

bool cscdqm::Utility::checkError ( const unsigned int  N, const unsigned int  n, const double  threshold, const double  sigfail  )

static

Check the hypothesis that error events (n) value above threshold comparing with the expected 0 and statistics is enough.

Parameters

N	Number of total events
n	Actual (observed) number of events errors
threshold	Rate of tolerance (<1)
sigfail	Significance threshold for low value

Returns

check result: true - error is significant, false - otherwise

Definition at line 301 of file CSCDQM_Utility.cc.

References n, and SignificanceLevelLow().

Referenced by cscdqm::Summary::ReadErrorChambers().

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

short cscdqm::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  )

static

Check the hypothesis that observed events (n) value is too low or too high comparing with the expected N.

Parameters

N	Expected number of events
n	Actual (observed) number of events
low_threshold	Rate of lower boundary of tolerance (< 1)
high_threshold	Rate of higher boundary of tolerance (> 1)
low_sigfail	Significance threshold for low value
high_sigfail	Significance threshold for high value

Returns

check outcome: 1 - observed number of events too high wrt expected (HOT), -1 - observed number of events too low wrt expected (COLD), 0 - observed number of events is fine wrt expected

Definition at line 278 of file CSCDQM_Utility.cc.

References n, SignificanceLevelHigh(), and SignificanceLevelLow().

Referenced by cscdqm::Summary::ReadReportingChambersRef().

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

uint32_t cscdqm::Utility::fastHash ( const char *  data, int  len  )

static

Calculate super fast hash (from http://www.azillionmonkeys.com/qed/hash.html)

Parameters

data	Source Data
length	of data

Returns

hash result

Definition at line 221 of file CSCDQM_Utility.cc.

References data, get16bits, cond::hash, NULL, and tmp.

                                                       {
    uint32_t hash = len, tmp;
    int rem;
  
    if (len <= 0 || data == NULL) 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;
  }

static uint32_t cscdqm::Utility::fastHash ( const char *  data )

inlinestatic

Definition at line 86 of file CSCDQM_Utility.h.

References fastHash().

Referenced by fastHash().

{ return fastHash(data, strlen(data)); }

int cscdqm::Utility::getCSCTypeBin ( const std::string &  cstr )

static

Get CSC y-axis position from chamber string.

Parameters

cstr	Chamber string

Returns

chamber y-axis position

Definition at line 33 of file CSCDQM_Utility.cc.

Referenced by cscdqm::EventProcessor::getCSCFromMap().

                                                  {
    if (cstr.compare("ME-4/2") == 0) return 0;
    if (cstr.compare("ME-4/1") == 0) return 1;
    if (cstr.compare("ME-3/2") == 0) return 2;
    if (cstr.compare("ME-3/1") == 0) return 3;
    if (cstr.compare("ME-2/2") == 0) return 4;
    if (cstr.compare("ME-2/1") == 0) return 5;
    if (cstr.compare("ME-1/3") == 0) return 6;
    if (cstr.compare("ME-1/2") == 0) return 7;
    if (cstr.compare("ME-1/1") == 0) return 8;
    if (cstr.compare("ME+1/1") == 0) return 9;
    if (cstr.compare("ME+1/2") == 0) return 10;
    if (cstr.compare("ME+1/3") == 0) return 11;
    if (cstr.compare("ME+2/1") == 0) return 12;
    if (cstr.compare("ME+2/2") == 0) return 13;
    if (cstr.compare("ME+3/1") == 0) return 14;
    if (cstr.compare("ME+3/2") == 0) return 15;
    if (cstr.compare("ME+4/1") == 0) return 16;
    if (cstr.compare("ME+4/2") == 0) return 17;
    return 0;
  }

std::string cscdqm::Utility::getCSCTypeLabel ( int  endcap, int  station, int  ring  )

static

Get CSC label from CSC parameters.

Parameters

endcap	Endcap number
station	Station number
ring	Ring number

Returns

chamber label

Definition at line 62 of file CSCDQM_Utility.cc.

References diffTwoXMLs::label, relativeConstraints::ring, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by cscdqm::EventProcessor::getCSCFromMap().

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

bool cscdqm::Utility::regexMatch ( const std::string &  expression, const std::string &  message  )

static

Match RegExp expression string against string message and return result.

Parameters

expression	RegExp expression in string to match
message	value to check

Returns

true if message matches RegExp expression

Definition at line 150 of file CSCDQM_Utility.cc.

Referenced by CSCOfflineClient::bookMonitorObject(), CSCMonitorModule::bookMonitorObject(), cscdqm::Collection::load(), cscdqm::Configuration::needBookMO(), and cscdqm::HistoDef::processName().

                                                                                {
    return regexMatch(TPRegexp(expression), message);
  }

bool cscdqm::Utility::regexMatch ( const TPRegexp &  re_expression, const std::string &  message  )

static

Match RegExp expression against string message and return result.

Parameters

re_expression	RegExp expression to match
message	value to check

Returns

true if message matches RegExp expression

Definition at line 139 of file CSCDQM_Utility.cc.

                                                                                  {
    TPRegexp *re = const_cast<TPRegexp*>(&re_expression);
    return re->MatchB(message);
  }

void cscdqm::Utility::regexReplace ( const std::string &  expression, std::string &  message, const std::string  replace = ""  )

static

Replace string part that matches RegExp expression with some string.

Parameters

expression	RegExp expression in string to match
message	value to check
replace	string to replace matched part

Definition at line 161 of file CSCDQM_Utility.cc.

                                                                                                     {
    Utility::regexReplace(TPRegexp(expression), message, replace);
  }

void cscdqm::Utility::regexReplace ( const TPRegexp &  re_expression, std::string &  message, const std::string  replace = ""  )

static

Replace string part that matches RegExp expression with some string.

Parameters

re_expression	RegExp expression to match
message	value to check
replace	string to replace matched part

Definition at line 172 of file CSCDQM_Utility.cc.

References alignCSCRings::s.

                                                                                                       {
    TString s(message); 
    TPRegexp *re = const_cast<TPRegexp*>(&re_expression);
    re->Substitute(s, replace);
    message = s;
  }

std::string cscdqm::Utility::regexReplaceStr ( const std::string &  expression, const std::string &  message, const std::string  replace = ""  )

static

Replace string part that matches RegExp expression with some string.

Parameters

expression	RegExp expression in string to match
message	value to check
replace	string to replace matched part

Returns

modified string

Definition at line 187 of file CSCDQM_Utility.cc.

                                                                                                                   {
    return regexReplaceStr(TPRegexp(expression), message, replace);
  }

std::string cscdqm::Utility::regexReplaceStr ( const TPRegexp &  re_expression, const std::string &  message, const std::string  replace = ""  )

static

Replace string part that matches RegExp expression with some string.

Parameters

re_expression	RegExp expression to match
message	value to check
replace	string to replace matched part

Returns

modified string

Definition at line 199 of file CSCDQM_Utility.cc.

References alignCSCRings::s.

                                                                                                                     {
    TString s(message); 
    TPRegexp *re = const_cast<TPRegexp*>(&re_expression);
    re->Substitute(s, replace);
    return s.Data();
  }

double cscdqm::Utility::SignificanceLevelHigh ( const unsigned int  N, const unsigned int  n  )

static

Calculate error significance alpha for the given number of events based on reference number of errors for "hot" elements: actual number of events have to be larger then the reference.

Parameters

N	number of reference events
n	number of actual events

Returns

error significance

no - n observed, ne - n expected

Definition at line 353 of file CSCDQM_Utility.cc.

References create_public_lumi_plots::log, N, n, Vispa.Plugins.EdmBrowser.EdmDataAccessor::ne(), and mathSSE::sqrt().

Referenced by checkOccupancy().

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

double cscdqm::Utility::SignificanceLevelLow ( const unsigned int  N, const unsigned int  n, const double  eps  )

static

Calculate error significance alpha for the given number of errors based on reference number of errors for "cold" elements: actual number of events have to be less then the reference.

Parameters

N	Number of events
n	Number of errors
eps	Rate of tolerance

Returns

Significance level

std::cout << "N = " << N << ", n = " << n << ", eps = " << eps << "\n";

Definition at line 322 of file CSCDQM_Utility.cc.

References a, b, create_public_lumi_plots::log, n, alignCSCRings::r, and mathSSE::sqrt().

Referenced by checkError(), and checkOccupancy().

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

void cscdqm::Utility::splitString ( const std::string &  str, const std::string &  delim, std::vector< std::string > &  results  )

static

Split string according to delimiter.

Parameters

str	String to split
delim	Delimiter
results	Vector to write results to

Returns

Definition at line 105 of file CSCDQM_Utility.cc.

Referenced by cscdqm::Detector::AddressFromString().

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

int cscdqm::Utility::tokenize ( const std::string &  str, std::vector< std::string > &  tokens, const std::string &  delimiters = " "  )

static

Break string into tokens.

Parameters

str	source string to break
tokens	pointer to result vector
delimiters	delimiter string, default " "

Returns

Definition at line 87 of file CSCDQM_Utility.cc.

Referenced by cscdqm::Collection::book().

                                                                                                       {
    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 cscdqm::Utility::trimString ( std::string &  str )

static

Trim string.

Parameters

str	string to trim

Definition at line 119 of file CSCDQM_Utility.cc.

Referenced by cscdqm::Detector::AddressFromString().

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