SoftGaussParticleConstraint.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 __SOFTGAUSSPARTICLECONSTRAINT_H
#define __SOFTGAUSSPARTICLECONSTRAINT_H
 
#include<vector>
#include<cassert>
#include "analysis/OrcaKinFit/BaseSoftConstraint.h"
#include "analysis/OrcaKinFit/BaseFitObject.h"
 
namespace Belle2 {
  namespace OrcaKinFit {
 
    class ParticleFitObject;
 
//  Class SoftGaussParticleConstraint:
 
    class SoftGaussParticleConstraint: public BaseSoftConstraint {
    public:
      explicit SoftGaussParticleConstraint(double sigma_     
                                          );
      virtual ~SoftGaussParticleConstraint() {};
 
      virtual void setFOList(std::vector <ParticleFitObject*>* fitobjects_ 
                            )
      {
        for (int i = 0; i < (int) fitobjects_->size(); i++) {
          fitobjects.push_back((*fitobjects_)[i]);
          flags.push_back(1);
        }
      };
      virtual void addToFOList(ParticleFitObject& fitobject, int flag = 1
                              )
      {
        fitobjects.push_back(&fitobject);
        flags.push_back(flag);
      };
      virtual void resetFOList()
      {
        fitobjects.resize(0);
        flags.resize(0);
      };
 
      virtual double getValue() const override = 0;
 
      virtual double getChi2() const override;
 
      virtual double getError() const override;
 
      virtual double getSigma() const;
 
      virtual double setSigma(double sigma_     
                             );
 
      virtual void getDerivatives(int idim,      
                                  double der[]   
                                 ) const override = 0;
      virtual void add2ndDerivativesToMatrix(double* M,     
                                             int idim       
                                            ) const override;
 
      virtual void addToGlobalChi2DerVector(double* y,    
                                            int idim     
                                           ) const override;
 
 
      void invalidateCache() const {}
 
      void test1stDerivatives();
      void test2ndDerivatives();
 
      double num1stDerivative(int ifo,      
                              int ilocal,  
                              double eps   
                             );
      double num2ndDerivative(int ifo1,     
                              int ilocal1, 
                              double eps1, 
                              int ifo2,    
                              int ilocal2, 
                              double eps2  
                             );
 
      int getVarBasis() const;
 
    protected:
 
      virtual bool secondDerivatives(int i,                         
                                     int j,                        
                                     double* derivatives           
                                    ) const = 0;
      virtual bool firstDerivatives(int i,                         
                                    double* derivatives           
                                   ) const = 0;
 
 
      typedef std::vector <ParticleFitObject*> FitObjectContainer;
      typedef FitObjectContainer::iterator FitObjectIterator;
      typedef FitObjectContainer::const_iterator ConstFitObjectIterator;
      FitObjectContainer fitobjects;
      std::vector <double> derivatives;
      std::vector <int> flags;
 
      double sigma;
 
      enum { VAR_BASIS = BaseDefs::VARBASIS_EPXYZ }; // this means that the constraint knows about E,px,py,pz
 
    };
 
  }// end OrcaKinFit namespace
} // end Belle2 namespace
 
#endif // __SOFTGAUSSPARTICLECONSTRAINT_H