dqm_algorithms::MDTTubeCheckError Class Reference

#include <MDTTubeCheckError.h>

Inheritance diagram for dqm_algorithms::MDTTubeCheckError:

Collaboration diagram for dqm_algorithms::MDTTubeCheckError:

Public Member Functions
	MDTTubeCheckError ()
virtual	~MDTTubeCheckError ()
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 20 of file MDTTubeCheckError.h.

Constructor & Destructor Documentation

MDTTubeCheckError()

dqm_algorithms::MDTTubeCheckError::MDTTubeCheckError

(

)

Definition at line 37 of file MDTTubeCheckError.cxx.

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

~MDTTubeCheckError()

dqm_algorithms::MDTTubeCheckError::~MDTTubeCheckError ( )

virtual

Definition at line 44 of file MDTTubeCheckError.cxx.

{
}

Member Function Documentation

clone()

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

virtual

Definition at line 50 of file MDTTubeCheckError.cxx.

{
  return new MDTTubeCheckError(*this);
}

execute()

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

virtual

Definition at line 57 of file MDTTubeCheckError.cxx.

{
  const TH1* histogram;
  const TH1* refhist=0;
  
  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" );
  }   
  
  //Get Parameters and Thresholds
  double minstat; 
  double bin_threshold;
  double nErr;
  double LowStatErr;
  double LowStatThre;
  double refcheck;
  double greenTh;
  double redTh;
  try {
    bin_threshold = dqm_algorithms::tools::GetFirstFromMap( "BinThreshold", config.getParameters());
    nErr          = dqm_algorithms::tools::GetFirstFromMap( "nErrBin", config.getParameters());
    LowStatErr    = dqm_algorithms::tools::GetFirstFromMap( "LowStatErr", config.getParameters(), 99999.);
    LowStatThre   = dqm_algorithms::tools::GetFirstFromMap( "LowStatThre", config.getParameters(), 0.);
    refcheck      = dqm_algorithms::tools::GetFirstFromMap( "ReferenceCheck", config.getParameters());
    minstat       = dqm_algorithms::tools::GetFirstFromMap("MinStat", config.getParameters(), -1);
    redTh         = dqm_algorithms::tools::GetFromMap( "NBins", config.getRedThresholds());
    greenTh       = dqm_algorithms::tools::GetFromMap( "NBins", config.getGreenThresholds() );
  }
  catch ( dqm_core::Exception & ex ) {
    throw dqm_core::BadConfig( ERS_HERE, name, ex.what(), ex );
  }
 
  //Get Reference Histo
  if (refcheck>0) {
    try {
      refhist = static_cast<const TH1*>( config.getReference() );
    }
    catch ( dqm_core::Exception & ex ) {
      throw dqm_core::BadRefHist(ERS_HERE,name," Could not retreive reference");
    }
    if (histogram->GetDimension() != refhist->GetDimension() ) {
      throw dqm_core::BadRefHist( ERS_HERE, name, "Reference VS histo: Different dimension!" );
    } 
    if (histogram->GetNbinsX() != refhist->GetNbinsX() ) {
      throw dqm_core::BadRefHist( ERS_HERE, name, "Reference VS histo: Different number of bins!" );
    }
  }
    
 //Check of statistics
  if (histogram->GetEntries() < minstat ) {
    ERS_INFO("Histogram does not satisfy MinStat requirement " <<histogram->GetName());
    dqm_core::Result *result = new dqm_core::Result(dqm_core::Result::Undefined);
    result->tags_["InsufficientEntries"] = histogram->GetEntries();
    return result;
  }
  ERS_DEBUG(1,"Statistics: "<< histogram->GetEntries()<< " entries ");
 
  int count = 0;
  std::vector<int> range;
  if (histogram->GetDimension() == 1){
    range = dqm_algorithms::tools::GetBinRange(histogram, config.getParameters()); 
  } else {
    ERS_INFO("Histogram has not dimension 1 : " <<histogram->GetName());
    throw dqm_core::Exception( ERS_HERE, histogram->GetName() );
  }
  if (range[1] == 0) {
    ERS_INFO("Empty histogram: " <<histogram->GetName());
    dqm_core::Result* result = new dqm_core::Result(); 
    result->status_ = dqm_core::Result::Undefined; 
    ERS_DEBUG(1,"Undefined");
    return result;
  }
  
  std::vector<int> Tubes; 
  int EmptyTubes =0;
  int LowStatTubes =0;
  for ( int i = range[0]; i <= range[1]; ++i ) {
    double Content = histogram->GetBinContent(i);
    double ErrCont = histogram->GetBinError(i);
    if (ErrCont > LowStatErr) LowStatTubes++;
    if (Content+std::abs(ErrCont) != 0.) {
      if ((Content + nErr*ErrCont) < bin_threshold ) {
    if (refcheck>0) {
      double RefCont = refhist->GetBinContent(i);
      double RefErrCont = refhist->GetBinError(i);
      double Diff = std::abs(Content - RefCont);
      double ErrDiff = sqrt(ErrCont*ErrCont + RefErrCont*RefErrCont);
      if (Diff > nErr*ErrDiff) {
        ++count;
        Tubes.push_back(i);
      }
    } else {
      ++count;
      Tubes.push_back(i);
    }
      }
    } else { ++EmptyTubes; }
  }
  ERS_DEBUG(1,"Number of bins " << name << " different from a treshold of " << bin_threshold << " is " << count );
 
  dqm_core::Result* result = new dqm_core::Result(); 
  result->tags_["NChangedStatusTubes"] = count;
  if (Tubes.size()>0) {
    for (int k=0; k<(int)Tubes.size(); k++) {
      std::string ToDB="ChangedStatusTube_";
      ToDB += std::to_string(k+1);
      result->tags_[ToDB] = Tubes[k];
      ERS_DEBUG(1,"MDT Tube which changed status: "<<ToDB<<" = "<<Tubes[k] );
    }
  }
 
  if ((EmptyTubes == range[1]) || ((LowStatTubes/range[1]) > LowStatThre)) {
    result->status_ = dqm_core::Result::Undefined; 
    ERS_DEBUG(1,"Undefined");
  } else if (count >= redTh) {
    result->status_ = dqm_core::Result::Red; 
    ERS_DEBUG(1,"Red");
  } else if ( count > greenTh) {
    result->status_ = dqm_core::Result::Yellow;
    ERS_DEBUG(1,"Yellow");
  } else {
    result->status_ = dqm_core::Result::Green;
    ERS_DEBUG(1,"Green");
  }
  return result;
}

printDescription()

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

virtual

Definition at line 191 of file MDTTubeCheckError.cxx.

{
  std::string message;
  message += "\n";
  message += "Algorithm: \"" + m_name + "\"\n";
  message += "Description: Check if the number of entries in bins is less than BinThreshold and compare with Reference Histo \n";
  message += "Mandatory Parameter: BinThreshold: Look for bins less than BinTreshold; Count number of bins satifying requirement \n";
  message += "Mandatory Parameter: nErrBin: n-sigma of acceptance for check with the BinTreshold \n";
  message += "Mandatory Parameter: ReferenceCheck: 0 if no check on reference is requested \n";
  message += "Mandatory Green/Red Threshold: NBins: number of bins satifying requirement\n";
  message += "Optional Parameters: MinStat = Minimum histogram statistics needed to perform Algorithm\n";
  message += "                     LowStatErr = error threshold for bin with too low statistics \n";
  message += "                     LowStatThre = threshold for fraction of bins with too low statistics \n";
  message += "                     xmin: minimum x range\n";
  message += "                     xmax: maximum x range\n";
  message += "\n";
  
  out << message;
}

Member Data Documentation

m_name

std::string dqm_algorithms::MDTTubeCheckError::m_name

private

Definition at line 33 of file MDTTubeCheckError.h.

---

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

• MDTTubeCheckError.h
• MDTTubeCheckError.cxx