BaseFitObject.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * Forked from https://github.com/iLCSoft/MarlinKinfit                    *
 *                                                                        *
 * Further information about the fit engine and the user interface        *
 * provided in MarlinKinfit can be found at                               *
 * https://www.desy.de/~blist/kinfit/doc/html/                            *
 * and in the LCNotes LC-TOOL-2009-001 and LC-TOOL-2009-004 available     *
 * from http://www-flc.desy.de/lcnotes/                                   *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#ifndef __BASEFITOBJECT_H
#define __BASEFITOBJECT_H
 
#include <iostream>
 
#include "analysis/OrcaKinFit/BaseDefs.h"
 
// Class BaseFitObject
 
namespace Belle2 {
  namespace OrcaKinFit {
 
    class BaseFitObject {
    public:
      BaseFitObject();
 
      BaseFitObject(const BaseFitObject& rhs               
                   );
      BaseFitObject& operator= (const BaseFitObject& rhs   
                               ) ;
 
      virtual ~BaseFitObject();
 
      virtual BaseFitObject* copy() const = 0;
 
      virtual BaseFitObject& assign(const BaseFitObject& source    
                                   );
 
      virtual bool setParam(int ilocal,          
                            double par_,        
                            bool measured_,     
                            bool fixed_ = false 
                           );
 
      virtual bool setParam(int ilocal,     
                            double par_    
                           );
 
      virtual bool updateParams(double p[],    
                                int idim      
                               );
 
      virtual bool setMParam(int ilocal,     
                             double mpar_   
                            );
 
      virtual bool setError(int ilocal,     
                            double err_    
                           );
 
      virtual bool setCov(int ilocal,     
                          int jlocal,    
                          double cov_    
                         );
 
      virtual bool setGlobalParNum(int ilocal,   
                                   int iglobal  
                                  );
 
      virtual bool fixParam(int ilocal,     
                            bool fix = true 
                           );
      virtual bool releaseParam(int ilocal     
                               )
      { return fixParam(ilocal, false); }
 
      virtual bool isParamFixed(int ilocal      
                               ) const;
 
      virtual double getParam(int ilocal      
                             ) const;
      virtual const char* getParamName(int ilocal      
                                      ) const = 0;
      //    virtual const char *getName () const { return name ? name : "???";}
      virtual const char* getName() const;  // { return name ? name : "???";}
      void setName(const char* name_);
      virtual double getMParam(int ilocal      
                              ) const;
      virtual double getError(int ilocal      
                             ) const;
      virtual double getCov(int ilocal,     
                            int jlocal     
                           ) const;
      virtual double getRho(int ilocal,     
                            int jlocal     
                           ) const;
      virtual bool isParamMeasured(int ilocal     
                                  ) const;
      virtual int getGlobalParNum(int ilocal     
                                 ) const;
      virtual int getNPar() const = 0;
      virtual int getNMeasured() const;
      virtual int getNUnmeasured() const;
      virtual int getNFree() const;
      virtual int getNFixed() const;
 
      virtual double getChi2() const;
 
      virtual double getDChi2DParam(int ilocal   
                                   ) const ;
 
      virtual double getD2Chi2DParam2(int ilocal,   
                                      int jlocal    
                                     ) const;
 
      virtual std::ostream& printParams(std::ostream& os   
                                       ) const;
 
      virtual std::ostream& printRhoValues(std::ostream& os   
                                          ) const;
 
      virtual std::ostream& print1stDerivatives(std::ostream& os   
                                               ) const;
 
      virtual std::ostream& print2ndDerivatives(std::ostream& os   
                                               ) const;
 
      virtual std::ostream&  print(std::ostream& os        
                                  ) const = 0;
 
 
      void invalidateCache() const {cachevalid = false;};
      virtual void updateCache() const = 0;
 
      // these are the methods that fill the fitter's matrices/vectors
 
      virtual void addToGlobCov(double* glcov,   
                                int idim     
                               ) const;
 
      virtual int addToGlobalChi2DerVector(double* y,    
                                           int idim     
                                          ) const;
 
      virtual void addToGlobalChi2DerMatrix(double* M,    
                                            int idim     
                                           ) const;
 
      virtual void addToGlobalChi2DerVector(double* y,      
                                            int idim,      
                                            double lambda, 
                                            double der[], 
                                            int metaSet  
                                           ) const;
 
      // seems not to be used DJeans
      //    virtual void addToDerivatives (double der[], int idim,
      //           double factor[], int metaSet) const;
 
      virtual void addTo1stDerivatives(double M[],
                                       int idim,
                                       double der[],
                                       int kglobal,
                                       int metaSet
                                      ) const;
 
      virtual void addTo2ndDerivatives(double der2[], int idim, double factor[], int metaSet) const;
      virtual void addTo2ndDerivatives(double M[], int idim,  double lambda, double der[], int metaSet) const;
 
      // DANIEL added
      // derivatives of intermediate variables wrt object's local parameters
      // these must be implemented by the derived classes for each type of object
      virtual double getFirstDerivative_Meta_Local(int iMeta,
                                                   int ilocal,
                                                   int metaSet
                                                  ) const = 0;
 
      virtual double getSecondDerivative_Meta_Local(int iMeta,
                                                    int ilocal,
                                                    int jlocal,
                                                    int metaSet
                                                   ) const = 0;
 
      virtual void initCov();
 
      virtual double getError2(double der[], int metaset) const;
 
      virtual void getDerivatives(double der[], int idim) const = 0;
 
 
    protected:
      char* name;
      const static double eps2;
 
      // DANIEL moved all of this stuff to BaseFitObject
      // it costs some extra memory, since everything has dimension of largest # of parameters
      // but avoid a lot of almost-duplication in the derived classes
 
      virtual bool calculateCovInv() const;
 
      double par[BaseDefs::MAXPAR];
      double mpar[BaseDefs::MAXPAR];
      bool measured[BaseDefs::MAXPAR];
      bool fixed[BaseDefs::MAXPAR];
      int globalParNum [BaseDefs::MAXPAR];
      double cov [BaseDefs::MAXPAR][BaseDefs::MAXPAR];
      mutable double covinv [BaseDefs::MAXPAR][BaseDefs::MAXPAR];
      mutable bool covinvvalid;
      mutable bool cachevalid;
      // end DANIEL adds
 
    };
 
    inline std::ostream& operator<< (std::ostream& os,         
                                     const BaseFitObject& bfo  
                                    )
    {
      return bfo.print(os);
    }
 
  }// end OrcaKinFit namespace
} // end Belle2 namespace
 
 
#endif // __BASEFITOBJECT_H