Base_PointB.h

Go to the documentation of this file.

//--------------------------------------//
// Authors: A. Cervera
//          JJ. Gomez-Cadenas
//          JA. Hernando
//          M. Ellis
//
// Last update 25/09/03 by G. Prior:
//      - setState for non const IState
//      - non const measurement (by ME)
//      - non const m_surface (by ME) 
//--------------------------------------//
   
#ifndef PointB_h
#define PointB_h 1

#include "Kalman/Interface_IPoint.h"
#include "Kalman/Interface_ITrajectoryFactory.h"


//! This is a General base class for a IPoint
/*! A Basic implementation of IPoint 
    It constains a private ITrajectory factory to create states
*/
class PointB : public IPoint
{
 public:
  //! default constructor
  PointB();
    
  //! constructor providing a trajectory factory
  PointB(ITrajectoryFactory& fact);
  
  //! default destructor
  virtual ~PointB();
  
  //! copy a naked point
  virtual void copy(const IPoint& ip);

  //! copy the full point (including state, residual, surface)
  virtual void copyFitResults(const IPoint& ip);  


  //-------- Set and Get methods -----------------


  //! the surface of the point (this field is NULL before the fit is performed)
  virtual const ISurface& surface() const {return *m_surface;}
  virtual void setSurface(const ISurface& surf);

  //! return true if the point it is used for fits
  virtual bool isUsed() const {return m_isUsed;}
  virtual void setIsUsed(bool t) {m_isUsed=t;}
  

  //! return true if the point it is updated
  virtual bool isUpdated() const {return m_isUpdated;}
  virtual void setIsUpdated(bool t) {m_isUpdated=t;}
  
  //! returns the quality of the point (tipically the local chi2)
  virtual std::map<std::string, double> qualityMap() const {return m_qualityMap;}
  //! set the quality map
  virtual void setQuality(std::string name, double value) {m_qualityMap[name]=value;}
  
  //!   Returns the projected hypervector
  virtual const HyperVector& projectionHV() const {return m_projectionHV;}
  //!   Set the projection HVector
  virtual void setProjectionHV(const HyperVector& hv) {m_projectionHV=hv;}

  //!   Returns the residual HVector
  virtual const HyperVector& residualHV() const {return m_residualHV;}
  //!   Set the residual HVector
  virtual void setResidualHV(const HyperVector& hv) {m_residualHV=hv;}

  //!   Returns the state
  virtual const IState& state() const {return *m_state;}
  //!   Returns a non constant reference to the state
  virtual IState& state() {return *m_state;}
  //!   Set the state. It will make a copy
  virtual void setState(const IState& is);
  virtual void setState(IState& is);
  
  //!   Returns the measurement
  virtual const IMeasurement& measurement() const {return *m_meas;};
  virtual IMeasurement& measurement() { return (IMeasurement&) *m_meas; };// ME added this
  //!   Sets a measurement
  virtual void setMeasurement(const IMeasurement& im) {m_meas=&im;};


  //!   path length from the first point used in the fit 
  virtual const  HyperDouble lengthFromFirstPointUpdated() const {return m_lengthFromFirstPointUpdated;};
  virtual void setLengthFromFirstPointUpdated(const HyperDouble& hd) {m_lengthFromFirstPointUpdated = hd;}




  //-------- Global acctions -----------------

  //! reset the point 
  //! (delete the measurements inside)
  virtual void hardReset();
  
  //!   reset the point
  virtual void reset();
  //!   strip the point (keep only the measurement)
  virtual void strip();

  //!  prints point information
  virtual void info(int verb) const;
  
 protected:
  
  //! is used for fits 
  bool m_isUsed;

  //! is updated flag
  bool m_isUpdated;
  
  //! quality
  std::map<std::string, double> m_qualityMap;
  
  //! state
  IState* m_state;
  
  //! measurement
  const IMeasurement* m_meas;
  
  //! projection of the state
  HyperVector m_projectionHV;
  
  //! residual
  HyperVector m_residualHV;

  //! path length from the first point used in the fit
  HyperDouble m_lengthFromFirstPointUpdated;

  //! Surface associated to the point
  ISurface* m_surface; //ME removed const
  
 protected:
  
  //! internal factory to create the trajectory owned points and state
  ITrajectoryFactory* m_factory;
  
};
#endif

---