dqm_algorithms::MDTMLOverview Class Reference

#include <MDTMLOverview.h>

Inheritance diagram for dqm_algorithms::MDTMLOverview:

Collaboration diagram for dqm_algorithms::MDTMLOverview:

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

Private Attributes
std::string	m_name

Detailed Description

Definition at line 16 of file MDTMLOverview.h.

Constructor & Destructor Documentation

MDTMLOverview()

dqm_algorithms::MDTMLOverview::MDTMLOverview

(

)

Definition at line 42 of file MDTMLOverview.cxx.

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

~MDTMLOverview()

dqm_algorithms::MDTMLOverview::~MDTMLOverview ( )

virtual

Definition at line 49 of file MDTMLOverview.cxx.

{
}

Member Function Documentation

clone()

dqm_core::Algorithm * dqm_algorithms::MDTMLOverview::clone ( )

virtual

Definition at line 55 of file MDTMLOverview.cxx.

{
  return new MDTMLOverview(*this);
}

execute()

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

virtual

Definition at line 62 of file MDTMLOverview.cxx.

{
  const TH1 * hist;
  const TH1 * ref;
  
  if( object.IsA()->InheritsFrom( "TH1" ) ) {
    hist = static_cast<const TH1*>(&object);
    if (hist->GetDimension() >= 2 ){
      throw dqm_core::BadConfig( ERS_HERE, name, "dimension >= 2 " );
    }
  } else {
    throw dqm_core::BadConfig( ERS_HERE, name, "does not inherit from TH1" );
  }   
  
  //Get Parameters and Thresholds
  bool ref_y_n=0;
  double thresh; 
  double minstat; 
  double greenTh;
  double redTh;
  try {
    ref_y_n      = dqm_algorithms::tools::GetFirstFromMap("ref", config.getParameters(), 0);
    thresh       = dqm_algorithms::tools::GetFirstFromMap("thresh", config.getParameters());
    minstat      = dqm_algorithms::tools::GetFirstFromMap("MinStat", config.getParameters(), 50);
    redTh        = dqm_algorithms::tools::GetFromMap( "Limits", config.getRedThresholds());
    greenTh      = dqm_algorithms::tools::GetFromMap( "Limits", config.getGreenThresholds() );
  }
  catch ( dqm_core::Exception & ex ) {
    throw dqm_core::BadConfig( ERS_HERE, name, ex.what(), ex );
  }
 
  //Get Reference Histo
 
  try {
    ref = static_cast<const TH1*>( config.getReference() );
  }
  catch ( dqm_core::Exception & ex ) {
    throw dqm_core::BadRefHist(ERS_HERE,name," Could not retrieve reference");
  }
 
  if (hist->GetDimension() != ref->GetDimension() ) {
    throw dqm_core::BadRefHist( ERS_HERE, name, "Reference VS histo: Different dimension!" );
  } 
  if (hist->GetNbinsX() != ref->GetNbinsX() ) {
    throw dqm_core::BadRefHist( ERS_HERE, name, "Reference VS histo: Different bin number in X axis!" );
  } 
    
 //Check of statistics
  if (hist->GetEntries() < minstat ) {
    ERS_INFO("Histogram does not satisfy MinStat requirement " <<hist->GetName());
    dqm_core::Result *result = new dqm_core::Result(dqm_core::Result::Undefined);
    result->tags_["InsufficientEntries"] = hist->GetEntries();
    return result;
  }
  ERS_DEBUG(1,"Statistics: "<< hist->GetEntries()<< " entries ");
 
 
 //Algo
 
  int binX = hist->GetNbinsX();
  //double x_center=0;
 
  std::vector<int> hist_buffer;
  std::vector<int> ref_buffer;
  
  std::vector< double > new_empty_bins;
  int count=0;
 
  for(int x_index=1; x_index<=binX; x_index++){
    if( hist->GetBinContent(x_index) != 0 ) hist_buffer.push_back((int)hist->GetBinContent(x_index));
    if(ref_y_n==1) {
      if( ref->GetBinContent(x_index) != 0 ) ref_buffer.push_back((int)ref->GetBinContent(x_index));
    }
  };
  
  
 
  auto median=[](std::vector<int> & v)->int {
    const auto midPoint = v.begin()+v.size()/2;
    std::nth_element(v.begin(), midPoint, v.end());
    return v[v.size()/2];
  };
  
  
  double percentThreshold = thresh*0.01;
  const int mediana_hist = median(hist_buffer);
  
  if(ref_y_n==1) {
    const int mediana_ref = median(ref_buffer);
    for(int xi=1; xi<=binX; xi++){
      if( hist->GetBinContent(xi) < mediana_hist*percentThreshold && ref->GetBinContent(xi) >= mediana_ref*percentThreshold){
        count++;
        new_empty_bins.push_back(hist->GetBinCenter(xi));
      };
    };
  } else if(ref_y_n==0){ 
    for(int xi=1; xi<=binX; xi++){
      if( hist->GetBinContent(xi) < mediana_hist*percentThreshold){
        count++;
        new_empty_bins.push_back(hist->GetBinCenter(xi));
      };
    };
  };
 
  
  //double tot=binX;
  //if(ref_y_n==0) tot=binX;
 
 //Tag generator
 
  dqm_core::Result* result = new dqm_core::Result(); 
 
  std::string message;
  std::string eta="ETA_";
  std::string ml="__ML";
  char eta_num[3];
  std::string ml_num;
  double num_ml_off=1;
  int counter=0;
  
  int empty_bin_number=new_empty_bins.size();
 
  for(int i=0; i<empty_bin_number; i++){
    counter=-1;
    do{
      counter++;
      if(counter>=20) break;
    }while(std::abs(counter-new_empty_bins[i])>0.3);
      
    snprintf(eta_num,sizeof(eta_num),"%d",counter);
    if( (counter-new_empty_bins[i])>=0)ml_num="1";
    if( (counter-new_empty_bins[i])<0) ml_num="2";
    message=eta+(std::string)eta_num+ml+ml_num;
    result->tags_[message]=num_ml_off;
  };
 
 //Result
 
  result->tags_["00-number_of_off_ML"] = count;
 
  if (count<greenTh) {
    result->status_ = dqm_core::Result::Green; 
    ERS_DEBUG(1,"Green");
  } else if ( count>=greenTh && count<redTh ) {
    result->status_ = dqm_core::Result::Yellow;
    ERS_DEBUG(1,"Yellow");
  } else if (count>=redTh) {
    result->status_ = dqm_core::Result::Red;
    ERS_DEBUG(1,"Red");
  }
  return result;
}

printDescription()

void dqm_algorithms::MDTMLOverview::printDescription ( std::ostream & out )

virtual

Definition at line 217 of file MDTMLOverview.cxx.

{
  std::string message;
  message += "\n";
  message += "Algorithm: \"" + m_name + "\"\n";
  message += "Description: compare the histo with reference and check if there are any ML switched off\n";
  message += "Mandatory Green/Red Threshold: Limits: number of new ML switched off while are on in reference\n";
  message += "                     thresh  = % of the mean entries per ML under which the algo will set ML off\n";
  message += "Optional Parameters: MinStat = Minimum histogram statistics needed to perform Algorithm\n";
  message += "              ref     = Bool value: 1 if you want perform the check comparing with ref\n";
  message += "                                    0 if you want perform the check without the comparison with ref\n";
  message += "\n";
  
  out << message;
}

Member Data Documentation

m_name

std::string dqm_algorithms::MDTMLOverview::m_name

private

Definition at line 29 of file MDTMLOverview.h.

---

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

• MDTMLOverview.h
• MDTMLOverview.cxx