ROOT_528-00b_version: include/TMultiDimFit.h Source File

00001 // @(#)root/hist:$Id: TMultiDimFit.h 20882 2007-11-19 11:31:26Z rdm $
00002 // Author: Christian Holm Christensen 07/11/2000
00003 
00004 #ifndef ROOT_TMultiDimFit
00005 #define ROOT_TMultiDimFit
00006 
00007 #ifndef ROOT_TNamed
00008 #include "TNamed.h"
00009 #endif
00010 #ifndef ROOT_TVectorD
00011 #include "TVectorD.h"
00012 #endif
00013 #ifndef ROOT_TMatrixD
00014 #include "TMatrixD.h"
00015 #endif
00016 #ifndef ROOT_TList
00017 #include "TList.h"
00018 #endif
00019 #ifndef ROOT_TVirtualFitter
00020 #include "TVirtualFitter.h"
00021 #endif
00022 
00023 class TBrowser;
00024 
00025 class TMultiDimFit : public TNamed {
00026 
00027 public:
00028    enum EMDFPolyType {
00029       kMonomials,
00030       kChebyshev,
00031       kLegendre
00032    };
00033 
00034 private:
00035    static TMultiDimFit* fgInstance; // Static instance
00036 protected:
00037 
00038    TVectorD     fQuantity;             // Training sample, dependent quantity
00039    TVectorD     fSqError;              // Training sample, error in quantity
00040    Double_t     fMeanQuantity;         // Mean of dependent quantity
00041    Double_t     fMaxQuantity;          // Max value of dependent quantity
00042    Double_t     fMinQuantity;          // Min value of dependent quantity
00043    Double_t     fSumSqQuantity;        // SumSquare of dependent quantity
00044    Double_t     fSumSqAvgQuantity;     // Sum of squares away from mean
00045 
00046    TVectorD     fVariables;            // Training sample, independent variables
00047    Int_t        fNVariables;           // Number of independent variables
00048    TVectorD     fMeanVariables;        // mean value of independent variables
00049    TVectorD     fMaxVariables;         // max value of independent variables
00050    TVectorD     fMinVariables;         // min value of independent variables
00051 
00052    Int_t        fSampleSize;           // Size of training sample
00053 
00054    TVectorD     fTestQuantity;         // Test sample, dependent quantity
00055    TVectorD     fTestSqError;          // Test sample, Error in quantity
00056    TVectorD     fTestVariables;        // Test sample, independent variables
00057 
00058    Int_t        fTestSampleSize;       // Size of test sample
00059 
00060    Double_t     fMinAngle;             // Min angle for acepting new function
00061    Double_t     fMaxAngle;             // Max angle for acepting new function
00062    Int_t        fMaxTerms;             // Max terms expected in final expr.
00063    Double_t     fMinRelativeError;     // Min relative error accepted
00064    Int_t       *fMaxPowers;            // [fNVariables] maximum powers
00065    Double_t     fPowerLimit;           // Control parameter
00066 
00067 
00068    TMatrixD     fFunctions;            // Functions evaluated over sample
00069    Int_t        fMaxFunctions;         // max number of functions
00070    Int_t       *fFunctionCodes;        // [fMaxFunctions] acceptance code
00071    Int_t        fMaxStudy;             // max functions to study
00072    Int_t        fMaxFuncNV;            // fMaxFunctions*fNVariables
00073 
00074    TMatrixD     fOrthFunctions;        // As above, but orthogonalised
00075    TVectorD     fOrthFunctionNorms;    // Norm of the evaluated functions
00076 
00077 
00078    Int_t       *fMaxPowersFinal;       // [fNVariables] maximum powers from fit;
00079    Int_t       *fPowers;               // [fMaxFuncNV] where fMaxFuncNV = fMaxFunctions*fNVariables
00080    Int_t       *fPowerIndex;           // [fMaxTerms] Index of accepted powers
00081 
00082    TVectorD     fResiduals;            // Vector of the final residuals
00083    Double_t     fMaxResidual;          // Max redsidual value
00084    Double_t     fMinResidual;          // Min redsidual value
00085    Int_t        fMaxResidualRow;       // Row giving max residual
00086    Int_t        fMinResidualRow;       // Row giving min residual
00087    Double_t     fSumSqResidual;        // Sum of Square residuals
00088 
00089    Int_t        fNCoefficients;        // Dimension of model coefficients
00090    TVectorD     fOrthCoefficients;     // The model coefficients
00091    TMatrixD     fOrthCurvatureMatrix;  // Model matrix
00092    TVectorD     fCoefficients;         // Vector of the final coefficients
00093    TVectorD     fCoefficientsRMS;      // Vector of RMS of coefficients
00094    Double_t     fRMS;                  // Root mean square of fit
00095    Double_t     fChi2;                 // Chi square of fit
00096    Int_t        fParameterisationCode; // Exit code of parameterisation
00097 
00098    Double_t     fError;                // Error from parameterization
00099    Double_t     fTestError;            // Error from test
00100    Double_t     fPrecision;            // Relative precision of param
00101    Double_t     fTestPrecision;        // Relative precision of test
00102    Double_t     fCorrelationCoeff;     // Multi Correlation coefficient
00103    TMatrixD     fCorrelationMatrix;    // Correlation matrix
00104    Double_t     fTestCorrelationCoeff; // Multi Correlation coefficient
00105 
00106    TList*       fHistograms;           // List of histograms
00107    Byte_t       fHistogramMask;        // Bit pattern of hisograms used
00108    Int_t        fBinVarX;              // Number of bin in independent variables
00109    Int_t        fBinVarY;              // Number of bin in dependent variables
00110 
00111    TVirtualFitter* fFitter;            //! Fit object (MINUIT)
00112 
00113    EMDFPolyType fPolyType;             // Type of polynomials to use
00114    Bool_t       fShowCorrelation;      // print correlation matrix
00115    Bool_t       fIsUserFunction;       // Flag for user defined function
00116    Bool_t       fIsVerbose;            //
00117 
00118    virtual Double_t EvalFactor(Int_t p, Double_t x) const;
00119    virtual Double_t EvalControl(const Int_t *powers) const;
00120    virtual void     MakeCoefficientErrors();
00121    virtual void     MakeCorrelation();
00122    virtual Double_t MakeGramSchmidt(Int_t function);
00123    virtual void     MakeCoefficients();
00124    virtual void     MakeCandidates();
00125    virtual void     MakeNormalized();
00126    virtual void     MakeParameterization();
00127    virtual void     MakeRealCode(const char *filename,
00128                                  const char *classname,
00129                                  Option_t   *option="");
00130    virtual Bool_t   Select(const Int_t *iv);
00131    virtual Bool_t   TestFunction(Double_t squareResidual,
00132                                  Double_t dResidur);
00133 public:
00134    TMultiDimFit();
00135    TMultiDimFit(Int_t dimension,
00136                 EMDFPolyType type=kMonomials,
00137                 Option_t *option="");
00138    virtual ~TMultiDimFit();
00139 
00140    virtual void     AddRow(const Double_t *x, Double_t D, Double_t E=0);
00141    virtual void     AddTestRow(const Double_t *x, Double_t D, Double_t E=0);
00142    virtual void     Browse(TBrowser* b);
00143    virtual void     Clear(Option_t *option=""); // *MENU*
00144    virtual void     Draw(Option_t * ="d") { }
00145    virtual Double_t Eval(const Double_t *x, const Double_t *coeff=0) const;
00146    virtual Double_t EvalError(const Double_t *x, const Double_t *coeff=0) const;
00147    virtual void     FindParameterization(Option_t* option=""); // *MENU*
00148    virtual void     Fit(Option_t *option=""); // *MENU*
00149 
00150    Double_t         GetChi2()              const { return fChi2; }
00151    const TMatrixD*  GetCorrelationMatrix() const { return &fCorrelationMatrix; }
00152    const TVectorD*  GetCoefficients()      const { return &fCoefficients; }
00153    Double_t         GetError()             const { return fError; }
00154    Int_t*           GetFunctionCodes()     const { return fFunctionCodes; }
00155    const TMatrixD*  GetFunctions()         const { return &fFunctions; }
00156    virtual TList*   GetHistograms()        const { return fHistograms; }
00157    Double_t         GetMaxAngle()          const { return fMaxAngle; }
00158    Int_t            GetMaxFunctions()      const { return fMaxFunctions; }
00159    Int_t*           GetMaxPowers()         const { return fMaxPowers; }
00160    Double_t         GetMaxQuantity()       const { return fMaxQuantity; }
00161    Int_t            GetMaxStudy()          const { return fMaxStudy; }
00162    Int_t            GetMaxTerms()          const { return fMaxTerms; }
00163    const TVectorD*  GetMaxVariables()      const { return &fMaxVariables; }
00164    Double_t         GetMeanQuantity()      const { return fMeanQuantity; }
00165    const TVectorD*  GetMeanVariables()     const { return &fMeanVariables; }
00166    Double_t         GetMinAngle()          const { return fMinAngle; }
00167    Double_t         GetMinQuantity()       const { return fMinQuantity; }
00168    Double_t         GetMinRelativeError()  const { return fMinRelativeError; }
00169    const TVectorD*  GetMinVariables()      const { return &fMinVariables; }
00170    Int_t            GetNVariables()        const { return fNVariables; }
00171    Int_t            GetNCoefficients()     const { return fNCoefficients; }
00172    Int_t            GetPolyType()          const { return fPolyType; }
00173    Int_t*           GetPowerIndex()        const { return fPowerIndex; }
00174    Double_t         GetPowerLimit()        const { return fPowerLimit; }
00175    const Int_t*     GetPowers()            const { return fPowers; }
00176    Double_t         GetPrecision()         const { return fPrecision; }
00177    const TVectorD*  GetQuantity()          const { return &fQuantity; }
00178    Double_t         GetResidualMax()       const { return fMaxResidual; }
00179    Double_t         GetResidualMin()       const { return fMinResidual; }
00180    Int_t            GetResidualMaxRow()    const { return fMaxResidualRow; }
00181    Int_t            GetResidualMinRow()    const { return fMinResidualRow; }
00182    Double_t         GetResidualSumSq()     const { return fSumSqResidual; }
00183    Double_t         GetRMS()               const { return fRMS; }
00184    Int_t            GetSampleSize()        const { return fSampleSize; }
00185    const TVectorD*  GetSqError()           const { return &fSqError; }
00186    Double_t         GetSumSqAvgQuantity()  const { return fSumSqAvgQuantity; }
00187    Double_t         GetSumSqQuantity()     const { return fSumSqQuantity; }
00188    Double_t         GetTestError()         const { return fTestError; }
00189    Double_t         GetTestPrecision()     const { return fTestPrecision; }
00190    const TVectorD*  GetTestQuantity()      const { return &fTestQuantity; }
00191    Int_t            GetTestSampleSize()    const { return fTestSampleSize; }
00192    const TVectorD*  GetTestSqError()       const { return &fTestSqError; }
00193    const TVectorD*  GetTestVariables()     const { return &fTestVariables; }
00194    const TVectorD*  GetVariables()         const { return &fVariables; }
00195 
00196    static TMultiDimFit* Instance();
00197    virtual Bool_t   IsFolder()             const { return kTRUE; }
00198    virtual Double_t MakeChi2(const Double_t* coeff=0);
00199    virtual void     MakeCode(const char *functionName="MDF", Option_t *option=""); // *MENU*
00200    virtual void     MakeHistograms(Option_t* option="A"); // *MENU*
00201    virtual void     MakeMethod(const Char_t* className="MDF", Option_t* option=""); // *MENU*
00202    virtual void     Print(Option_t *option="ps") const; // *MENU*
00203 
00204    void             SetBinVarX(Int_t nbbinvarx) {fBinVarX = nbbinvarx;}
00205    void             SetBinVarY(Int_t nbbinvary) {fBinVarY = nbbinvary;} 
00206    void             SetMaxAngle(Double_t angle=0);
00207    void             SetMaxFunctions(Int_t n) { fMaxFunctions = n; }
00208    void             SetMaxPowers(const Int_t *powers);
00209    void             SetMaxStudy(Int_t n) { fMaxStudy  = n; }
00210    void             SetMaxTerms(Int_t terms) { fMaxTerms = terms; }
00211    void             SetMinRelativeError(Double_t error);
00212    void             SetMinAngle(Double_t angle=1);
00213    void             SetPowerLimit(Double_t limit=1e-3);
00214    virtual void     SetPowers(const Int_t *powers, Int_t terms);
00215 
00216    ClassDef(TMultiDimFit,2) // Multi dimensional fit class
00217 }
00218 ;
00219 #endif