dqm_algorithms::TileBinsOutRange Class Reference

#include <TileBinsOutRange.h>

Inheritance diagram for dqm_algorithms::TileBinsOutRange:

Collaboration diagram for dqm_algorithms::TileBinsOutRange:

Public Member Functions
	TileBinsOutRange ()
virtual	~TileBinsOutRange ()=default
virtual TileBinsOutRange *	clone () override
virtual dqm_core::Result *	execute (const std::string &name, const TObject &object, const dqm_core::AlgorithmConfig &config) override
void	printDescription (std::ostream &out)

Private Attributes
std::string	m_name

Detailed Description

Definition at line 13 of file TileBinsOutRange.h.

Constructor & Destructor Documentation

TileBinsOutRange()

dqm_algorithms::TileBinsOutRange::TileBinsOutRange

(

)

Definition at line 22 of file TileBinsOutRange.cxx.

                                  : m_name("TileBinsOutRange") {
  dqm_core::AlgorithmManager::instance().registerAlgorithm(m_name, this);
}

~TileBinsOutRange()

virtual dqm_algorithms::TileBinsOutRange::~TileBinsOutRange ( )

virtualdefault

Member Function Documentation

clone()

TileBinsOutRange * dqm_algorithms::TileBinsOutRange::clone ( )

overridevirtual

Definition at line 27 of file TileBinsOutRange.cxx.

                                          {
  return new TileBinsOutRange();
}

execute()

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

overridevirtual

Definition at line 32 of file TileBinsOutRange.cxx.

                                                                                         {
 
  const TH1* histogram = nullptr;
 
  if(object.IsA()->InheritsFrom( "TH1" )) {
    histogram = static_cast<const TH1*>(&object);//type already checked in preceding line
    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 TH2");
  }
 
  const bool publish = static_cast<bool>(dqm_algorithms::tools::GetFirstFromMap( "PublishBins", config.getParameters(), 0));
  const bool publishHistogram = static_cast<bool>(dqm_algorithms::tools::GetFirstFromMap( "PublishHistogram", config.getParameters(), 1));
  const int maxPublish = static_cast<int>(dqm_algorithms::tools::GetFirstFromMap( "MaxPublish", config.getParameters(), 20));
  const double minStat = dqm_algorithms::tools::GetFirstFromMap( "MinStat", config.getParameters(), -1);
  const double ignoreValue = dqm_algorithms::tools::GetFirstFromMap( "IgnoreValue", config.getParameters(), -99999);
 
  const TProfile* profile(nullptr);
  const TProfile2D* profile2D(nullptr);
  const double minBinEntries = dqm_algorithms::tools::GetFirstFromMap( "MinBinEntries", config.getParameters(), -1);
  if(minBinEntries > 0) {
   if (object.InheritsFrom("TProfile"))        profile   = dynamic_cast<const TProfile*>(&object);
   else if (object.InheritsFrom("TProfile2D")) profile2D = dynamic_cast<const TProfile2D*>(&object);
  }
 
  if (histogram->GetEntries() < minStat ) {
    dqm_core::Result *result = new dqm_core::Result(dqm_core::Result::Undefined);
    result->tags_["InsufficientEntries"] = histogram->GetEntries();
    return result;
  }
 
  double minValue;
  double maxValue;
  double redThreshold;
  double greenThreshold;
  try {
    minValue = dqm_algorithms::tools::GetFromMap( "MinValue", config.getGreenThresholds() );
    maxValue = dqm_algorithms::tools::GetFromMap( "MaxValue", config.getGreenThresholds() );
    greenThreshold = dqm_algorithms::tools::GetFromMap("NBins", config.getGreenThresholds());
    redThreshold = dqm_algorithms::tools::GetFromMap("NBins", config.getRedThresholds());
  } catch( dqm_core::Exception & ex ) {
    throw dqm_core::BadConfig( ERS_HERE, name, ex.what(), ex );
  }
 
  TH1* resultHistogram = nullptr;
  if (publishHistogram) {
    if (histogram->InheritsFrom("TH1")) {
      resultHistogram = static_cast<TH1*>(histogram->Clone());//type already checked
    } else {
      throw dqm_core::BadConfig( ERS_HERE, name, "does not inherit from TH1" );
    }
    resultHistogram->Reset();
  }
 
  int nBins = 0;
  int nSkippedBins = 0;
  dqm_core::Result* result = new dqm_core::Result();
  std::vector<int> range = dqm_algorithms::tools::GetBinRange(histogram, config.getParameters());
  for (int i = range[0]; i <= range[1]; ++i) {
    for (int j = range[2]; j <= range[3]; ++j) {
 
      if (minBinEntries > 0) {
        int bin = histogram->GetBin(i, j);
        if (profile) {
          if (profile->GetBinEntries(bin) < minBinEntries) {
            ++nSkippedBins;
            continue;
          }
        } else if (profile2D) {
          if (profile2D->GetBinEntries(bin) < minBinEntries) {
            ++nSkippedBins;
            continue;
          }
        }
      }
 
      double binValue = histogram->GetBinContent(i, j);
      if((binValue == ignoreValue) || (binValue > minValue && binValue < maxValue )) continue;
 
      ++nBins;
      if (resultHistogram){
        resultHistogram->SetBinContent(i, binValue);
        if (publish && nBins < maxPublish) {
          dqm_algorithms::tools::PublishBin(histogram, i, 0, binValue, result);
        }
      }
    }
  }
 
  ERS_DEBUG(1,"Number of bad bins is " << nBins );
  ERS_DEBUG(1,"Green threshold: " << greenThreshold << " bin(s);   Red threshold : " << redThreshold << " bin(s) ");
 
  result->tags_["NBins"] = nBins;
  result->tags_["NSkippedBins"] = nSkippedBins;
  if (resultHistogram) result->object_ = boost::shared_ptr<TObject>(resultHistogram);
 
  if (greenThreshold > redThreshold) {
    if (nBins >= greenThreshold) {
      result->status_ = dqm_core::Result::Green;
    } else if (nBins > redThreshold) {
      result->status_ = dqm_core::Result::Yellow;
    } else {
      result->status_ = dqm_core::Result::Red;
    }
  } else {
    if (nBins <= greenThreshold) {
      result->status_ = dqm_core::Result::Green;
    } else if (nBins < redThreshold) {
      result->status_ = dqm_core::Result::Yellow;
    } else {
      result->status_ = dqm_core::Result::Red;
    }
  }
 
  return result;
}

printDescription()

void dqm_algorithms::TileBinsOutRange::printDescription

(

std::ostream &

out

)

Definition at line 153 of file TileBinsOutRange.cxx.

                                                       {
 
  out << m_name << ": Check number of bins which are out of range (MinValue, MaxValue) " << std::endl;
  out << "Mandatory Green Threshold: MinValue: minimum value of range" << std::endl;
  out << "Mandatory Green Threshold: MaxValue: maximum value of range" << std::endl;
  out << "Mandatory Green/Red Threshold: NBins: Number of non-empty bins to give Green/Red result\n" << std::endl;
  out << "Optional Parameter: MinStat: Minimum histogram statistics needed to perform Algorithm" << std::endl;
  out << "Optional Parameter: IgnoreValue: valued to be ignored for being processed" << std::endl;
  out << "Optional Parameter: MaxPublish: Max number of bins to save (default 20)" << std::endl;
  out << "Optional Parameter: MinBinEntries: Minimum bin entries in profile histogram needed to check this bin (by default: -1)" << std::endl;
 
}

Member Data Documentation

m_name

std::string dqm_algorithms::TileBinsOutRange::m_name

private

Definition at line 24 of file TileBinsOutRange.h.

---

The documentation for this class was generated from the following files:

• TileBinsOutRange.h
• TileBinsOutRange.cxx