dqm_algorithms::ZDCTestConstantVsLB Class Reference

#include <ZDCTestConstantVsLB.h>

Inheritance diagram for dqm_algorithms::ZDCTestConstantVsLB:

Collaboration diagram for dqm_algorithms::ZDCTestConstantVsLB:

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

Protected Attributes
std::string	m_name

Detailed Description

Definition at line 16 of file ZDCTestConstantVsLB.h.

Constructor & Destructor Documentation

ZDCTestConstantVsLB()

dqm_algorithms::ZDCTestConstantVsLB::ZDCTestConstantVsLB

(

)

Definition at line 43 of file ZDCTestConstantVsLB.cxx.

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

~ZDCTestConstantVsLB()

dqm_algorithms::ZDCTestConstantVsLB::~ZDCTestConstantVsLB ( )

virtual

Definition at line 51 of file ZDCTestConstantVsLB.cxx.

    {
    }

Member Function Documentation

clone()

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

virtual

Definition at line 58 of file ZDCTestConstantVsLB.cxx.

    {
        return new ZDCTestConstantVsLB(*this);
    }

execute()

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

virtual

Definition at line 66 of file ZDCTestConstantVsLB.cxx.

    {
        //No status flags are set
        dqm_core::Result* result = new dqm_core::Result();
        result->status_ = dqm_core::Result::Undefined;
            const TH2 * histogram;
  
                if( object.IsA()->InheritsFrom( "TH2" ) ) {
                 histogram = static_cast<const TH2*>(&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 TH2" );
                }
 
            TProfile *profile = histogram->ProfileX();
            TH1 *projection = histogram->ProjectionX("projection");
                int Xbins = histogram->GetXaxis()->GetNbins();
 
        float minstat = dqm_algorithms::tools::GetFirstFromMap( "MinStat", config.getParameters(), 100);
        float NsigYellow = dqm_algorithms::tools::GetFirstFromMap( "NsigYellow", config.getParameters(), 5);
        float NsigMultRed = dqm_algorithms::tools::GetFirstFromMap( "NsigMultRed", config.getParameters(), 10);
                
                bool redflag = false;
                bool yellowflag = false;
                bool greenflag = true; // if nothing goes wrong, return green
 
        TGraphErrors* ge = new TGraphErrors;
        int nge =0;
        for (int ilb = 0; ilb<Xbins ;ilb++)
          {
            if (projection->GetBinContent(ilb+1) >= minstat)
              {
            ge->SetPoint(nge,ilb,profile->GetBinContent(ilb+1));
            ge->SetPointError(nge,ilb,profile->GetBinError(ilb+1));
            nge++;
              }
          }
 
        TFitResultPtr fit_res = ge->Fit("pol0","QNS0");
        if (!fit_res.Get())
          {
            result->status_ = dqm_core::Result::Yellow;
            return result;
          }
        
        double mean = fit_res->Value(0);
 
        std::vector<int> yellowLBs;
        std::vector<double> yellowR;
        for (int ip = 0; ip<ge->GetN() ;ip++)
          {
            double x,y;
            ge->GetPoint(ip,x,y);
            double ey = ge->GetErrorY(ip);
            double r = TMath::Abs(( y - mean ) / ey); // number of sigma from const mean, use only pointwise error
            if (r>NsigYellow)
              {
            yellowflag = true;
            yellowLBs.push_back(x); // store LB
            yellowR.push_back(r); // store R
              }
          }
 
        for (size_t iy=0;iy<yellowLBs.size();iy++)
          {
            int LB = yellowLBs.at(iy);
            double R = yellowR.at(iy);
            char ctag[256];
            sprintf(ctag,"Bad LB %d with R", LB);
            result->tags_[ctag] = R;
          }
        
        if (yellowLBs.size() > NsigMultRed)
          {
            redflag = true;
          }
        
        if (redflag)
          {
            result->status_ = dqm_core::Result::Red;
          }
        else if (yellowflag)
          {
            result->status_ = dqm_core::Result::Yellow;
          }
        else if (greenflag)
          {
            result->status_ = dqm_core::Result::Green;
          }
 
        return result;
    }

printDescription()

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

virtual

Definition at line 29 of file ZDCTestConstantVsLB.cxx.

    {
        std::string message;
        message += "\n";
        message += "Algorithm: \"" + m_name + "\"\n";
        message += "Description: Calculates the mean of the LB dependence\n";
        message += "A constant fit is performed, for bins with minimum statistics, and outliers are reported.  Yellow is for any 5 sigma deviations, red is for 10 or more\n";
        message += "             Overflow (and Underflow) bins are not included\n";
        message += "\n";
        
        out << message;
    }

Member Data Documentation

m_name

std::string dqm_algorithms::ZDCTestConstantVsLB::m_name

protected

Definition at line 30 of file ZDCTestConstantVsLB.h.

---

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

• ZDCTestConstantVsLB.h
• ZDCTestConstantVsLB.cxx