dqm_algorithms::BinsOutOfRange Struct Reference

#include <BinsOutOfRange.h>

Inheritance diagram for dqm_algorithms::BinsOutOfRange:

Collaboration diagram for dqm_algorithms::BinsOutOfRange:

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

Detailed Description

Definition at line 19 of file BinsOutOfRange.h.

Constructor & Destructor Documentation

BinsOutOfRange()

dqm_algorithms::BinsOutOfRange::BinsOutOfRange

(

)

Definition at line 26 of file BinsOutOfRange.cxx.

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

~BinsOutOfRange()

dqm_algorithms::BinsOutOfRange::~BinsOutOfRange

(

)

Definition at line 31 of file BinsOutOfRange.cxx.

{
}

Member Function Documentation

clone()

dqm_algorithms::BinsOutOfRange * dqm_algorithms::BinsOutOfRange::clone

(

)

Definition at line 36 of file BinsOutOfRange.cxx.

{
  
  return new BinsOutOfRange();
}

execute()

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

Definition at line 44 of file BinsOutOfRange.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 = dqm_algorithms::tools::GetFirstFromMap( "MinStat", config.getParameters(), -1);
  const double ignoreval = dqm_algorithms::tools::GetFirstFromMap( "ignoreval", config.getParameters(), -99999);
  const bool publish = (bool) dqm_algorithms::tools::GetFirstFromMap( "PublishBins", config.getParameters(), 1); 
  const int Nmaxpublish = (int) dqm_algorithms::tools::GetFirstFromMap( "MaxPublish", config.getParameters(), 20); 
  const double RANGE_D = dqm_algorithms::tools::GetFirstFromMap( "RANGE_D", config.getParameters(), -50);
  const double RANGE_U = dqm_algorithms::tools::GetFirstFromMap( "RANGE_U", config.getParameters(), 50);
  if ( histogram->GetEntries() < minstat ) {
    dqm_core::Result *result = new dqm_core::Result(dqm_core::Result::Undefined);
    result->tags_["InsufficientEntries"] = histogram->GetEntries();
    return result;
  }
  
  double gthreshold;
  double rthreshold;
  try {
    rthreshold = dqm_algorithms::tools::GetFromMap( "NbadBins", config.getRedThresholds() );
    gthreshold = dqm_algorithms::tools::GetFromMap( "NbadBins", config.getGreenThresholds() );
  }
  catch( dqm_core::Exception & ex ) {
    throw dqm_core::BadConfig( ERS_HERE, name, ex.what(), ex );
  }
  
  std::vector<int> range=dqm_algorithms::tools::GetBinRange(histogram, config.getParameters()); 
  std::vector<bin3> badbinstrip;
  for ( int k = range[0]; k <= range[1]; ++k ) {
    for ( int l = range[2]; l <= range[3]; ++l ) {
      double binvalue = histogram->GetBinContent(k,l);
      if (binvalue== ignoreval) continue;
      double eta = histogram->GetXaxis()->GetBinCenter(k);
      double phi = histogram->GetYaxis()->GetBinCenter(l); 
      if(binvalue > RANGE_D && binvalue < RANGE_U ) continue;
      bin3 onebin = {eta,phi,k,l,binvalue};
      badbinstrip.push_back(onebin);
    }    
  }
 
 std::sort(badbinstrip.begin(),badbinstrip.end(),mySortfunc); 
 dqm_core::Result* result = new dqm_core::Result();
// publish problematic bins
  int count=0;
  for(unsigned int i=0;i<badbinstrip.size();i++){
    if(publish){
      char tmp[500];
      sprintf(tmp,"%i-(eta,phi)=(%0.3f,%0.3f)",count,badbinstrip[i].m_eta,badbinstrip[i].m_phi);
      std::string tag = tmp;
      result->tags_[tag] = badbinstrip[i].m_value;
    }  
    count++;
    if(count>Nmaxpublish) break;
  }
 
  result->tags_["NBadBins"] = count;
 
  if(count>rthreshold ) result->status_ = dqm_core::Result::Red;
  else if (count>gthreshold) result->status_ = dqm_core::Result::Yellow;
       else result->status_ = dqm_core::Result::Green;
 
  return result;
  
}

printDescription()

void dqm_algorithms::BinsOutOfRange::printDescription

(

std::ostream &

out

)

Definition at line 122 of file BinsOutOfRange.cxx.

{
  
  out<<"BinsOutOfRange: Print out the badbins which are out of range [range_d,range_u] "<<std::endl;
  out<<"Optional Parameter: MinStat: Minimum histogram statistics needed to perform Algorithm"<<std::endl;
  out<<"Optional Parameter: ignoreval: valued to be ignored for being processed"<<std::endl; 
  out<<"Optional Parameter: MaxPublish: Max number of bins to save (default 20)"<<std::endl; 
  
}

---

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

• BinsOutOfRange.h
• BinsOutOfRange.cxx