Resolving all symbols in the library

[u/mrichter/AliRoot.git] / STAT / TKDNodeInfo.h

diff --git a/STAT/TKDNodeInfo.h b/STAT/TKDNodeInfo.h
index 9a522c9d50ffae4d86b0794cae38b4c3c9faa703..e68822909b893a22dea29a447b53131e7f570cc5 100644 (file)
--- a/STAT/TKDNodeInfo.h
+++ b/STAT/TKDNodeInfo.h
@@ -1,51 +1,123 @@
 #ifndef ROOT_TKDNodeInfo
 #define ROOT_TKDNodeInfo
 
+////////////////////////////////////////////////////////
+//
+// Bucket representation for TKDInterpolator(Base)
+//
+// Author Alexandru Bercuci <A.Bercuci@gsi.de>
+//
+////////////////////////////////////////////////////////
+
 #ifndef ROOT_TObject
 #include "TObject.h"
 #endif
 
+#ifndef ROOT_TBox
+#include "TBox.h"
+#endif
+
+#ifndef ROOT_TMarker
+#include "TMarker.h"
+#endif
+
 template <typename Value> class TVectorT;
-typedef struct TVectorT<Double_t> TVectorD;
+typedef class TVectorT<Double_t> TVectorD;
 template <typename Value> class TMatrixT;
 typedef class TMatrixT<Double_t> TMatrixD;
-class TKDInterpolatorBase;
 class TKDNodeInfo : public TObject
 {
-friend class TKDInterpolatorBase;
 public:
-       TKDNodeInfo(const Int_t ndim = 0);
-       TKDNodeInfo(const TKDNodeInfo &);
-       TKDNodeInfo& operator=(const TKDNodeInfo &);
-       virtual  ~TKDNodeInfo();
-       Double_t  CookPDF(const Double_t *point, Double_t &result, Double_t &error);
-       inline Bool_t    Has(const Float_t *p);
-       void      Print();
-       void      Store(const TVectorD &par, const TMatrixD &cov);
+  friend class TKDPDF;
+  friend class TKDInterpolatorBase;
+  class TKDNodeDraw : public TBox {
+  public:
+    TKDNodeDraw();
+    ~TKDNodeDraw() {;}
+    void  Draw(Option_t* option = "");
+    void  Print(const Option_t* option = "") const; // *MENU*
+    void  SetNode(TKDNodeInfo*, UChar_t s, UChar_t ax1=0, UChar_t ax2=1);
+  private:
+    TKDNodeDraw(const TKDNodeDraw & ref);
+    TKDNodeDraw& operator=(const TKDNodeDraw & ref);
 
+    TMarker     fCOG;    // COG of the node
+    TKDNodeInfo *fNode;  //! node data
+    ClassDef(TKDNodeDraw, 1)   // graphical representation of TKDNodeInfo
+  };
+
+  TKDNodeInfo(Int_t ndim = 0);
+  TKDNodeInfo(const TKDNodeInfo & ref);
+  TKDNodeInfo& operator=(const TKDNodeInfo & ref);
+  virtual ~TKDNodeInfo();
+  Bool_t        CookPDF(const Double_t *point, Double_t &result, Double_t &error) const;
+  inline void   GetBoundary(Int_t ax, Float_t &min, Float_t &max) const;
+  inline void   GetCOG(Float_t* &p) const;
+  Int_t         GetDimension() const { return fNDim/3; }
+  void          GetPDF(Float_t &pdf, Float_t &error) const {pdf=fVal[0]; error=fVal[1];}
+  Int_t         GetSize() const { return fNDim; }
+  Int_t         GetNcov() const { return fNcov; }
+  Int_t         GetNpar() const { return fNpar; }
+  inline Bool_t Has(const Float_t *p) const;
+  void          Print(const Option_t * = "") const;
+  void          Store(TVectorD const *par, TMatrixD const *cov=NULL);
+
+  Double_t*      Cov() const  { return fCov; }
+  Double_t*      Par() const  { return fPar; }
+
+  void          SetNode(Int_t ndim, Float_t *data, Float_t *pdf);
 protected:
-       void      Build(const Int_t ndim);
+  void          Bootstrap();
+  void          Build(Int_t ndim);
+  void          SetNcov() { fNcov=Int_t(.5*fNpar*(fNpar+1.));}
+  void          SetNpar() { Int_t dim=Int_t(fNDim/3); fNpar=Int_t(1 + dim + .5*dim*(dim+1));}
+  Float_t*      Data() { return fData;}
+  Float_t*      Val()  { return &fVal[0]; }
 
-public:
-       Int_t     fNDim;          // 3 times data dimension
-       Float_t   *fData;         //[fNDim] node's data
-       Float_t   fVal[2];        // measured value for node
-       TMatrixD  *fCov;          // interpolator covariance matrix
-       TVectorD  *fPar;          // interpolator parameters
 
-       ClassDef(TKDNodeInfo, 1)  // node info for interpolator
+private:
+  Int_t     fNDim;          //! 3 times data dimension
+  Float_t   *fData;         //![fNDim] node's data
+  Float_t   fVal[2];        //!measured value for node
+  Int_t     fNpar;          //number of parameters
+  Int_t     fNcov;          //number of covarince elements
+  Double_t  *fPar;          //[fNpar] interpolator parameters
+  Double_t  *fCov;          //[fNcov] interpolator covariance matrix
+
+
+  ClassDef(TKDNodeInfo, 2)  // node info for interpolator
 };
 
 //_____________________________________________________________________
-Bool_t TKDNodeInfo::Has(const Float_t *p)
+inline Bool_t TKDNodeInfo::Has(const Float_t *p) const
 {
-       Int_t n = 0;
-       Int_t ndim = fNDim/3;
-       for(int id=0; id<ndim; id++) if(p[id]>=fData[ndim+2*id] && p[id]<fData[ndim+2*id+1]) n++;
-       if(n==ndim) return kTRUE;
-       return kFALSE;
+  Int_t ndim = fNDim/3;
+  
+  Float_t *it = &fData[ndim]; Int_t n(0);
+  for(int id=0; id<ndim; id++, it+=2)
+    if(p[id]>=it[0] && p[id]<it[1]) n++;
+  if(n==ndim) return kTRUE;
+  return kFALSE;
 }
 
+//_____________________________________________________________________
+inline void TKDNodeInfo::GetBoundary(Int_t ax, Float_t &min, Float_t &max) const
+{
+  Int_t ndim = fNDim/3;
+  if(ax<0 || ax>=ndim){
+    min=0.; max=0.;
+    return;
+  }
+  Float_t *it = &fData[ndim+(ax<<1)];
+  min = it[0]; max = it[1];
+}
+
+//_____________________________________________________________________
+inline void TKDNodeInfo::GetCOG(Float_t* &p) const
+{
+  Int_t ndim = fNDim/3;
+  memcpy(p, fData, ndim*sizeof(Float_t));
+}
 
 #endif