#include <HLTMETStatus.h>

Inheritance diagram for dqm_algorithms::HLTMETStatus:

Collaboration diagram for dqm_algorithms::HLTMETStatus:

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

Private Attributes
std::string	m_name

Detailed Description

Definition at line 20 of file HLTMETStatus.h.

Constructor & Destructor Documentation

◆ HLTMETStatus()

dqm_algorithms::HLTMETStatus::HLTMETStatus ( )

Definition at line 35 of file HLTMETStatus.cxx.

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

Member Function Documentation

◆ clone()

dqm_algorithms::HLTMETStatus * dqm_algorithms::HLTMETStatus::clone ( )

Definition at line 42 of file HLTMETStatus.cxx.

{
  
  return new HLTMETStatus();
}

◆ execute()

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

Definition at line 50 of file HLTMETStatus.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" );
  }
  // Get Green and Red Thresholds
  double grThr = 0.05, reThr = 0.1; // Green and Red thresholds
  try {
    grThr = dqm_algorithms::tools::GetFromMap("Threshold",config.getGreenThresholds() );
    reThr = dqm_algorithms::tools::GetFromMap("Threshold",config.getRedThresholds() );
  } catch ( dqm_core::Exception & ex ) {
    throw dqm_core::BadConfig(ERS_HERE,name,"Paramter: 'Threshold' is mandatory, cannot continue");
  }
 
  //non sense case: compare fraction and threshold >100%
  if ((grThr>1.0 || reThr>1.0) ) {
    throw dqm_core::BadConfig(ERS_HERE,m_name,"Configuration Error: Threshold should be between [0.0, 1.0] 10% => 0.1");
  }
 
  // Get Parameters
  size_t ntotBins = (size_t) histogram -> GetNbinsX();
 
  // read thresholds
  size_t colflags[4];
  colflags[0] = static_cast<size_t>(dqm_algorithms::tools::GetFirstFromMap("METYellowMin", config.getParameters(), 1));
  colflags[1] = static_cast<size_t>(dqm_algorithms::tools::GetFirstFromMap("METYellowMax", config.getParameters(), ntotBins));
  colflags[2] = static_cast<size_t>(dqm_algorithms::tools::GetFirstFromMap("METRedMin",    config.getParameters(), 1));
  colflags[3] = static_cast<size_t>(dqm_algorithms::tools::GetFirstFromMap("METRedMax",    config.getParameters(), ntotBins));
  // read options
  bool doflags[2];
  doflags[0] = static_cast<bool>(dqm_algorithms::tools::GetFirstFromMap("DoYellowFlag", config.getParameters(), 1));
  doflags[1] = static_cast<bool>(dqm_algorithms::tools::GetFirstFromMap("DoRedFlag",    config.getParameters(), 1));
 
  dqm_core::Result* result = new dqm_core::Result();
  colflags[0] = ((colflags[0] > 0) && (colflags[0] <= ntotBins)) ? colflags[0] : 1;
  colflags[1] = ((colflags[1] >= colflags[0]) && (colflags[1] <= ntotBins)) ? colflags[1] : ntotBins;
  colflags[2] = ((colflags[2] > 0) && (colflags[2] <= ntotBins)) ? colflags[2] : 1;
  colflags[3] = ((colflags[3] >= colflags[2]) && (colflags[3] <= ntotBins)) ? colflags[3] : ntotBins;
  bool yellowLo2HiEmpty = true, redLo2HiEmpty = true;
  int ycnt = 0, rcnt = 0;
  
  // we fill 1(error) or 0(no-error) for each bin for every event
  // therefore we have to divide #of entries by #of bins
  // to get the #of events
  double nentries = histogram -> GetEntries(); 
  double nevtstot = 1.; // no. of events
  if(!std::isnan(nentries/ntotBins) || !std::isinf(nentries / ntotBins)) nevtstot = nentries/ntotBins;
 
  // yellow flag
  double theYFracMax = -9., theRFracMax = -9.;
  if(doflags[0]) {
    for( size_t j = colflags[0]; j <= colflags[1]; j++ ) {
      // if at least one of the bins > 0 : flag = YELLOW
      double thebinc = histogram -> GetBinContent(j);
      // fraction of events having this error-bit set
      double thefrac = thebinc / nevtstot; 
 
      // "Worst-case flag not to exceed YELLOW" flag:
      // if threshold exceeds green threshold, set yellow
      // if threshold exceeds red threshold, still set yellow
      // reThr > grThr
      if(thefrac > grThr)  { 
        if(theYFracMax < thefrac) theYFracMax = thefrac;
        yellowLo2HiEmpty = false;
        ycnt ++; 
      }
    }
  }
 
  // red flag
  if(doflags[1]) {
    for( size_t j = colflags[2]; j <= colflags[3]; j++ ) {
      // if at least one of the bins > 0 : flag = RED
      double thebinc = histogram -> GetBinContent(j);
      // fraction of events having this error-bit set
      double thefrac = thebinc / nevtstot; 
      if(thefrac > reThr)  { 
        if(theRFracMax < thefrac) theRFracMax = thefrac;
        redLo2HiEmpty = false;
        rcnt++;
      } 
    }
  }
 
  // set results
  result->status_ = dqm_core::Result::Green;
 
  if(doflags[0] && !yellowLo2HiEmpty) {
    result->status_ = dqm_core::Result::Yellow;
  }
 
  if(doflags[1] && !redLo2HiEmpty) {
    result->status_ = dqm_core::Result::Red;
  }
 
  result->tags_["NumOfStatusBitsYellow"] = ycnt; 
  result->tags_["EventFractionYellow"] = theYFracMax; 
  result->tags_["NumOfStatusBitsRed"] = rcnt;
  result->tags_["EventFractionRed"] = theRFracMax;
 
  
  return result;
}

◆ printDescription()

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

Definition at line 168 of file HLTMETStatus.cxx.

{
  
  out<<"HLT MET Status: Of the 32 status bits, check if any subset of bits are set. If so, flag YELLOW" << std::endl;
  out<<"Bit #32 is global error bit, if set flag RED." << std::endl;
  
  out<<"Mandatory parameter: XBin: The label of the X bin that you would like to check\n"<<std::endl;
  
}

Member Data Documentation

◆ m_name

std::string dqm_algorithms::HLTMETStatus::m_name

private

Definition at line 31 of file HLTMETStatus.h.

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

Public Member Functions

Private Attributes