dqm_algorithms::BinHeight_LessThanEqual_Threshold Struct Reference

#include <BinHeight_LessThanEqual_Threshold.h>

Inheritance diagram for dqm_algorithms::BinHeight_LessThanEqual_Threshold:

Collaboration diagram for dqm_algorithms::BinHeight_LessThanEqual_Threshold:

Public Types
enum	binStatus { aRedBin, aYellowBin, aGreenBin, anUndefBin =-1 }

Public Member Functions
	BinHeight_LessThanEqual_Threshold ()
BinHeightThreshold *	clone ()
dqm_core::Result *	execute (const std::string &, const TObject &, const dqm_core::AlgorithmConfig &)
void	CheckThresholds (const std::string &type, double thresholdGr, double thresholdRed)
bool	checkUndefinedStatusValue (const std::string &type, double thresholdGr, double thresholdRed, std::pair< bool, double > valueGray)
BinHeightThreshold::binStatus	CompareBinHeightThreshold (const std::string &type, double bincontent, double thresholdGr, double thresholdRed, std::pair< bool, double > valueGray)
bool	equalWithinPrecision (double a, double b)
void	printDescription (std::ostream &out)

Private Attributes
std::string	m_name
double	m_precision {}

Detailed Description

Definition at line 16 of file BinHeight_LessThanEqual_Threshold.h.

Member Enumeration Documentation

binStatus

enum dqm_algorithms::BinHeightThreshold::binStatus

inherited

Enumerator
aRedBin
aYellowBin
aGreenBin
anUndefBin

Definition at line 21 of file BinHeightThreshold.h.

{aRedBin,aYellowBin,aGreenBin,anUndefBin=-1};

Constructor & Destructor Documentation

BinHeight_LessThanEqual_Threshold()

dqm_algorithms::BinHeight_LessThanEqual_Threshold::BinHeight_LessThanEqual_Threshold ( )

inline

Definition at line 18 of file BinHeight_LessThanEqual_Threshold.h.

: BinHeightThreshold("LessThanEqual") {};

Member Function Documentation

CheckThresholds()

void dqm_algorithms::BinHeightThreshold::CheckThresholds ( const std::string &  type, double  thresholdGr, double  thresholdRed  )

inherited

Definition at line 212 of file BinHeightThreshold.cxx.

                                                                                                                      {
  if(type=="GreaterThan" || type=="GreaterThanEqual")
    {
      if(thresholdGr>=thresholdRed)
    ERS_INFO("'BinHeight_" << type << "_Threshold' algorithm expects red > yellow > green. You set the warning threshold (" << thresholdGr << ") >= error threshold (" << thresholdRed << "): it will never return 'yellow/warning'.");
    }
  if(type=="LessThan" || type=="LessThanEqual")
    {
      if(thresholdGr<=thresholdRed)
    ERS_INFO("'BinHeight_" << type << "_Threshold' algorithm expects red < yellow < green. You set the warning threshold (" << thresholdGr << ") <= error threshold (" << thresholdRed << "): it will never return 'yellow/warning'. Are you sure this is what you want?");
    }
  if(type=="redEqual_yellowGreaterThan")
    {
      if(thresholdRed>0 && thresholdRed<thresholdGr)
    ERS_INFO("You set the error threshold (" << thresholdRed << ") between zero and the warning threshold (" << thresholdGr << ") in 'BinHeight_redEqual_yellowGreaterThan_Threshgold' algorithm. Are you sure this is what you want?");
    }
  if(type=="redEqual_yellowLessThan")
    {
      if(thresholdRed>thresholdGr)
    ERS_INFO("You set the error threshold (" << thresholdRed << ") larger than the warning threshold (" << thresholdGr << ") in 'BinHeight_redEqual_yellowLessThan_Threshold' algorithm. Are you sure this is what you want?");
    }
}

checkUndefinedStatusValue()

bool dqm_algorithms::BinHeightThreshold::checkUndefinedStatusValue ( const std::string &  type, double  thresholdGr, double  thresholdRed, std::pair< bool, double >  valueGray  )

inherited

Definition at line 236 of file BinHeightThreshold.cxx.

                                                                                                                                                         {
  if(!valueGray.first)
    return valueGray.first;
    
  if(type=="LessThan" || type=="GreaterThan")
    return valueGray.first;
 
  if(equalWithinPrecision(valueGray.second,thresholdRed))
    {
      ERS_INFO("You have set 'UndefinedStatus' equal to the error threshold in 'BinHeight_" << type << "_Threshold' algorithm. Error has the precedence here: the bin content WILL NOT be checked against 'UndefinedStatus'");
      return false;
    }
    
  if(type!="redEqual_yellowLessThan" && type!="redEqual_yellowGreaterThan" && equalWithinPrecision(valueGray.second,thresholdGr))
    {
      ERS_INFO("You have set 'UndefinedStatus' equal to the warning threshold in 'BinHeight_" << type << "_Threshold' algorithm. Warning has the precedence here: the bin content WILL NOT be checked against 'UndefinedStatus'");
      return false;
    }
 
  return valueGray.first;
}

clone()

dqm_algorithms::BinHeightThreshold * dqm_algorithms::BinHeightThreshold::clone ( )

inherited

Definition at line 43 of file BinHeightThreshold.cxx.

{  
  return new BinHeightThreshold(m_name);
}

CompareBinHeightThreshold()

dqm_algorithms::BinHeightThreshold::binStatus dqm_algorithms::BinHeightThreshold::CompareBinHeightThreshold ( const std::string &  type, double  bincontent, double  thresholdGr, double  thresholdRed, std::pair< bool, double >  valueGray  )

inherited

Definition at line 261 of file BinHeightThreshold.cxx.

                                                                                                                                                                            {
  if(valueGray.first)
    {
      if(equalWithinPrecision(bincontent,valueGray.second))
    {
      return dqm_algorithms::BinHeightThreshold::binStatus::anUndefBin;
    }
    }
 
  if(type=="GreaterThan")
    {
      if(bincontent>thresholdRed)
    return dqm_algorithms::BinHeightThreshold::binStatus::aRedBin;
      if(bincontent>thresholdGr)
    return dqm_algorithms::BinHeightThreshold::binStatus::aYellowBin;  
      return dqm_algorithms::BinHeightThreshold::binStatus::aGreenBin;
    }
  if(type=="LessThan")
    {
      if(bincontent<thresholdRed)
    return dqm_algorithms::BinHeightThreshold::binStatus::aRedBin;
      if(bincontent<thresholdGr)
    return dqm_algorithms::BinHeightThreshold::binStatus::aYellowBin;  
      return dqm_algorithms::BinHeightThreshold::binStatus::aGreenBin;
    }
  if(type=="GreaterThanEqual")
    {
      if(bincontent>thresholdRed || equalWithinPrecision(bincontent,thresholdRed))
    return dqm_algorithms::BinHeightThreshold::binStatus::aRedBin;
      if(bincontent>thresholdGr || equalWithinPrecision(bincontent,thresholdGr))
    return dqm_algorithms::BinHeightThreshold::binStatus::aYellowBin;  
      return dqm_algorithms::BinHeightThreshold::binStatus::aGreenBin;
    }
  if(type=="LessThanEqual")
    {
      if(bincontent<thresholdRed || equalWithinPrecision(bincontent,thresholdRed))
    return dqm_algorithms::BinHeightThreshold::binStatus::aRedBin;
      if(bincontent<thresholdGr || equalWithinPrecision(bincontent,thresholdGr))
    return dqm_algorithms::BinHeightThreshold::binStatus::aYellowBin;  
      return dqm_algorithms::BinHeightThreshold::binStatus::aGreenBin;
    }
  if(type=="redEqual_yellowGreaterThan")
    {
      if(equalWithinPrecision(bincontent,thresholdRed))
    return dqm_algorithms::BinHeightThreshold::binStatus::aRedBin;
      if(bincontent>thresholdGr) 
    return dqm_algorithms::BinHeightThreshold::binStatus::aYellowBin;
      return dqm_algorithms::BinHeightThreshold::binStatus::aGreenBin;
    }
  if(type=="redEqual_yellowLessThan")
    {
      if(equalWithinPrecision(bincontent,thresholdRed))
    return dqm_algorithms::BinHeightThreshold::binStatus::aRedBin;
      if(bincontent<thresholdGr) 
    return dqm_algorithms::BinHeightThreshold::binStatus::aYellowBin;
      return dqm_algorithms::BinHeightThreshold::binStatus::aGreenBin;
    }
  if(type=="Equal")
    {
      if(equalWithinPrecision(bincontent,thresholdRed))
    return dqm_algorithms::BinHeightThreshold::binStatus::aRedBin;
      if(equalWithinPrecision(bincontent,thresholdGr)) 
    return dqm_algorithms::BinHeightThreshold::binStatus::aYellowBin;
      return dqm_algorithms::BinHeightThreshold::binStatus::aGreenBin;
    }
  return dqm_algorithms::BinHeightThreshold::binStatus::anUndefBin;
}

equalWithinPrecision()

bool dqm_algorithms::BinHeightThreshold::equalWithinPrecision ( double  a, double  b  )

inherited

Definition at line 331 of file BinHeightThreshold.cxx.

{
  //relative difference method (following what suggested in (non-ATLAS) web page http://floating-point-gui.de/errors/comparison/)
  double absA = std::abs(a);
  double absB = std::abs(b);
  double diff = std::abs(a - b);
 
  if (a == b) { // shortcut, handles infinities
    return true;
  } 
  else if (a == 0 || b == 0 || diff < DBL_MIN) {
    // a or b is zero or both are extremely close to it
    // relative error is less meaningful here
    return diff < (m_precision * DBL_MIN);
  } 
  else { // use relative error
    return (diff / std::min((absA + absB), DBL_MAX)) < m_precision;
  }
}

execute()

dqm_core::Result * dqm_algorithms::BinHeightThreshold::execute ( const std::string &  name, const TObject &  object, const dqm_core::AlgorithmConfig &  config  )

inherited

Definition at line 50 of file BinHeightThreshold.cxx.

{  
  const TH1 * histogram;
  if( object.IsA()->InheritsFrom( "TH1" ) ) {
    histogram = static_cast<const TH1*>(&object);
    if (histogram->GetDimension() > 2 ){ 
      throw dqm_core::BadConfig( ERS_HERE, name, "dimension > 2 " );
    }
  } else {
    throw dqm_core::BadConfig( ERS_HERE, name, "does not inherit from TH1" );
  }
  const double minstat = 1;
  if (histogram->GetEntries() < minstat ) {
    ERS_INFO( "Too few entries: " << histogram->GetEntries() );
    dqm_core::Result *result = new dqm_core::Result(dqm_core::Result::Undefined);
    result->tags_["InsufficientEntries"] = histogram->GetEntries();
    return result;
  }
 
  int start_from_last;
  int n_bins;
  int window_size; 
  double gthreshold;
  double rthreshold;
  std::pair<bool,double> grayValue;
  try {
    n_bins = dqm_algorithms::tools::GetFirstFromMap( "NBins", config.getParameters() ,1);
    window_size = dqm_algorithms::tools::GetFirstFromMap( "WindowSize", config.getParameters() ,1); 
    start_from_last = dqm_algorithms::tools::GetFirstFromMap( "StartFromLast", config.getParameters() ,-1); 
    gthreshold = dqm_algorithms::tools::GetFromMap( "HeightThreshold", config.getGreenThresholds() );
    rthreshold = dqm_algorithms::tools::GetFromMap( "HeightThreshold", config.getRedThresholds() );
  }
  catch ( dqm_core::Exception & ex ) {
    throw dqm_core::BadConfig( ERS_HERE, name, ex.what(), ex );
  }
  grayValue.first=true;
  try {
    grayValue.second = dqm_algorithms::tools::GetFirstFromMap( "UndefinedStatus", config.getParameters() );
  }
  catch ( dqm_core::Exception & ex ) {
    grayValue.first=false;
    grayValue.second=-1;
  }
  try {
    m_precision = dqm_algorithms::tools::GetFirstFromMap( "EqualityPrecision", config.getParameters(),1e-4);
  }
  catch ( dqm_core::Exception & ex ) {
    m_precision=1e-4;
  }
 
 
  //check if the provided parameter values make sense
  if(m_precision<0) {
    ERS_INFO("'EqualityPrecision cannot be negative: it will be re-set to its absolute value.");
    m_precision=std::abs(m_precision);
  }
  if(window_size<=0) {
      ERS_INFO("You set search window size (WindowSize) <= 0: I will search the whole histogram.");
    }
  else {
    if(n_bins>window_size) {
      ERS_INFO("You set the minimum number of bins for throwing error/warning (NBins) larger than the window size (WindowSize): in this way the algorithm can never return error/warning. Setting NBins=WindowSize.");
      n_bins=window_size;
    }
  }
  if(n_bins<=0)  {
    ERS_INFO("You set the minimum number of bins for throwing error/warning (NBins) <= 0: in this way the algorithm would always return error. Setting NBins=1 (default value).");
    n_bins=1;
  }
  CheckThresholds(m_name,gthreshold,rthreshold);
  grayValue.first=checkUndefinedStatusValue(m_name,gthreshold,rthreshold,grayValue);
 
  dqm_core::Result* result = new dqm_core::Result();
  TH1* resulthisto;
  if (histogram->InheritsFrom("TH2")) {
    throw dqm_core::BadConfig( ERS_HERE, name, "TH2 received. This algorithm only works with TH1" );
  } else if (histogram->InheritsFrom("TH1")) {
        resulthisto=(TH1*)(histogram->Clone());
  } else {
    throw dqm_core::BadConfig( ERS_HERE, name, "does not inherit from TH1" );
  }
 
  resulthisto->Reset();
 
 
  //first, look for the last filled LB, i.e. the bin with nonzero content of largest x if start_from_last<0, if start_from_last>=0, then starts from last but N-th bin, where N=start_from_last
  int i_currentLB=histogram->GetNbinsX();
  if(start_from_last>=0)
    i_currentLB-=start_from_last;
  else
    {
      while(i_currentLB>=1)
    {
      if(histogram->GetBinContent(i_currentLB)!=0) break;
      i_currentLB--;
    }
    }
  //if the histogram is just empty, or still has too few bins, do nothing 
   if(i_currentLB<=0 || i_currentLB<n_bins)
    {
     ERS_DEBUG(1,"start_from_last parameter >= total number of bins, I just cannot do the check. Do nothing.");
     return result;
    }
 
   //now loop over an x window of size 'window_size'
    int iLB=i_currentLB;
    int countYellow=0;
    int countRed=0;
    int countGray=0;
    while(iLB>=1 && (window_size<0 || (i_currentLB-iLB)<window_size))
       {
    double content=histogram->GetBinContent(iLB);
    dqm_algorithms::BinHeightThreshold::binStatus LBstatus=CompareBinHeightThreshold(m_name,content, gthreshold , rthreshold,grayValue);
    if(LBstatus==dqm_algorithms::BinHeightThreshold::binStatus::aYellowBin) 
    {
      countYellow++;
    }
    if(LBstatus==dqm_algorithms::BinHeightThreshold::binStatus::aRedBin) 
    {
      countRed++;
    }
    if(LBstatus==dqm_algorithms::BinHeightThreshold::binStatus::anUndefBin) 
    {
      countGray++;
    }
    //fill result histogram
    resulthisto->SetBinContent(iLB,content);
    iLB--;
       }
 
       
    ERS_DEBUG(1,"Found " << countRed << " red bins and " << countYellow << " red bins. In a window of size " << window_size << " bins, starting at bin " << i_currentLB);
    ERS_DEBUG(1,"To be compared with: " << n_bins);
    ERS_DEBUG(1,"Green treshold=" << gthreshold << " Red threshold=" << rthreshold );
 
  result->tags_["NRedBins"] = countRed;
  result->tags_["NYellowBins"] = countYellow;
  result->object_ =  (boost::shared_ptr<TObject>)(TObject*)(resulthisto);
  if(countRed>=n_bins)
    {
      result->status_ = dqm_core::Result::Red;
    } 
  else if(countRed+countYellow>=n_bins)
    {
      result->status_ = dqm_core::Result::Yellow;
    } 
  else if(countGray>=n_bins)
    {
      result->status_ = dqm_core::Result::Undefined;
    }
  else
    {
      result->status_ = dqm_core::Result::Green;
    }
     
  return result;
  
}

printDescription()

void dqm_algorithms::BinHeightThreshold::printDescription ( std::ostream &  out )

inherited

Definition at line 352 of file BinHeightThreshold.cxx.

{
  TString redCond,yellowCond;
  if(m_name=="redEqual_yellowGreaterThan" || m_name=="redEqual_yellowLessThan" || m_name=="Equal")
    {
      redCond="bin_content==redThreshold";
      if(m_name=="Equal")
    yellowCond="bin_content==yellowThreshold && bin_content!=redThreshold";
      else if(m_name=="redEqual_yellowGreaterThan")
    yellowCond="bin_content>yellowThreshold && bin_content!=redThreshold";
      else
    yellowCond="bin_content<yellowThreshold && bin_content!=redThreshold";
    }
  else
    {
      if(m_name=="GreaterThan")
    {
      redCond="bin_content>redThreshold";
      yellowCond="redThreshold>=bin_content>yellowThreshold";
    }
      else if(m_name=="LessThan")
    {
      redCond="bin_content<redThreshold";
      yellowCond="redThreshold<=bin_content<yellowThreshold";
    }
      else if(m_name=="GreaterThanEqual")
    {
      redCond="bin_content>=redThreshold";
      yellowCond="redThreshold>bin_content>=yellowThreshold";
    }
      else //LessThenEqual is the only remaining
    {
      redCond="bin_content<=redThreshold";
      yellowCond="redThreshold<bin_content<=yellowThreshold";
    }
    }
  out << "BinHeight_" << m_name << "_Threshold checks the bin height of a TH1. Ideally, a quantity as a function of LB. LB is expected to be on x axis, the quantity of interest is the bin content." << std::endl;
  out << "BinHeight_" << m_name << "_Threshold defines 'red' and 'yellow' bins depending on the value of the bin content:\n \t-if " << redCond << ": the bin is 'red'.\n \t-if " << yellowCond << ": the bin is 'yellow'.\n \t-if (OPTIONAL) an 'UndefinedStatus' value is set and bin_content==UndefinedStatus, the bin is 'gray'.";
  if(m_name!="GreaterThan" && m_name!="LessThan")
    out << " Note that if 'UndefinedStatus' is equal to 'redThreshold' or 'yellowThreshold', the bin will be 'red'/'yellow' rather than 'gray'.";
  out << "\n \t-otherwise the bin is 'green'" << std::endl;
  out << "The algorithm checks all the bins in a window of size 'WindowSize', starting from:\n \t a) the last but X bin.\n \t b) the last non-zero bin.\n Oprion a) or b) is chosen by the parameter 'StartFromLast': if('StartFromLast'>=0), (a) holds and X is equal to 'StartFromLast', while (b) holds if 'StartFromLast'<0." << std::endl;
  out << "In the window of interest, the number of red/yellow/gray bins is counted, respectively Nred/Nyellow/Ngray. The output is then defined comparing these numbers against the parameter 'NBins':\n \t- if Nred>=NBins: returns 'RED'.\n \t- else, if (Nred+Nyellow)>=NBins: returns 'YELLOW'.\n \t- else, if Ngray>=NBins: returns 'GREY'.\n \t- else returns 'GREEN'." << std::endl;
  out << "NOTE: to avoid issues due to rounding in double precision, the equality between the bin content and any parameter is defined asking for the relative difference between the two to be smaller than a given parameter. I.e. content==Y is implemented as (abs(content-Y)/(content+Y))<epsilon. epsilon is equal to the parameter 'EqualityPrecision' which is tunable and set to 10^-4 by default\n"<<std::endl;
 
  out<<"Mandatory Parameter: HeightThreshold: sets the warning (yellowThreshold) and error (redThreshold) thresholds."<<std::endl; 
  out<<"Optional Parameter: NBins: minimum number of red/(yellow+red)/gray bins in the window of interest for the algorithm to return Red/Yellow/Grey. Default is 1."<<std::endl;
  out<<"Optional Parameter: WindowSize: size of the x-axis range (in number of bins) in which red/yellow/gray bins are searched for. If WindowSize<=0, the whole istogram is searched for. Default is 1."<<std::endl;
  out<<"Optional Parameter: StartFromLast: if StartFromLast=X with X>=0, the algorithm will check the bins starting from the last but X bin. If StartFromLast<0, it will start from the first bin of nonzero content. Default is -1."<<std::endl;
  out<<"Optional Parameter: UndefinedStatus: a bin is defined to be 'gray' if its content is equal to UndefinedStatus. If not set, bins are not check against it."<<std::endl;
  out<<"Optional Parameter: EqualityPrecision: sets the precision with which the bin content is defined to be 'equal' to a parameter, as described above. Default is 10^-4."<<std::endl;
}

Member Data Documentation

m_name

std::string dqm_algorithms::BinHeightThreshold::m_name

privateinherited

Definition at line 35 of file BinHeightThreshold.h.

m_precision

double dqm_algorithms::BinHeightThreshold::m_precision {}

privateinherited

Definition at line 36 of file BinHeightThreshold.h.

---

The documentation for this struct was generated from the following file:

• BinHeight_LessThanEqual_Threshold.h