dqm_algorithms::DivideBin Struct Reference

#include <DivideBin.h>

Inheritance diagram for dqm_algorithms::DivideBin:

Collaboration diagram for dqm_algorithms::DivideBin:

Public Member Functions
	DivideBin ()
DivideBin *	clone ()
dqm_core::Result *	execute (const std::string &, const TObject &, const dqm_core::AlgorithmConfig &)
void	printDescription (std::ostream &out)

Detailed Description

Definition at line 18 of file DivideBin.h.

Constructor & Destructor Documentation

DivideBin()

dqm_algorithms::DivideBin::DivideBin

(

)

Definition at line 21 of file DivideBin.cxx.

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

Member Function Documentation

clone()

dqm_algorithms::DivideBin * dqm_algorithms::DivideBin::clone

(

)

Definition at line 28 of file DivideBin.cxx.

{
  
  return new DivideBin();
}

execute()

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

Definition at line 36 of file DivideBin.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" );
  }
  
 
  double gthresho;
  double rthresho;
  int xbin_num;
  int xbin_denom;
  try {
    xbin_num   = (int)dqm_algorithms::tools::GetFirstFromMap( "TestBin", config.getParameters());
    xbin_denom = (int)dqm_algorithms::tools::GetFirstFromMap( "RefBin", config.getParameters());
  }
  catch ( dqm_core::Exception & ex ) {
    throw dqm_core::BadConfig( ERS_HERE, name, ex.what(), ex );
  }
  
  try {
    gthresho = dqm_algorithms::tools::GetFromMap( "Threshold", config.getGreenThresholds() );
    rthresho = dqm_algorithms::tools::GetFromMap( "Threshold", config.getRedThresholds() );
  }
  catch ( dqm_core::Exception & ex ) {
    throw dqm_core::BadConfig(ERS_HERE,name,"Parameter: 'Threshold' is mandatory, cannot continue");
    
  }
  
  const double minstat = dqm_algorithms::tools::GetFirstFromMap( "MinStat", config.getParameters(), -1);
  
  const double minrefentries = dqm_algorithms::tools::GetFirstFromMap( "MinRefEntries", config.getParameters(), 1 );
  
  if (histogram->GetEntries() < minstat ) {
    dqm_core::Result *result = new dqm_core::Result(dqm_core::Result::Undefined);
    result->tags_["InsufficientEntries"] = histogram->GetEntries();
    return result;
  }
  
  // Get the denominator
  double hdenom = histogram->GetBinContent(xbin_denom);  
  
  if ( minrefentries > 0 && hdenom < minrefentries) {
    dqm_core::Result *result = new dqm_core::Result(dqm_core::Result::Undefined);
    result->tags_["InsufficientRefEntries"] = hdenom;
    return result;
  }
 
  // Get the numerator
  double hnum = histogram -> GetBinContent(xbin_num);
 
  double value = hnum/hdenom;
 
  dqm_core::Result* result = new dqm_core::Result();
  result->tags_["BinRatio"] = value;
  
if (rthresho < gthresho){
  if ( value >= gthresho ) {
    result->status_ = dqm_core::Result::Green;
  } else if (  value < rthresho ) {
    result->status_ = dqm_core::Result::Red;
  } else {
    result->status_ = dqm_core::Result::Yellow;
  }
} else {
  if ( value <= gthresho ) {
    result->status_ = dqm_core::Result::Green;
  } else if (  value > rthresho ) {
    result->status_ = dqm_core::Result::Red;
  } else {
    result->status_ = dqm_core::Result::Yellow;
  }
}
      
  return result;
}

printDescription()

void dqm_algorithms::DivideBin::printDescription

(

std::ostream &

out

)

Definition at line 122 of file DivideBin.cxx.

                                                              {
  out<<"DivideBin : Performs the division of a particular bin by the total entries in that histogram "<< std::endl;
  out<<"Optional Parameter : MinStat : Minimum histogram statistics needed to perform Algorithm"<< std::endl;
  out<<"Optional Parameter : MinRefEntries : Minimum number of entries in reference bin needed to perform Algorithm"<< std::endl;
  out<<"Mandatory parameter: TestBin: Index of the bin in x that should be tested\n"<< std::endl;
  out<<"Mandatory parameter: RefBin: Index of the bin in x that should be used as a reference\n"<< std::endl;
 
}

---

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

• DivideBin.h
• DivideBin.cxx