dqm_algorithms::EfficiencyRefComp Struct Reference

#include <EfficiencyRefComp.h>

Inheritance diagram for dqm_algorithms::EfficiencyRefComp:

Collaboration diagram for dqm_algorithms::EfficiencyRefComp:

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

Detailed Description

Definition at line 14 of file EfficiencyRefComp.h.

Constructor & Destructor Documentation

EfficiencyRefComp()

dqm_algorithms::EfficiencyRefComp::EfficiencyRefComp

(

)

Definition at line 20 of file EfficiencyRefComp.cxx.

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

Member Function Documentation

clone()

dqm_algorithms::EfficiencyRefComp * dqm_algorithms::EfficiencyRefComp::clone

(

)

Definition at line 24 of file EfficiencyRefComp.cxx.

                                                                       {
  return new EfficiencyRefComp();
}

execute()

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

Definition at line 28 of file EfficiencyRefComp.cxx.

                                                                                                                                           {
  const TH1 * histogram;
 
  if( object.IsA()->InheritsFrom( "TH1" ) ) {
    histogram = static_cast<const TH1*>(&object);
  } 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); 
  
 
  if (histogram->GetEntries() < minstat ) {
    dqm_core::Result *result = new dqm_core::Result(dqm_core::Result::Undefined);
    result->tags_["InsufficientEffectiveEntries"] = histogram->GetEffectiveEntries();
    return result;
  }
 
  TObject* ro = config.getReference();
  const TObject* firstReference=0;
  TObject* secondReference=0;
  try { 
    dqm_algorithms::tools::handleReference( *ro , firstReference , secondReference );
  }catch ( dqm_core::Exception & ex ) {
    throw dqm_core::BadRefHist(ERS_HERE,name," Could not retreive reference");
  }
 
  //Check the reference
  const TH1* refhist = dynamic_cast<const TH1*>(firstReference);
  if ( refhist==0 ){
    throw dqm_core::BadRefHist( ERS_HERE, "Dimension", name );
  }
 
  if ((histogram->GetDimension() != refhist->GetDimension()) || (histogram->GetNbinsX() != refhist->GetNbinsX()) || (histogram->GetNbinsY() != refhist->GetNbinsY()) || refhist->GetNbinsZ() != histogram->GetNbinsZ() ) {
    throw dqm_core::BadRefHist( ERS_HERE, "number of bins", name );
  }
 
  //get range of input histograms
  std::vector<int> range=dqm_algorithms::tools::GetBinRange(histogram, config.getParameters()); 
 
  //get config
  bool check_bin_err = (dqm_algorithms::tools::GetFirstFromMap("CheckBinErr", config.getParameters(), -1) > 0); //if the bin diff < err on bin ignore it
  double posMaxDiff = dqm_algorithms::tools::GetFirstFromMap("PosMaxDiff", config.getParameters(), 1.0);
  double negMaxDiff = dqm_algorithms::tools::GetFirstFromMap("NegMaxDiff", config.getParameters(), 1.0);
 
  int count = 0;
 
  dqm_core::Result* result = new dqm_core::Result();
  TH1* resulthisto;
  resulthisto=(TH1*)(histogram->Clone());
  resulthisto->Reset();
 
  //loop over each bin and calulcate the difference from the reference
  for(int i=range[0]; i< range[1]; i++){
    double binContent = histogram->GetBinContent(i);
    double refContent = refhist->GetBinContent(i);
    double binErr = histogram->GetBinError(i);
 
    if(std::abs(binContent - refContent) < binErr && check_bin_err){
      //difference between ref and bin content is less than 1 sigma
      continue;
    }
 
    double diff = binContent - refContent;
    double adiff = std::abs(diff);
    double threshold = 1000;
 
    if(diff < 0){
      threshold = negMaxDiff;
    }else{
      threshold = posMaxDiff;
    }
 
    if(adiff > threshold){
      //bin differs from reference by more than threshold
      count++;
      resulthisto->SetBinContent(i, binContent);
      if (publish && count< maxpublish){
        dqm_algorithms::tools::PublishBin(histogram,i,0,binContent,result);
      }
    }
  }
 
  result->tags_["NBins"] = count;
  result->object_ =  boost::shared_ptr<TObject>(resulthisto);
 
  double rthreshold = dqm_algorithms::tools::GetFromMap( "NBins", config.getRedThresholds() );
  double gthreshold = dqm_algorithms::tools::GetFromMap( "NBins", config.getGreenThresholds() );
 
  if(count >= rthreshold){
    result->status_ = dqm_core::Result::Red;
  }else if(count <= gthreshold){
    result->status_ = dqm_core::Result::Green;
  }else{
    result->status_ = dqm_core::Result::Yellow;
  }
 
  return result;
}

printDescription()

void dqm_algorithms::EfficiencyRefComp::printDescription

(

std::ostream &

out

)

Definition at line 132 of file EfficiencyRefComp.cxx.

                                                                      {
  out<<"EfficiencyRefComp_: Compares each bin to the reference bin and calculates the difference. The difference for each bin is then compared to a threshold value. Different thresholds are supported for bins > ref and < ref."<<std::endl;
}

---

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

• EfficiencyRefComp.h
• EfficiencyRefComp.cxx