TrackFitObject.h

Go to the documentation of this file.

#ifndef __TRACKFITOBJECT_H
#define __TRACKFITOBJECT_H

#include "BaseFitObject.h"

#include <iostream>

class TwoVector;
class ThreeVector;
class FourVector;
class JBLHelix;


// Class TrackFitObject

class TrackFitObject: public BaseFitObject {
  public:
    TrackFitObject(const char *name_ = 0                   
                  );
    TrackFitObject (const TrackFitObject& rhs              
                   );
    TrackFitObject& operator= (const TrackFitObject& rhs   
                   );
    virtual ~TrackFitObject();
    
    virtual bool   setParam (int ilocal,         
                             double par_,        
                             bool measured_,     
                             bool fixed_ = false 
                            );  
    virtual bool   setParam (int ilocal,         
                             double par_         
                            );  

    virtual bool  setParameters (int ivertex,                  
                                const ThreeVector& vertex,    
                                const FourVector& momentum,   
                                double charge_                
                               ) = 0; 
    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 double getParam (int i                
                            ) const;
    virtual double getMParam (int i              
                            ) const;
    virtual double getError (int ilocal          
                            ) const;
    virtual double getCov (int ilocal,           
                           int jlocal            
                          ) const;
    virtual bool isParamMeasured (int ilocal     
                                  ) const;
    virtual bool isParamFixed (int ilocal        
                              ) const;
    virtual int getGlobalParNum(int ilocal       
                               ) const;
    virtual int getNPar() const = 0;
    
    virtual const char *getName () const;
    
    virtual void setName (const char *name_       
                         );
    
    virtual void getTrajectoryPointEx (double s,              
                                       ThreeVector& p         
                                      ) const = 0; 
    virtual ThreeVector getTrajectoryPoint (double s             
                                           ) const; 
    virtual void getVertexEx (int ivertex,              
                              ThreeVector& p            
                             ) const = 0; 
    virtual ThreeVector getVertex (int ivertex    
                                  ) const; 

    virtual void setVertex (int ivertex,         
                            const TwoVector& v   
                           ) = 0; 
    
    virtual void getTrajectoryDerivativeEx (double s,            
                                            int ilocal,          
                                            ThreeVector& p       
                                           ) const = 0;
    virtual ThreeVector getTrajectoryDerivative (double s,       
                                                 int ilocal      
                                                ) const;
    virtual void getVertexDerivativeEx (int ivertex,            
                                        int ilocal,             
                                        ThreeVector& p          
                                       ) const = 0;
    virtual ThreeVector getVertexDerivative (int ivertex,       
                                             int ilocal         
                                            ) const;

    virtual void getMomentumAtTrajectoryEx (double s,           
                                            FourVector& p       
                                           ) const = 0; 
    virtual FourVector getMomentumAtTrajectory (double s        
                                               ) const; 
    virtual void getMomentumEx (int ivertex,                    
                                FourVector& p                   
                               ) const = 0; 
    virtual FourVector getMomentum (int ivertex                 
                                   ) const; 

    virtual double getCharge () const = 0; 

    virtual double getMass () const = 0; 

    virtual void getMomentumDerivativeAtTrajectoryEx (double s,      
                                                      int ilocal,    
                                                      FourVector& p  
                                                     ) const = 0; 
    virtual FourVector getMomentumDerivativeAtTrajectory (double s,   
                                                          int ilocal  
                                                         ) const; 
    virtual void getMomentumDerivativeEx (int ivertex,           
                                          int ilocal,            
                                          FourVector& p          
                                         ) const = 0;
    virtual FourVector getMomentumDerivative (int ivertex,       
                                              int ilocal         
                                             ) const;
    virtual double getArcLength (int ivertex                           
                                ) const = 0;
    virtual void addToGlobCov(double *globvcov,                       
                              int idim                                
                              ) const; 
        
    
    virtual double getChi2() const;
    virtual double getDChi2DParam(int ilocal                
                                    ) const = 0;
    virtual double getD2Chi2DParam2(int ilocal,               
                                    int jlocal                
                                   ) const = 0;
    
    virtual void addToGlobalChi2DerMatrix (int idim, double *M) const = 0;
    virtual void addToGlobalDerMatrix (int idim,               
                                       double c,               
                                       double *M               
                                      ) const = 0;
    
    virtual JBLHelix getTangentialHelix (double s     
                                        ) = 0;
    virtual std::ostream& print (std::ostream& os              
                                ) const;
    
    virtual void invalidateCache();  
    
    
    static double setBfield (double bfield_             
                            );
  
    inline static double getBfield ();
    
    static double bfield;
    
    virtual bool fixVertexParam (int ivertex,    
                                 bool fix=true  
                                 ) = 0;
    virtual bool releaseVertexParam (int ivertex    
                                    );
    virtual void TrackFitObject::printCov (std::ostream& os              
                                          ) const;
  protected:
    virtual void initCov();
    virtual void checkCov();
    
    virtual bool calculateCovInv() const;
    
    virtual void calculateChi2() const;
    virtual void copy (const TrackFitObject& source              
                   );
  
  
    enum {NPARMAX = 8};
    
    double par[NPARMAX];
    double mpar[NPARMAX];
    double err[NPARMAX];
    bool measured[NPARMAX];
    bool fixed[NPARMAX];
    int globalParNum [NPARMAX];
    double cov [NPARMAX][NPARMAX];    
    mutable double covinv [NPARMAX][NPARMAX];   
    mutable bool cachevalid; 
    mutable bool covinvvalid; 
    
    // Cache variables
    mutable double chi2;               
    mutable double resid[NPARMAX];     
    mutable bool   chi2contr[NPARMAX]; 
    
    char *name;                        
    
};
    
inline std::ostream& operator<< (std::ostream& os,              
                                 const TrackFitObject& tfo      
                                ) {
  tfo.print(os);
  return os;
}

double TrackFitObject::getBfield() {
  return bfield;
}

#endif // __TRACKFITOBJECT_H

---