ResponseCurve.h

#ifndef RESPONSECURVE_H
#define RESPONSECURVE_H

#include "Sct/Streamable.h"
#include "Sct/Exception.h"
#include "Sct/LogicErrors.h"
#include <map>
#include <TF1.h>
#include <boost/utility.hpp>
#include <boost/shared_ptr.hpp>

using std::map;
using std::auto_ptr;
using std::string;

using namespace Sct;
using namespace boost;

namespace SctData {
    class ChipConfiguration;
class ResponseCurve : public virtual Streamable {
 public:
    shared_ptr<TF1> getFunction() const throw() ;
    virtual shared_ptr<TF1> getInverseFunction() const throw(LogicError) = 0;
    const int getIndex() const throw();
    virtual double getGain(const double charge) const throw() = 0;
    virtual auto_ptr<ResponseCurve> create() const throw() = 0 ;
    virtual ~ResponseCurve() throw();
    ResponseCurve& operator=(const ResponseCurve&) throw();
    bool operator==(const ResponseCurve&)const throw();
    virtual string getClassName() const throw() {return "SctData::ResponseCurve";}
    virtual string getCurveName() const throw() {return "Unknown Response Curve";}
private:
    ResponseCurve();
    shared_ptr<TF1> ptr_function;
protected:
    mutable shared_ptr<TF1> ptr_inverse;
    ResponseCurve(auto_ptr<TF1>) throw(LogicError);
};

    class ResponseCurveMap : boost::noncopyable {
    public:
    bool addToMap(const string& curvename, const int index, ResponseCurve&) throw() ;
    static ResponseCurveMap& getMap() throw();
    auto_ptr<ResponseCurve> get(const string& curvename) const throw(LogicError);
    auto_ptr<ResponseCurve> get(const int index) const throw(LogicError);
    auto_ptr<ResponseCurve> get(const ChipConfiguration& chip) const throw(LogicError);
    int getIndex(const string& curvename) const throw(LogicError);
    private:
    map<int, ResponseCurve*> indexMap;
    map<string, int> nameMap;
    };


    class LinearResponseCurve : public ResponseCurve {
    public:
    LinearResponseCurve() throw(LogicError);
    virtual ~LinearResponseCurve() throw();
    virtual shared_ptr<TF1> getInverseFunction() const throw(LogicError);
    virtual double getGain(const double charge) const throw();
    virtual string getCurveName() const throw() {return "LinearResponseCurve";}
    virtual auto_ptr<ResponseCurve> create() const throw();
    static bool inMap; 

    static double linFn(double *x, double *par) throw();
    static double invLinFn(double *x, double *par) throw();
    int m_deb;
    };
    
    class ExponentialResponseCurve : public ResponseCurve {
    public:
    ExponentialResponseCurve() throw(LogicError);
    virtual ~ExponentialResponseCurve() throw(){;}
    virtual shared_ptr<TF1> getInverseFunction() const throw(LogicError);
    virtual double getGain(const double charge) const throw();
    virtual string getCurveName() const throw() {return "ExponentialResponseCurve";}
    virtual auto_ptr<ResponseCurve> create() const throw() ;
    
    static double expFn(double *x, double *par) throw();
    static double invExpFn(double *x, double *par) throw();

    static bool inMap; 
    };
    
    
    class GrilloResponseCurve : public ResponseCurve {
    public:
    GrilloResponseCurve() throw(LogicError);
    virtual ~GrilloResponseCurve() throw() {;}
    virtual shared_ptr<TF1> getInverseFunction() const throw(LogicError);
    virtual double getGain(const double charge) const throw() ;
    virtual string getCurveName() const throw() {return "GrilloResponseCurve";}
    virtual auto_ptr<ResponseCurve> create() const throw() ;
    static bool inMap; 

    static double grilloFn(double *x, double *par) throw();
    static double invGrilloFn(double *x, double *par) throw();
    };
    
    class QuadraticResponseCurve : public ResponseCurve {
    public:
    QuadraticResponseCurve() throw(LogicError);
    virtual ~QuadraticResponseCurve() throw() {;}
    virtual shared_ptr<TF1> getInverseFunction() const throw(LogicError);
    virtual double getGain(const double charge) const throw();
    virtual string getCurveName() const throw() {return "QuadraticResponseCurve";}
    virtual auto_ptr<ResponseCurve> create() const throw();
    static bool inMap; 

    static double quadFn(double *x, double *par) throw();
    static double invQuadFn(double *x, double *par) throw();
    };

//INLINES
    inline shared_ptr<TF1> ResponseCurve::getFunction() const throw() {
    return ptr_function;
    }

    inline const int ResponseCurve::getIndex() const throw() {
    return ResponseCurveMap::getMap().getIndex(this->getCurveName());
    }
}

#endif //#ifndef RESPONSECURVE_H

---