TrimRangeTestResult.h

#ifndef SCTDATA_TRIMRANGETESTRESULT_H
#define SCTDATA_TRIMRANGETESTRESULT_H
#include <boost/shared_ptr.hpp>
#include <cmath>

#include "TestResult.h"
#include "Sct/Streamable.h"
#include "Stat.h"

class TGraph;

namespace SctData{

class TrimRangeTestResult : public TestResult {
public:
    TrimRangeTestResult() throw();
    
    TrimRangeTestResult(unsigned int runNumber, const string& moduleName) throw();
    
    // Destructor
    virtual ~TrimRangeTestResult() throw();
    
    //Override
    virtual string getClassName() const throw();
    
    class Trim : public Sct::Streamable {
    public:
    Trim(const short unsigned trim, const float vthr=0.) throw() : trim(trim), vthr(vthr) {;}
    short unsigned trim;
    float vthr;
    
    Trim& operator+= (const Trim& t) throw()    {trim+=t.trim ; vthr+=t.vthr; return *this;}
    Trim& operator/= (const unsigned i) throw()  {trim/=i;       vthr/=i;      return *this;}
    Trim operator- (const Trim& t) const throw() {return Trim(trim-t.trim , vthr-t.vthr); }
    Trim operator* (const Trim& t) const throw() {return Trim(trim*t.trim , vthr*t.vthr); }
    Trim() throw() : trim(0), vthr(0.) {;}
        virtual string getClassName() const throw();
    };
    
    class ChipTrim : public Sct::Streamable {
    public:
    ChipTrim() throw() : channelTrim(nChannelChip), target(0) {;}
    Stats<Trim> channelTrim;
    float target;
    short range;
    virtual string getClassName() const throw();
    };
    
    
    class TrimData : public Sct::Streamable {
    public:
    TrimData(float p0, float p1) throw() : p0(p0), p1(p0) {;}
    std::vector<std::pair<float, float> > graph;
    float p0;
    float p1;
    float getVthr(const short unsigned trim) const throw();
    int getTrim(const float vthr) const throw();

    TrimData& operator+= (const TrimData& d) throw()    { p0+=d.p0; p1+=d.p1; return *this;}
    TrimData& operator/= (const unsigned i) throw()     { p0/=i;    p1/=i;    return *this;}
    TrimData operator* (const TrimData& d) const throw() { return TrimData(p0*d.p0, p1*d.p1);}
    TrimData() throw() : p0(0), p1(0) {;}
    virtual string getClassName() const throw();
    };
    
    class ChipTrimData : public Sct::Streamable {
    public:
    ChipTrimData() throw() : 
        channelData(nChannelChip) {;}
    
    const Stats<double> getOffsets() const throw() ;
    const Stats<double> getSteps() const throw() ;
    void addDefects(shared_ptr<DefectList> list) {fitDefects=list ;}
    Stats<TrimData> channelData;
    boost::shared_ptr<DefectList> fitDefects;
    virtual std::string getClassName() const throw();
    };

    std::vector<boost::shared_ptr<const ChipTrimData> > chipTrimData;
    std::vector<boost::shared_ptr<const ChipTrim> > chipTrim;

    float charge;              
    short signed type;         
    short unsigned algorithm;  
};// end of TrimRangeTestResult class


//INLINES
    inline float TrimRangeTestResult::TrimData::getVthr(const short unsigned trim) const throw() {
    return (trim-p0) / p1;
    }

    inline int TrimRangeTestResult::TrimData::getTrim(const float vthr) const throw() {
    return static_cast<int>(floor((p0 + vthr * p1) + 0.5));
    }



} // end of namespace SctData

#endif //#ifndef SCTDATA_TRIMRANGETESTRESULT_H

---