BaseHardConstraint.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * See https://github.com/tferber/OrcaKinfit, 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/                                   *
 *                                                                        *
 * Adopted by: Torben Ferber (torben.ferber@desy.de) (TF)                 *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
 
#ifndef __BASEHARDCONSTRAINT_H
#define __BASEHARDCONSTRAINT_H
 
#include "analysis/OrcaKinFit/BaseDefs.h"
#include "analysis/OrcaKinFit/BaseConstraint.h"
#include "analysis/OrcaKinFit/BaseFitObject.h"
 
#include <vector>
 
namespace Belle2 {
  namespace OrcaKinFit {
 
    class BaseFitObject;
 
//  Class BasehardConstraint:
 
    class BaseHardConstraint: public BaseConstraint {
    public:
 
      inline BaseHardConstraint();
 
      virtual ~BaseHardConstraint();
 
      virtual void add1stDerivativesToMatrix(double* M,       
                                             int idim        
                                            ) const;
 
      virtual void add2ndDerivativesToMatrix(double* M,       
                                             int idim,       
                                             double lambda   
                                            ) const;
      virtual void addToGlobalChi2DerVector(double* y,    
                                            int idim,    
                                            double lambda //< The lambda value
                                           ) const;
      virtual double dirDer(double* p,                    
                            double* w,   
                            int idim,    
                            double mu = 1 
                           );
 
      virtual double dirDerAbs(double* p,                 
                               double* w,   
                               int idim,    
                               double mu = 1 
                              );
 
      virtual bool secondDerivatives(int i,                         
                                     int j,                        
                                     double* derivatives           
                                    ) const = 0;
      virtual bool firstDerivatives(int i,                         
                                    double* derivatives           
                                   ) const = 0;
 
      virtual int getVarBasis() const = 0;
 
      virtual double getValue() const override = 0;
 
      virtual double getError() const override;
 
      virtual void getDerivatives(int idim,      
                                  double der[]   
                                 ) const override = 0;
 
      virtual int  getGlobalNum() const
      {return globalNum;}
      virtual void setGlobalNum(int iglobal                 
                               )
      {globalNum = iglobal;}
 
      virtual void printFirstDerivatives() const;
      virtual void printSecondDerivatives() const;
 
      virtual void test1stDerivatives();
      virtual void test2ndDerivatives();
 
      virtual double num1stDerivative(int ifo,      
                                      int ilocal,  
                                      double eps   
                                     );
      virtual double num2ndDerivative(int ifo1,     
                                      int ilocal1, 
                                      double eps1, 
                                      int ifo2,    
                                      int ilocal2, 
                                      double eps2  
                                     );
 
 
 
 
 
    protected:
 
      typedef std::vector <BaseFitObject*> FitObjectContainer;
      typedef FitObjectContainer::iterator FitObjectIterator;
      typedef FitObjectContainer::const_iterator ConstFitObjectIterator;
      FitObjectContainer fitobjects;
      std::vector <double> derivatives;
      std::vector <int> flags;
 
      int globalNum;
 
    };
 
    BaseHardConstraint::BaseHardConstraint()
      : fitobjects(FitObjectContainer()), derivatives(std::vector <double> ()), flags(std::vector <int> ()), globalNum(0)
    {
    }
 
  }// end OrcaKinFit namespace
} // end Belle2 namespace
 
#endif // __BASEHARDCONSTRAINT_H