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 int	getRUIfromDDUId (unsigned ddu_id)
	Get RUI Number from DDU source ID for post LS1 configuration. 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 67 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 gen::n, and SignificanceLevelLow().

Referenced by fastHash(), and 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 gen::n, S(), SignificanceLevelHigh(), and SignificanceLevelLow().

Referenced by fastHash(), and 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 84 of file CSCDQM_Utility.h.

References checkError(), checkOccupancy(), fastHash(), getRUIfromDDUId(), N, gen::n, SignificanceLevelHigh(), SignificanceLevelLow(), and electronIdCutBased_cfi::threshold.

Referenced by fastHash().

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

cscdqm::Utility::fastHash

static uint32_t fastHash(const char *data, int len)

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

Definition: CSCDQM_Utility.cc:221

data

char data[epos_bytes_allocation]

Definition: EPOS_Wrapper.h:82

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 == "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 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;
   }

int cscdqm::Utility::getRUIfromDDUId ( unsigned ddu_id )

static

Get RUI Number from DDU source ID for post LS1 configuration.

Parameters

ddu_id DDI Source ID

Definition at line 364 of file CSCDQM_Utility.cc.

References mps_fire::i, FEDNumbering::MAXCSCDDUFEDID, and FEDNumbering::MINCSCDDUFEDID.

Referenced by fastHash(), cscdqm::EventProcessor::processDDU(), and cscdqm::EventProcessor::processExaminer().

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

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(), cscdqm::HistoDef::processName(), and cscdqm::Configuration::~Configuration().

                                                                                 {
     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.

Referenced by cscdqm::Configuration::~Configuration().

                                                                                                      {
     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 = static_cast<const char *>(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 cmsBatch::log, N, gen::n, Vispa.Plugins.EdmBrowser.EdmDataAccessor::ne(), and mathSSE::sqrt().

Referenced by checkOccupancy(), and fastHash().

                                                                                   {
     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, cmsBatch::log, gen::n, alignCSCRings::r, and mathSSE::sqrt().

Referenced by checkError(), checkOccupancy(), and fastHash().

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

Static Public Member Functions

Detailed Description

Member Function Documentation