deadReckoner.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 1992-2010 VT MAK
** All rights reserved.
*********************************************************************/



#ifndef DtDeadReckoner_H_
#define DtDeadReckoner_H_

#include "approximator.h"
#include <matrix/vlTaitBryan.h>
#include <matrix/vlDcm.h>
#include <matrix/vlVector.h>
#include "disEnums.h"

class DT_DLL_VLPROTIND DtDeadReckoner : public DtApproximator
{
public:

   DtDeadReckoner();

   virtual ~DtDeadReckoner();

   DtDeadReckoner(const DtDeadReckoner& orig);

   DtDeadReckoner& operator=(const DtDeadReckoner& orig);

   virtual DtApproximator* clone() const;

   virtual void setLocation(const DtVector& loc, DtTime curTime);

   virtual const DtVector& approxLocation(DtTime curTime) const;

   virtual const DtVector& deadReckonedLocation(DtTime curTime) const;

   virtual void setVelocity(const DtVector& vel, DtTime curTime);

   virtual const DtVector& approxVelocity(DtTime curTime) const;

   virtual const DtVector& deadReckonedVelocity(DtTime curTime) const;

   virtual void setOrientation(const DtTaitBryan& ori, DtTime curTime);

   virtual const DtTaitBryan& approxEuler(DtTime curTime) const;

   virtual const DtTaitBryan& deadReckonedEuler(DtTime curTime) const;

   virtual void setAcceleration(const DtVector& acc, DtTime curTime);
   virtual const DtVector& acceleration(DtTime curTime) const;

   virtual void setRotationalVelocity(const DtVector& vel, DtTime curTime);
   virtual const DtVector& rotationalVelocity(DtTime curTime) const;

   virtual const DtDcm& approxBodyToGeoc(DtTime curTime) const;

   virtual const DtDcm& deadReckonedBodyToGeoc(DtTime curTime) const;

   virtual void setAlgorithm(DtDeadReckonTypes alg);
   virtual DtDeadReckonTypes algorithm() const;

   virtual void deadReckonPosition(DtTime dt, 
      const DtVector& oldPos, const DtVector& oldVel,
      const DtVector& oldAccel,
      DtVector& newVel, DtVector& newPos);

   virtual void deadReckonOrientation(DtTime dt, 
      const DtDcm& old_b2w,
      const DtDirectedRotRate& drr,
      DtDcm& new_b2w);

public:

   static void deadReckonPosition(
      DtTime dt, DtDeadReckonTypes algorithm,
      const DtVector& oldPos, const DtVector& oldVel,
      const DtVector& oldAccel,
      DtVector& newVel, DtVector& newPos);

   static void deadReckonOrientation(
      DtTime dt, DtDeadReckonTypes algorithm,
      const DtDcm& old_b2w,
      const DtDirectedRotRate& drr,
      DtDcm& new_b2w);

protected:

   virtual void deadReckonLoc(DtTime curTime) const;

   virtual void deadReckonBodyToGeoc(DtTime curTime) const;

   virtual void deadReckonEuler(DtTime curTime) const;

   virtual int isRotational();

   DtDeadReckoner* self() const;

protected:

   static int isRotational(DtDeadReckonTypes algorithm);

protected:

   DtVector myLocAtTimeOfValidity;
   DtVector myVelAtTimeOfValidity;
   DtTime mySimTimePosDataValid;
   DtDcm myBodyToGeocAtTimeOfValidity;
   DtTime mySimTimeOrientDataValid;

   DtVector myDRLoc;
   DtVector myDRVel;
   DtTime myDRPosTime;
   DtDcm myDRBodyToGeoc;
   DtTime myDRBodyToGeocTime;
   DtTaitBryan myDREuler;
   DtTime myDREulerTime;
   DtDirectedRotRate myDirectedRotRate;
   DtDeadReckonTypes myAlgorithm;
   DtVector myAccel;
   DtBodyRates myRotVel;
};

inline DtDeadReckoner* DtDeadReckoner::self() const
{
   return (DtDeadReckoner*)this;
}

inline const DtVector& DtDeadReckoner::deadReckonedLocation(DtTime curTime) const
{
   deadReckonLoc(curTime);
   return myDRLoc;
}

inline const DtVector& DtDeadReckoner::approxLocation(DtTime curTime) const
{
   return deadReckonedLocation(curTime);
}

inline const DtVector& DtDeadReckoner::deadReckonedVelocity(DtTime curTime) const
{
   deadReckonLoc(curTime);
   return myDRVel;
}

inline const DtVector& DtDeadReckoner::approxVelocity(DtTime curTime) const
{
   return deadReckonedVelocity(curTime);
}

inline const DtDcm& DtDeadReckoner::deadReckonedBodyToGeoc(DtTime curTime) const
{
   deadReckonBodyToGeoc(curTime);
   return myDRBodyToGeoc;
}

inline const DtDcm& DtDeadReckoner::approxBodyToGeoc(DtTime curTime) const
{
   return deadReckonedBodyToGeoc(curTime);
}

inline const DtTaitBryan& DtDeadReckoner::deadReckonedEuler(
   DtTime curTime) const
{
   deadReckonEuler(curTime);
   return myDREuler;
}

inline const DtTaitBryan& DtDeadReckoner::approxEuler(DtTime curTime) const
{
   return deadReckonedEuler(curTime);
}

inline void DtDeadReckoner::setAlgorithm(DtDeadReckonTypes alg)
{
   myAlgorithm = alg;
}

inline DtDeadReckonTypes DtDeadReckoner::algorithm() const
{
   return myAlgorithm;
}

inline const DtVector& DtDeadReckoner::acceleration(DtTime curTime) const
{
   return myAccel;
}

inline const DtVector& DtDeadReckoner::rotationalVelocity(DtTime curTime) const
{
   return myRotVel;
}

#endif