dqm_algorithms::TRTWeightedAverage Struct Reference

#include <TRTWeightedAverage.h>

Inheritance diagram for dqm_algorithms::TRTWeightedAverage:

Collaboration diagram for dqm_algorithms::TRTWeightedAverage:

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

Detailed Description

Definition at line 14 of file TRTWeightedAverage.h.

Constructor & Destructor Documentation

TRTWeightedAverage()

dqm_algorithms::TRTWeightedAverage::TRTWeightedAverage

(

)

Definition at line 21 of file TRTWeightedAverage.cxx.

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

~TRTWeightedAverage()

dqm_algorithms::TRTWeightedAverage::~TRTWeightedAverage

(

)

Definition at line 26 of file TRTWeightedAverage.cxx.

{
}

Member Function Documentation

clone()

dqm_algorithms::TRTWeightedAverage * dqm_algorithms::TRTWeightedAverage::clone

(

)

Definition at line 30 of file TRTWeightedAverage.cxx.

{
    return new TRTWeightedAverage();
}

execute()

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

Definition at line 35 of file TRTWeightedAverage.cxx.

{
    const TH1 * histogram;
    const TH1 * refhist;
 
    if (object.IsA()->InheritsFrom("TH1")) {
        histogram = static_cast<const TH1*>(&object);
        if (histogram->GetDimension() > 1) {
            throw dqm_core::BadConfig(ERS_HERE, name, "dimension > 1");
        }
    } 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 firstbin = dqm_algorithms::tools::GetFirstFromMap("FirstBin", config.getParameters(), -1);
    const double lastbin = dqm_algorithms::tools::GetFirstFromMap("LastBin", config.getParameters(), -1);
    const double expectedaverage = dqm_algorithms::tools::GetFirstFromMap("ExpectedAverage", config.getParameters(), -1);
    const double p0 =  dqm_algorithms::tools::GetFirstFromMap("P0", config.getParameters(), -1);
    const double p1 =  dqm_algorithms::tools::GetFirstFromMap("P1", config.getParameters(), -1);
    const double correctusingbin1 = dqm_algorithms::tools::GetFirstFromMap("CorrectUsingBin1", config.getParameters(), -1);
    
    if (histogram->GetEntries() < minstat) {
        dqm_core::Result *result = new dqm_core::Result(dqm_core::Result::Undefined);
        result->tags_["InsufficientEntries"] = histogram->GetEntries();
        return result;
    }
 
    if (firstbin>lastbin){
        dqm_core::Result *result = new dqm_core::Result(dqm_core::Result::Undefined);
        result->tags_["Range_is_not_correct "] = 1;
        return result;
    }
 
    if (firstbin<0){
        dqm_core::Result *result = new dqm_core::Result(dqm_core::Result::Undefined);
        result->tags_["Range_is_not_correct "] = 2;
        return result;
    }
    
    if (lastbin > histogram->GetNbinsX()){
        dqm_core::Result *result = new dqm_core::Result(dqm_core::Result::Undefined);
        result->tags_["Range_is_not_correct "] = 3;
        return result;
    }
    
    try {
         refhist = dynamic_cast<const TH1*>( config.getReference() );
    }
    catch ( dqm_core::Exception & ex ) {
         throw dqm_core::BadRefHist(ERS_HERE,name," Could not retreive reference");
    }
 
    if (!refhist) {
         throw dqm_core::BadRefHist(ERS_HERE, name, "Reference is not a histogram");
    }
  
    if (histogram->GetDimension() != refhist->GetDimension() ) {
         throw dqm_core::BadRefHist( ERS_HERE, name, "Dimension" );
    }
  
    if ((histogram->GetNbinsX() != refhist->GetNbinsX()) || (histogram->GetNbinsY() != refhist->GetNbinsY())) {
         throw dqm_core::BadRefHist( ERS_HERE, name, "Non-matching number of bins of reference" );
    }
  
   std::map<std::string, double> results; // you can set flagging thresholds on any of these result tags
       
   double mean = 0;
   double sum = 0;
   double sumcontent = 0;
   double CorrectedMean= 0;
 
    for (int i = firstbin; i <= lastbin; ++i) {
        
        const double binContent = histogram->GetBinContent(i);
        const double binCenter = histogram->GetXaxis()->GetBinCenter(i);
        
        sum += binContent*binCenter;
        sumcontent += binContent;
    }
 
 
    if (sumcontent==0){
        dqm_core::Result *result = new dqm_core::Result(dqm_core::Result::Undefined);
        result->tags_["Content_is_zero "] = 1;
        return result;
    }
 
    mean = sum/sumcontent;
 
    if (correctusingbin1>0){
         double bin0=histogram->GetBinContent(1);
         double Nentries=histogram->GetEntries();
         double correctionfactor=bin0/Nentries;
         CorrectedMean= mean-(p0+p1*correctionfactor);
    }
 
    results["Weighted_mean"] = mean; 
    results["Abs_Diff"] = std::fabs(mean-expectedaverage);
    if (correctusingbin1>0){
         results["Corrected_Weighted_mean"]= CorrectedMean+expectedaverage;
         results["Corrected_Abs_Diff"]=std::fabs(CorrectedMean);
    }else{
         results["Corrected_Weighted_mean"]=0;
         results["Corrected_Abs_Diff"]=0;
    }
    //return result;
    return tools::MakeComparisons(results, config.getGreenThresholds(), config.getRedThresholds());
}

printDescription()

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

virtual

Definition at line 144 of file TRTWeightedAverage.cxx.

{
   //Modify following part:
   out << "TRTWeightedAverage: Calculates weighted average of the bins within the selected bin range. It is also possible to correct these results using the normalized value of the 0th bin. This is helpful for TRT drift time histogram. In the case of the correction algorithm expects the coefficients p0 and p1 such that (weighted_mean-p0-p1*normalized_firtbin_value) is 0 on the average. \n"
     "Optional parameter: MinStat :\n"
     "Optional parameter: FirstBin :\n"
     "Optional parameter: LastBin :\n"
     "Optional parameter: ExpectedAverage :\n"
     "Optional parameter: P0 :\n"
     "Optional parameter: P1 :\n"
     "Optional parameter: CorrectUsing0Bin :\n"
     "Returned values: \n"
     "  Weighted_mean: weighted average result for the selected bins. \n"     
     "  Abs_Diff: Absolute value of the difference between Weighted_mean and ExpectedAverage, fabs(Weighted_mean-ExpectedAverage) \n"
     "  Corrected_Weighted_mean:  Weighted_mean-(p0+p1*normalized_bin_0)+ExpectedAverage , 0 if CorrectUsing0Bin==0 \n"
     "  Corrected_Abs_Diff:  fabs(Weighted_mean-(p0+p1*normalized_bin_0)), 0 if CorrectUsing0Bin==0 \n"     
       << std::endl;
}

---

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

• TRTWeightedAverage.h
• TRTWeightedAverage.cxx