VertexFitObject.h

Go to the documentation of this file.

#ifndef __VERTEXFITOBJECT_H
#define __VERTEXFITOBJECT_H

#include "BaseFitObject.h"

#include <iostream>
#include <cassert>
#include <vector>

class ThreeVector;
class FourVector;
class TrackParticleFitObject;
class BaseFitter;
class BaseConstraint;

// Class VertexFitObject

class VertexFitObject: public BaseFitObject {
  public:
    VertexFitObject(const char *name_,
                    double x,
                    double y,
                    double z
                   );
    VertexFitObject (const VertexFitObject& rhs);

    VertexFitObject& operator= (const VertexFitObject& rhs);

    virtual VertexFitObject *copy() const ;
    
    virtual VertexFitObject& assign (const BaseFitObject& source   
                                 ) ;

    virtual ~VertexFitObject();



// these are now defined upstream    
//    /// Set value and measured flag of parameter ilocal; return=success
//    virtual bool   setParam (int ilocal,         ///< Local parameter number
//                             double par_,        ///< New parameter value
//                             bool measured_,     ///< New "measured" flag
//                             bool fixed_ = false ///< New "fixed" flag
//                            );  
//    /// Set value of parameter ilocal; return=success
//    virtual bool   setParam (int ilocal,         ///< Local parameter number
//                             double par_         ///< New parameter value
//                            );  
//    /// Set measured value of parameter ilocal; return=success
//    virtual bool   setMParam (int ilocal,         ///< Local parameter number
//                              double mpar_        ///< Measured parameter value
//                             );  
//    /// Set error of parameter ilocal
//    virtual bool   setError (int ilocal,    ///< Local parameter number
//                             double err_    ///< New error value
//                             );
//    /// Set covariance of parameters ilocal and jlocal
//    virtual bool   setCov (int ilocal,    ///< Local parameter number
//                           int jlocal,    ///< Local parameter number
//                           double cov_    ///< New error value
//                          );
//    /// Set number of parameter ilocal in global list
//    /// return true signals OK
//    virtual bool setGlobalParNum (int ilocal, int iglobal); 
//    
//    /// Fix a parameter (fix=true), or release it (fix=false)
//    virtual bool fixParam (int ilocal,    ///< Local parameter number
//                           bool fix=true  ///< fix if true, release if false
//                          );
//    
//    /// Get parameter ilocal
//    virtual double getParam (int ilocal     ///< Local parameter number
//                            ) const;
//    /// Get measured value of parameter ilocal
//    virtual double getMParam (int ilocal     ///< Local parameter number
//                            ) const;
//    /// Get error of parameter ilocal
//    virtual double getError (int ilocal     ///< Local parameter number
//                            ) const;
//    /// Get covariance between parameters ilocal and jlocal
//    virtual double getCov (int ilocal,    ///< Local parameter number
//                           int jlocal     ///< Local parameter number
//                          ) const;
//    /// Get measured flag for parameter i
//    virtual bool isParamMeasured (int ilocal) const;
//    /// Get fixed flag for parameter i
//    virtual bool isParamFixed (int ilocal) const;
//    /// Get global parameter number of parameter ilocal
//    virtual int getGlobalParNum(int ilocal) const;
//    /// Get number of parameters of this FitObject
//    virtual int getNPar() const;
    virtual int getNPar() const {return NPAR;}
    
    //    virtual const char *getName () const;
    
//    virtual void setName (const char *name_);
    
    virtual const char *getParamName (int ilocal     
                                      ) const;
   
    
    virtual void getVertexEx (ThreeVector& p
                             ) const;

    virtual ThreeVector getVertex() const; 
    
    virtual void getVertexDerivativeEx (int ilocal, 
                                        ThreeVector& p
                                       ) const;

    virtual ThreeVector getVertexDerivative (int ilocal 
                                            ) const;


    virtual void getDerivatives (double der[], int idim) const {}

//    /// Add covariance matrix elements to 
//    /// global covariance matrix of size idim x idim
//    virtual void addToGlobCov(double *cov, int idim) const; 
            
//    /// Get chi squared from measured and fitted parameters
//    virtual double getChi2() const;
//    /// Get derivative of chi squared w.r.t. parameter ilocal
//    virtual double getDChi2DParam(int ilocal) const 
//    {assert (0);}
//    /// Get second derivative of chi squared w.r.t. parameters ilocal1 and ilocal2
//    virtual double getD2Chi2DParam2(int ilocal1, int ilocal2) const {assert (0);};
//    
//    /// Add derivatives of chi squared to global covariance matrix
//    virtual void addToGlobalChi2DerMatrix (double *M,   ///< Global covariance matrix
//                                           int idim     ///< First dimension of global covariance matrix
//                                           ) const 
//    {assert (0);}
//    /// Add derivatives of chi squared to global derivative matrix
//    virtual void addToGlobalChi2DerVector (double *y,   ///< Vector of chi2 derivatives
//                                           int idim     ///< Vector size 
//                                           ) const 
//    {assert (0);}
//    
//    /// Add derivatives to global covariance matrix
//    virtual void addToGlobalDerMatrix (int idim, double c, double *M) const {assert (0);};
//    

    // print object to ostream
    virtual std::ostream& print (std::ostream& os   
                                 ) const;
    
    virtual TrackParticleFitObject *getTrack (int i
                                              ) const {return tracks[i].track;}
        
    virtual void addTrack (TrackParticleFitObject *track,   
                           bool inbound,            
                           bool measured            
                           );
    
    enum  {
      VX = 1, VY = 2, VZ = 4, VXY = 3, VXYZ=7,
      PX = 8, PY = 16, PZ = 32, PXY = 24, PXYZ = 56,
      E = 64, EPXYZ = 120,
      THE_FULL_MONTY = 127
    };
    
    virtual void addConstraints (BaseFitter& fitter, 
                                 int mask = THE_FULL_MONTY
                                );
    
    virtual ThreeVector estimatePosition ();
    
    virtual void initForFit();

    virtual double getFirstDerivative_Meta_Local(int iMeta, int ilocal , int metaSet) const;
    virtual double getSecondDerivative_Meta_Local(int iMeta, int ilocal , int jlocal , int metaSet) const;
            
  protected:

    virtual void updateCache() const {assert (0);}



    virtual void addVertexConstraints (BaseFitter& fitter, int axis);
    virtual void addMomentumConstraint (BaseFitter& fitter, int axis);
  
    //    virtual void initCov();    
    //    virtual bool calculateCovInv() const;
    //    virtual void calculateChi2() const;
    //    virtual void copy (const VertexFitObject& source);
    //    virtual VertexFitObject* copy() const;
  
  
    enum {NPAR = 3};
    
//    /// fit parameters
//    double par[NPAR];
//    /// measured parameters
//    double mpar[NPAR];
//    /// errors
//    double err[NPAR];
//    /// measured flag
//    bool measured[NPAR];
//    /// fixed flag
//    bool fixed[NPAR];
//    /// global paramter number for each parameter
//    int globalParNum [NPAR];
//    /// local covariance matrix
//    double cov [NPAR][NPAR];    
//    /// inverse of local covariance matrix
//    mutable double covinv [NPAR][NPAR];   
//    /// flag for valid inverse covariance matrix
//    mutable bool covinvvalid; 
    
    // Cache variables
    //    mutable double chi2;               ///< chi^2
    //    mutable double resid[NPAR];     ///< residuals
    //    mutable bool   chi2contr[NPAR]; ///< contributes to chi2?
    
    //    char *name;                        ///< object name
    
    struct TrackDescriptor {
      TrackParticleFitObject *track;
      bool inbound;
      bool measured;
      TrackDescriptor (TrackParticleFitObject *track_, bool inbound_, bool measured_)
      : track (track_), inbound (inbound_), measured (measured_) 
      {}
      TrackDescriptor ()
      : track (0), inbound (0), measured (0) 
      {}
    };
    
    typedef std::vector<TrackDescriptor> TContainer;
    typedef TContainer::iterator TIterator;
    TContainer tracks;
    typedef std::vector<BaseConstraint *> CContainer;
    typedef CContainer::iterator CIterator;
    CContainer constraints;
    
};
    
#endif // __VERTEXFITOBJECT_H