BinThreshold.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/

 
#include <dqm_core/AlgorithmConfig.h>
#include <dqm_algorithms/BinThreshold.h>
#include <dqm_algorithms/tools/AlgorithmHelper.h>
#include <TH1.h>
#include <TF1.h>
#include <TClass.h>
#include <ers/ers.h>
 
#include <iostream>
#include <cmath>
#include <dqm_core/AlgorithmManager.h>
 
namespace
{
  dqm_algorithms::BinThreshold GreaterThan( "GreaterThan" );
  dqm_algorithms::BinThreshold GreaterThanAbs( "GreaterThanAbs" );
  dqm_algorithms::BinThreshold GreaterThanNonZeroMedian( "GreaterThanNonZeroMedian" );
  dqm_algorithms::BinThreshold GreaterThanEqual( "GreaterThanEqual" );
  dqm_algorithms::BinThreshold LessThan( "LessThan" );
  dqm_algorithms::BinThreshold LessThanAbs( "LessThanAbs" );
  dqm_algorithms::BinThreshold LessThanNonZeroMedian( "LessThanNonZeroMedian" );
  dqm_algorithms::BinThreshold LessThanEqual( "LessThanEqual" );
  dqm_algorithms::BinThreshold Equal( "Equal" );
  dqm_algorithms::BinThreshold NotEqual( "NotEqual" );
}
 
 
dqm_algorithms::BinThreshold::BinThreshold( const std::string & name )
  : m_name( name )
{
  dqm_core::AlgorithmManager::instance().registerAlgorithm("Bins_"+name+"_Threshold", this);
}
 
dqm_algorithms::BinThreshold * 
dqm_algorithms::BinThreshold::clone()
{
  
  return new BinThreshold( m_name );
}
 
 
dqm_core::Result *
dqm_algorithms::BinThreshold::execute( const std::string &  name, 
                        const TObject & object, 
                                                const dqm_core::AlgorithmConfig & config )
{  
  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 = dqm_algorithms::tools::GetFirstFromMap( "MinStat", config.getParameters(), -1);
  const bool publish = (bool) dqm_algorithms::tools::GetFirstFromMap( "PublishBins", config.getParameters(), 0); 
  const int maxpublish = (int) dqm_algorithms::tools::GetFirstFromMap( "MaxPublish", config.getParameters(), 20); 
  const int xmax = (int) dqm_algorithms::tools::GetFirstFromMap( "xMax", config.getParameters(), -1); 
  const int xmin = (int) dqm_algorithms::tools::GetFirstFromMap( "xMin", config.getParameters(), -1); 
  const int ymax = (int) dqm_algorithms::tools::GetFirstFromMap( "yMax", config.getParameters(), -1); 
  const int ymin = (int) dqm_algorithms::tools::GetFirstFromMap( "yMin", config.getParameters(), -1); 
 
  std::string ignoreBins     = dqm_algorithms::tools::GetFirstFromMap("IgnoreBins", config.getGenericParameters(), "-1");  //The format is a list of int pairs, separated with : and split by comas. The symbol * can be used to indicate rows or columns. Ex: "2:3,5:*,*:7"
 
  std::vector<int> hotColumns,  hotRows;
  std::vector<std::vector<int>> hotBins;
 
  parseVetoList(ignoreBins, hotRows, hotColumns, hotBins);
 
  bool vetoHotRows = false;    if (hotRows.size() > 0)    vetoHotRows = true;
  bool vetoHotBins = false;    if (hotBins.size() > 0)    vetoHotBins = true;
  bool vetoHotColumns = false; if (hotColumns.size() > 0) vetoHotColumns = true;
  
  if (histogram->GetEntries() < minstat ) {
    dqm_core::Result *result = new dqm_core::Result(dqm_core::Result::Undefined);
    result->tags_["InsufficientEntries"] = histogram->GetEntries();
    return result;
  }
  
  double bin_threshold;
  double gthreshold;
  double rthreshold;
  try {
    bin_threshold = dqm_algorithms::tools::GetFirstFromMap( "BinThreshold", config.getParameters() );
    rthreshold = dqm_algorithms::tools::GetFromMap( "NBins", config.getRedThresholds() );
    gthreshold = dqm_algorithms::tools::GetFromMap( "NBins", config.getGreenThresholds() );
  }
  catch ( dqm_core::Exception & ex ) {
    throw dqm_core::BadConfig( ERS_HERE, name, ex.what(), ex );
  }
  
  
  int count = 0; 
  std::vector<int> range=dqm_algorithms::tools::GetBinRange(histogram, config.getParameters()); 
  dqm_core::Result* result = new dqm_core::Result();
  TH1* resulthisto;
  if (histogram->InheritsFrom("TH2")) {
    resulthisto=(TH1*)(histogram->Clone());
  } else if (histogram->InheritsFrom("TH1")) {
        resulthisto=(TH1*)(histogram->Clone());
  } else {
    throw dqm_core::BadConfig( ERS_HERE, name, "does not inherit from TH1" );
  }
 
  resulthisto->Reset();
  if(m_name.find("Median")!=std::string::npos){
    std::vector<double> bin_vals;
    for ( int i = range[0]; i <= range[1]; ++i ) {
      for ( int j = range[2]; j <= range[3]; ++j ) {
    if(histogram -> GetBinContent(i,j) > 0) bin_vals . push_back( histogram -> GetBinContent(i,j) );
      }
    }
    std::sort(bin_vals.begin(), bin_vals.end());
    unsigned bin_vals_size = bin_vals.size();
    double median = 0;
    if(bin_vals_size%2==0 && bin_vals_size>1) median = (bin_vals.at(bin_vals_size/2-1)+bin_vals.at(bin_vals_size/2))/2;
    else if(bin_vals_size%2==1 && bin_vals_size>1) median = bin_vals.at(bin_vals_size/2-1);
    else if(bin_vals_size==1) median = bin_vals.at(0);
 
    double min_bin_threshold = dqm_algorithms::tools::GetFirstFromMap( "MinBinThreshold", config.getParameters() , -99999);
    double max_bin_threshold = dqm_algorithms::tools::GetFirstFromMap( "MaxBinTrheshold", config.getParameters() , -99999);
    bin_threshold=median*bin_threshold;
 
    bin_threshold = std::max(bin_threshold, min_bin_threshold);
    if(max_bin_threshold > -1 ) bin_threshold = std::min(bin_threshold, max_bin_threshold);
 
    result->tags_["Effective_BinThreshold"] = bin_threshold;
  }
 
  //bools for skiping threshold comparison of vetoed rows, columns and bins
  bool skipColumn = false;
  bool skipRow    = false;
  bool skipBin    = false;
 
  for ( int i = range[0]; i <= range[1]; ++i ) {
    skipColumn = false;
    for (int column  : hotColumns){
      if (vetoHotColumns && ( column == i || skipColumn == true)) skipColumn = true;
    }
    //Skip column if it is in list of vetoed columns
    if (skipColumn) continue;
    //Skip bin threshold comparison if xmax!=-1 and i>xmax
    if (xmax!=-1 && i>xmax) continue;
    //Skip bin threshold comparison if xmin!=-1 and i<xmin
    if (xmin!=-1 && i<xmin) continue;
 
    for ( int j = range[2]; j <= range[3]; ++j ) {
      skipRow = false; skipBin = false;
      for (int row  : hotRows){
    if (vetoHotRows && ( row == j || skipRow == true)) skipRow = true;
      }
      for (const auto& pair : hotBins){
    if (vetoHotBins && ( (pair[0] == i && pair[1] == j) || skipBin == true)) skipBin = true;
      }
      //Skip Bin if it is in list of vetoed bins
      if (skipBin) continue;
      //Skip Row if it is in list of vetoed rows
      if (skipRow) continue;
      //Skip bin threshold comparison if ymax!=-1 and j>ymax
      if (ymax!=-1 && j>ymax) continue;
      //Skip bin threshold comparison if ymin!=-1 and j<ymin
      if (ymin!=-1 && j<ymin) continue;
 
      double content= histogram -> GetBinContent(i,j);
      if ( CompareBinThreshold(m_name, content, bin_threshold )) {
    ++count;
          resulthisto->SetBinContent(i,j,content);
      if (publish && count< maxpublish){
           dqm_algorithms::tools::PublishBin(histogram,i,j,content,result);
      }
      }
    }
  }
 
  ERS_DEBUG(1,"Number of bins " << m_name << " treshold of " << bin_threshold << " is " << count );
  ERS_DEBUG(1,"Green threshold: "<< gthreshold << " bin(s);   Red threshold : " << rthreshold << " bin(s) ");    
  
  int TotalBins = (int) dqm_algorithms::tools::GetFirstFromMap( "TotalBins", config.getParameters() , -99999);
  if(TotalBins > -10){
    if(TotalBins < 0) TotalBins = histogram->GetNbinsX()*histogram->GetNbinsY()*histogram->GetNbinsZ();
    int effectiveCount = count - (histogram->GetNbinsX()*histogram->GetNbinsY()*histogram->GetNbinsZ() - TotalBins);
    if(m_name.find("LessThan")!=std::string::npos) result->tags_["NBins_%"] = 100.*effectiveCount/TotalBins;
    else result->tags_["NBins_%"] = 100.*count/TotalBins;
  }
 
  result->tags_["NBins"] = count;
  result->object_ =  boost::shared_ptr<TObject>(resulthisto);
  if (gthreshold > rthreshold) {
     if ( count >= gthreshold ) {
        result->status_ = dqm_core::Result::Green;
     } else if ( count > rthreshold ) {
        result->status_ = dqm_core::Result::Yellow;
     } else {
        result->status_ = dqm_core::Result::Red;
     }
  } else {
     if ( count <= gthreshold ) {
        result->status_ = dqm_core::Result::Green;
     } else if ( count < rthreshold ) {
        result->status_ = dqm_core::Result::Yellow;
     } else {
        result->status_ = dqm_core::Result::Red;
     }
  }
  
  return result;
  
}
 
bool
dqm_algorithms::BinThreshold::CompareBinThreshold(const std::string & type, double bincontent, double threshold) {
  
  if (type == "GreaterThan") return (bincontent > threshold);
  if (type == "GreaterThanAbs") return (std::abs(bincontent) > threshold);
  if (type == "GreaterThanNonZeroMedian") return (bincontent > threshold);
  if (type == "LessThan") return (bincontent < threshold);
  if (type == "LessThanAbs") return (std::abs(bincontent) < threshold);
  if (type == "LessThanNonZeroMedian") return (bincontent < threshold);
  if (type == "LessThanEqual") return (bincontent <= threshold);
  if (type == "GreaterThanEqual") return (bincontent >= threshold);
  if (type == "Equal") return (bincontent == threshold);
  if (type == "NotEqual") return (bincontent != threshold);
 
  return 0;
}
 
void dqm_algorithms::BinThreshold::parseVetoList(const std::string& input, std::vector<int>& rows, std::vector<int>& columns, std::vector<std::vector<int>>& bins) {
 
  std::string inputNoQuotes;
  for (char c : input) if (c != '"') inputNoQuotes += c;
 
  std::stringstream ss(inputNoQuotes);
  std::string token;
 
  while (std::getline(ss, token, ',')) {
    std::stringstream pairStream(token);
    std::string first, second;
 
    if (std::getline(pairStream, first, ':') && std::getline(pairStream, second, ':')) {
      if (first == "*") {
    rows.push_back(std::stoi(second));
      } else if (second == "*") {
    columns.push_back(std::stoi(first));
      } else {
    bins.push_back({std::stoi(first), std::stoi(second)});
      }
    }
  }
}
 
void
dqm_algorithms::BinThreshold::printDescription(std::ostream& out)
{
  
  out<<"Bins_"+m_name+"_Threshold: Checks for number of bins "+m_name+" threshold value\n"<<std::endl;
  
  out<<"Mandatory Parameter: BinThreshold: Look for bins "+m_name+" BinTreshold; Count number of bins satifying requirement \n"<<std::endl;
  
  out<<"Mandatory Green/Red Threshold: NBins: Number of bins satifying "+m_name+" BinThreshold constraint to give Green/Red result\n"<<std::endl;
  
  out<<"Optional Parameter: PublishBins: Save bins which are different from average in Result (set to 1)\n"<<std::endl; 
  out<<"Optional Parameter: MaxPublish: Max number of bins to save (default 20)"<<std::endl; 
  out<<"Optional Parameter: MinStat: Minimum histogram statistics needed to perform Algorithm"<<std::endl;
  out<<"Optional Parameter: xmin: minimum x range"<<std::endl;
  out<<"Optional Parameter: xmax: maximum x range"<<std::endl;
  out<<"Optional Parameter: ymin: minimum y range"<<std::endl;
  out<<"Optional Parameter: ymax: maximum y range\n"<<std::endl;
  out<<"Optional Parameter: ignoreBins: list of bins to ignore in the threshold comparison (x,y) in a string, separated by comas and semicolons. Ex: 1:3,6:7. It also allows to pass rows and columns like *:4 and *:4 respectively \n"<<std::endl;
  
}