Base_ModelB.h

Go to the documentation of this file.

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

#ifndef ModelB_h
#define ModelB_h 1

#include <assert.h>

#include "Kalman/Interface_IModel.h"

//! Base class for Model
class ModelB : public IModel
{
 public:

  //! default constructor
  ModelB(){m_measNdim=1;m_dynamicNdim=1;load();}

  //! constructor providing the dimensions of the state and the measurement
  ModelB(int measNdim, int dynamicNdim){m_measNdim=measNdim; m_dynamicNdim=dynamicNdim;load();}
    
  //! destructor
  virtual ~ModelB(){}

  //--------

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

  //------------- PROJECTOR -------------------------
 
  //! set the projector by name
  virtual void setProjector(std::string name) {m_projectorName=name;}
  //! add a projector to the list
  virtual void addProjector(std::string name, IProjector* p){m_projectorMap[name]=p;}

  //! returns the H matrix for the state
  virtual EMatrix HMatrix(const IState& state, const IMeasurement& meas)
  {return projector(meas.type()).HMatrix(state, meas);} 



  //! project the state of the point 
  virtual bool project(IPoint& point)
    {return projector(point.measType()).project(point);} 
  

  //!   Project the dynamic vector
  virtual EVector projectionVector(const IState& state, const IMeasurement& meas)
  {return projector(meas.type()).projectionVector(state, meas);} 


  //!   Project the dynamic matrix
  virtual EMatrix projectionMatrix(const IState& state, const IMeasurement& meas)
    {return projector(meas.type()).projectionMatrix(state, meas);}  

  //!   Project the dynamicHV
  virtual HyperVector projectionHV(const IState& state, const IMeasurement& meas)
    {return projector(meas.type()).projectionHV(state, meas);}

  
  virtual EMatrix measurementProjector(const IState& state, const IMeasurement& meas)
    {return projector(meas.type()).measurementProjector(state, meas);}


  //! Returns the A matrix (dx/dr) for the Kalman vertex fit
  virtual EMatrix AMatrix(const IState& state, const IMeasurement& meas)
    {return projector(meas.type()).AMatrix(state, meas);}

  //! Returns the B matrix (dx/dp) for the Kalman vertex fit
  virtual EMatrix BMatrix(const IState& state, const IMeasurement& meas)
    {return projector(meas.type()).BMatrix(state, meas);}

  //! Returns the c0 vector for the Kalman vertex fit
  virtual EVector c0(const IState& state, const IMeasurement& meas)
    {return projector(meas.type()).c0(state, meas);}




  //------------- PROPAGATOR ------------------------

  //! returns the propagator name
  virtual std::string propagatorName() const {return m_propagatorName;}
  //! set the propagator by name
  virtual void setPropagator(std::string name) {m_propagatorName=name;}
  //! set externally the propagator
  virtual void addPropagator(std::string name, IPropagator* p) {m_propagatorMap[name]=p;}

  //! set propagator vervosity 
  virtual void setPropagatorVerbosity(int v){propagator().setVerbosity(v);}
  //! return propagator vervosity 
  virtual int propagatorVerbosity(){return propagator().verbosity();}      

  //! returns specific propagator properties
  virtual std::string propagatorProperties() 
    {return propagator().propagatorProperties();}
  //! set properties of the propagator in the case there is a choice
  virtual void setPropagatorProperties(void* prop)
     {propagator().setPropagatorProperties(prop);} 

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


  //! Propagate an state to a surface
  //! 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
  virtual bool propagate(const IState& iniS,
             const ISurface& surf, 
             IState& finalS);


  //!   Propagate an state to a given length
  virtual bool propagate(const IState& iniS,
             const ISurface& surf,
             const HyperVector& natHV, 
             IState& finalS);



  //!   Propagate an state in steps
  virtual bool propagateInSteps(const IState& iniS,
                const ISurface& surf,
                const HyperVector& natHV, 
                IState& finalS);

  // functions for propagation in steps
  virtual void actionBeforeFirstStep(const ISurface& surf, IState& state);
  virtual void actionBeforeStep(HyperVector& natHV, IState& state);
  virtual void actionAfterStep(HyperVector& natHV, IState& state);
  virtual void actionBeforeLastStep(const ISurface& surf, IState& state);

  
  //!  Returns the dynamicHV of the state when propagate an state to a surface
  virtual HyperVector propagateDynamicHV(const IState& iniS, 
                     const ISurface& surf);
  

  // computes the path lentgh between a state and a straight line, 
  // providing rl0 and ul0 such that rl = rl0 + ul0*s
  virtual double pathLengthToStraightLine(const IState& iniS, 
                      const EVector& rl0,
                      const EVector& ul0)
    { 
      cout << "ModelB  ERROR:   pathLengthToStraightLine " << rl0 << " " << ul0 << endl; 
      iniS.info(2);
      assert(false);
      return -1.0;
    }  //ME added return and warning mesages


  //---------------- NOISERS -------------------------

  //! add a Noiser to the Model
  virtual void addNoiser(std::string name, INoiser* noiser) 
    {noiser->setName(name);m_noiserVector.push_back(noiser);}

  //! number of noisers
  virtual int nNoisers() const { return m_noiserVector.size();}

  //! set is Used 
  virtual void setNoiserIsUsed(std::string name, bool flag) 
    {noiser(name).setIsUsed(flag);}
  virtual bool noiserIsUsed(std::string name)    //TODO const
    {return noiser(name).isUsed();}

  //! Compute the Q matrix
  virtual EMatrix computeQMatrix(const IState& iniS, const HyperVector& natHV) const;


  //------------------ SURFACE INTERSECTOR ---------------

  //! add a surface intersector
  virtual void addSurfaceIntersector(std::string name, IModelSurfaceIntersector* surfaceIntersector) 
    {m_surfaceIntersectorMap[name]=surfaceIntersector;}
  

  //! computes the natural HyperVector when intersecting a surface
  virtual bool naturalHVAtSurface(const IState& iniS,
                  const ISurface& surf, 
                  HyperVector& natHV)   
    {return surfaceIntersector(surf).naturalHVAtSurface(iniS, surf, natHV);}

  //! computes the natural HyperVector when intersecting a surface and check that the intersection point 
  //! is inside the surface
  virtual bool naturalHVAtFiniteSurface(const IState& iniS, 
                    const ISurface& surf,
                    HyperVector& natHV)     
    {return surfaceIntersector(surf).naturalHVAtFiniteSurface(iniS, surf, natHV);}

  

  //! computes the surface perpendicular to the trajectory and containing the point measHV. 
  //! Computes also the natural HyperVector when intersecting that surface.
  virtual bool naturalHVAtNormalSurface(const IState& prevState, 
                    const HyperVector& measHV,
                    const std::string surfType,
                    ISurface& surf,
                    HyperVector& natHV)    
    {return surfaceIntersector(surfType).naturalHVAtNormalSurface(prevState, measHV, surf, natHV);}

  //---------

  //! get dimension of the dynamic vector
  virtual const int dynamicNdim() const {return m_dynamicNdim;}
  //! set dimension of the dynamic vector
  virtual void setDynamicNdim(const int dim) {m_dynamicNdim=dim;}
  
  //! get dimension of the measurement
  virtual const int measNdim() const {return m_measNdim;}
  //! set dimension of the measurement vector
  virtual void setMeasNdim(const int dim) {m_measNdim=dim;}

  //-------

  //!  The name of the model
  virtual void setName(std::string name) {m_name = name;}
  //!   Return of the model name
  virtual std::string name() const {return m_name;}
  
  //!  The volume  //TODO
  virtual void setVolume(IVolume& vol);
  virtual IVolume& volume() const {return *m_volume;}

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

  //! list the available options
  virtual void menu() const;

  //! returns the components
  virtual const int irun()    const {return m_irun;}
  virtual const int istate0() const {return m_istate0;}
  virtual const int istate1() const {return m_istate1;}

  //! interpretation of states
  virtual const EVector directionVector(const IState& state) const { state.info(2); return EVector( 1, 0 ); }       //ME added info and return
  virtual const EVector positionVector(const IState& state) const { state.info(2); return EVector( 1, 0 ); }        //ME added info and return
  virtual const EMatrix directionMatrix(const IState& state) const { state.info(2); return EMatrix( 1, 1, 0 ); }    //ME added info and return
  virtual const EMatrix positionMatrix(const IState& state) const { state.info(2); return EMatrix( 1, 1, 0 ); }     //ME added info and return
  virtual const EVector momentumVector(const IState& state) const { state.info(2); return EVector( 1, 0 ); }        //ME added info and return
  virtual const EMatrix momentumMatrix(const IState& state) const { state.info(2); return EMatrix( 1, 1, 0 ); }     //ME added info and return
  virtual const double momentum(const IState& state) const { state.info(2); return -1.0; };             //ME added info and return
  virtual const double momentumError2(const IState& state) const { state.info(2); return -1.0; };               //ME added info and return
  virtual const double charge(const IState& state) const { state.info(2); return 0; };                  //ME added info and return

  //! interpretation of vertex parameters
  virtual const EVector directionVectorVertex(const IState& state) const;
  virtual const EVector positionVectorVertex(const IState& state) const;
  virtual const EMatrix directionMatrixVertex(const IState& state) const;
  virtual const EMatrix positionMatrixVertex(const IState& state) const;
  virtual const EVector momentumVectorVertex(const IState& state) const;
  virtual const EMatrix momentumMatrixVertex(const IState& state) const;
  virtual const EMatrix positionMomentumMatrixVertex(const IState& state) const;

 protected:
  
  //! load the predefined projectors and propagators
  virtual void load();
  
  //! returns the projector
  virtual IProjector& projector(std::string name) {return *m_projectorMap[name];}
 
 
  //! returns the propagator
  virtual IPropagator& propagator() {return *m_propagatorMap[m_propagatorName];}

  //! returns the noiser
  virtual INoiser& noiser(int i) const {return *m_noiserVector[i];} 
  virtual INoiser& noiser(std::string name);

  //! returns the Surface Intersector for a given surface type
  virtual IModelSurfaceIntersector& surfaceIntersector(std::string name)   
    {return *m_surfaceIntersectorMap[name];}
   

  //! returns the Surface Intersector for a given surface
  virtual IModelSurfaceIntersector& surfaceIntersector(const ISurface& surf) 
    {return *m_surfaceIntersectorMap[surf.type()];}
      
  //temporary //todo
  virtual EVector energyLossParameters(){ return m_energyLossParameters;}

 protected:

  std::string m_name;

  IVolume* m_volume;

  int m_dynamicNdim;
  int m_measNdim;
  
  std::string m_propagatorName;
  std::string m_projectorName;

  
  std::map<std::string, IPropagator*> m_propagatorMap;
  std::map<std::string, IProjector*> m_projectorMap;

  std::vector<INoiser*> m_noiserVector; 

  std::map<std::string, IModelSurfaceIntersector*> m_surfaceIntersectorMap; 

  int m_verbosity;

  
  // components 
  int m_irun;
  int m_istate0;
  int m_istate1;
        


  double m_stepEnergyLoss;
  EVector m_energyLossParameters;


  bool m_propagateInSteps;
  bool m_propagateInStepsNow;
        
  double m_stepLength;  

  int m_nSteps;
  int m_nMaxSteps;

  double m_side;

};

#endif

---