Base_PropagatorB.h

Go to the documentation of this file.

//! \authors{Anselmo Cervera, Juan J. Gomez-Cadenas and Jose Angel Hernando}
//! \date{11/01}

#ifndef PropagatorB_h
#define PropagatorB_h 1

#include "Kalman/Interface_IPropagator.h"
#include "Kalman/Interface_IModel.h"

//! Basic implementation for propagator
/*!
    A model has:
    
        - A pointer to a IModel to refer to
        
    A model do:
    
        - the propagation via the IModel    

    A propagator preserves from the last propagation:
        
        - the F matrix
        
        - the Q matrix
        
        - the initial State
        
        - the end State
        
        - the end surface
        
*/
class PropagatorB : public IPropagator 
{
 public:

  //! default constructor
  PropagatorB() {}

  //! Constructor providing the model  
  PropagatorB(IModel* pm){m_model=pm;}

  //! default destructor
  virtual ~PropagatorB() {}
  
  //----------
  //! Propagate an state to a given length
  //! It compute the dynamicHV and the runningHV in the new surface, set the values in the state
  //! It has the extra possibility of propagate an state with a different model
  //! (note that the results it is the end (State) which is not const!)
  virtual bool propagate(const IState& ini, 
             const ISurface& is, 
             const HyperVector& natHV, 
             IState& end);
    
  //!  Returns the dynamicHV of the state when propagate an state to a surface
  virtual HyperVector computeDynamicHV(const IState& ini, 
                       const HyperVector& natHV,
                       const HyperVector& runHV);


  //! computes the dynamic vector
  virtual EVector computeDynamicVector(const IState& iniS, 
                       const HyperVector& natHV, 
                       const HyperVector& runHV);

  
  //!  Returns the runningHV of the state when propagate an state to a surface
  virtual HyperVector computeRunningHV(const IState& ini, const HyperVector& natHV)
  {
    std::cout << "PropagatorB::computeRunningHV called with:  " << natHV << std::endl;
    ini.info(2);
    return natHV;
  }  //ME added warning and return
  

   //! Computes the transport matrix F
  virtual EMatrix computeFMatrix(const IState& ini, 
                 const HyperVector& natHV,
                 const HyperVector& runHV);
   
  //----------

  //!   If the Propagator it is linear returns the F matrix
  //!   (if not returns the 1st term of Taylor expansion)
  virtual EMatrix FMatrix()  {return m_F;}
  
  //!   Returns the matrix of random extra errors added to the state during the
  //!   progation (null if non). This matrix is calculated by the Noiser.
  virtual EMatrix QMatrix() {return m_Q;}

  //! Returns the A matrix (dx/dr) for the Kalman vertex fit
  virtual EMatrix AMatrix(const IPoint& point);

  //! Returns the B matrix (dx/dp) for the Kalman vertex fit
  virtual EMatrix BMatrix(const IPoint& point);

  
  //----------

  //! get dimension of the dynamic vector
  virtual const int dynamicNdim() const {return m_model->dynamicNdim();}

  //-------------

  //! set propagator verbosity 
  virtual void setVerbosity(int v){m_verbosity=v;}
  //! return propagator verbosity 
  virtual int verbosity() {return m_verbosity;}  

  //! returns specific propagator properties
  virtual std::string propagatorProperties() 
    {cout << "There are not specific properties !!!" <<endl; return "";}
  //! set properties of the propagator in the case there is a choice
  virtual void setPropagatorProperties(void* prop)
     {cout << "You cannot select specific properties !!! " << (int)prop << endl;};  //ME added pointer to prop


  
  // temporary // todo
  virtual bool applyEnergyLoss(IState& state,
                   const HyperVector& natHV);

  virtual double  computeEnergyLoss(const double m, const double e0, 
                    const double s);

 protected:

  //! return a model
  virtual const IModel& model() const {return *m_model;};
  //! set a model
  virtual void setModel(IModel* p) {m_model = p;};

  //! compute parameters needed for the actual propagation
  virtual void computeParameters(const IState& iniS, 
                 const ISurface& surf, 
                 const HyperVector& natHV){    
    if (m_verbosity > 9){
      iniS.info();
      surf.info();
      natHV.info();
    }
  }

 protected:
  
  //! the initial state (not owner by the propagator)
  const IState* m_iniState;
  
  //! the end surface (not owner by the propagator)
  const ISurface* m_surface;
  
  //! the final state (not owner by the propagator)
  IState* m_endState;
  
  //! the F matrix of the last propagation  
  EMatrix m_F;
  
  //! The Q matrix of the last propagation
  EMatrix m_Q;

  //! A pointer to the model
  IModel* m_model;  

  //---
  int m_verbosity;
          
};

#endif

---