FGForce.h

Go to the documentation of this file.

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 Header:       FGForce.h
 Author:       Tony Peden
 Date started: 5/20/00
 
 ------------- Copyright (C) 1999  Anthony K. Peden (apeden@earthlink.net) -----
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU Lesser General Public License as published by the Free
 Software Foundation; either version 2 of the License, or (at your option) any
 later version.
 
 This program is distributed in the hope that it will be useful, but WITHOUT
 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
 details.
 
 You should have received a copy of the GNU Lesser General Public License along
 with this program; if not, write to the Free Software Foundation, Inc., 59
 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
 Further information about the GNU Lesser General Public License can also be
 found on the world wide web at http://www.gnu.org.
 
 
 HISTORY
--------------------------------------------------------------------------------
5/20/00  TP   Created
 
 
FUNCTIONAL DESCRIPTION
--------------------------------------------------------------------------------
 
The purpose of this class is to provide storage for computed forces and
encapsulate all the functionality associated with transforming those
forces from their native coord system to the body system.  This includes
computing the moments due to the difference between the point of application
and the cg.
 
CAVEAT:  if the custom transform is used for wind-to-body transforms then the
         user *must* always pass this class the negative of beta. This is true
         because sideslip angle does not follow the right hand rule i.e. it is
         positive for aircraft nose left sideslip.  Note that use of the custom
         transform for this purpose shouldn't be necessary as it is already
         provided by SetTransform(tWindBody) and is not subject to the same
         restriction.
 
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SENTRY
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
 
#ifndef FGFORCE_H
#define FGFORCE_H
 
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
INCLUDES
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
 
#include "FGJSBBase.h"
#include "math/FGMatrix33.h"
 
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
FORWARD DECLARATIONS
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
 
namespace JSBSim {
 
class FGFDMExec;
class FGMassBalance;
 
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
CLASS DOCUMENTATION
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

 
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
CLASS DECLARATION
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
 
class FGForce : public FGJSBBase
{
public:
  explicit FGForce(FGFDMExec *FDMExec);
  FGForce(const FGForce& force);

  virtual ~FGForce();
 
  enum TransformType { tNone, tWindBody, tLocalBody, tCustom };
 
  virtual const FGColumnVector3& GetBodyForces(void);
 
  inline double GetBodyXForce(void) const { return vFb(eX); }
  inline double GetBodyYForce(void) const { return vFb(eY); }
  inline double GetBodyZForce(void) const { return vFb(eZ); }
  inline const FGColumnVector3& GetMoments(void) const { return vM; }
 
  // Normal point of application, JSBsim structural coords
  // (inches, x +back, y +right, z +up)
  inline void SetLocation(double x, double y, double z) {
    vXYZn(eX) = x;
    vXYZn(eY) = y;
    vXYZn(eZ) = z;
    SetActingLocation(x, y, z);
  }

  inline void SetActingLocation(double x, double y, double z) {
    vActingXYZn(eX) = x;
    vActingXYZn(eY) = y;
    vActingXYZn(eZ) = z;
  }
  inline void SetLocationX(double x) {vXYZn(eX) = x; vActingXYZn(eX) = x;}
  inline void SetLocationY(double y) {vXYZn(eY) = y; vActingXYZn(eY) = y;}
  inline void SetLocationZ(double z) {vXYZn(eZ) = z; vActingXYZn(eZ) = z;}
  inline double SetActingLocationX(double x) {vActingXYZn(eX) = x; return x;}
  inline double SetActingLocationY(double y) {vActingXYZn(eY) = y; return y;}
  inline double SetActingLocationZ(double z) {vActingXYZn(eZ) = z; return z;}
  inline void SetLocation(const FGColumnVector3& vv) { vXYZn = vv; SetActingLocation(vv);}
  inline void SetActingLocation(const FGColumnVector3& vv) { vActingXYZn = vv; }
 
  inline double GetLocationX( void ) const { return vXYZn(eX);}
  inline double GetLocationY( void ) const { return vXYZn(eY);}
  inline double GetLocationZ( void ) const { return vXYZn(eZ);}
  inline double GetActingLocationX( void ) const { return vActingXYZn(eX);}
  inline double GetActingLocationY( void ) const { return vActingXYZn(eY);}
  inline double GetActingLocationZ( void ) const { return vActingXYZn(eZ);}
  const FGColumnVector3& GetLocation(void) const { return vXYZn; }
  const FGColumnVector3& GetActingLocation(void) const { return vActingXYZn; }
 
  //these angles are relative to body axes, not earth!!!!!
  //I'm using these because pitch, roll, and yaw are easy to visualize,
  //there's no equivalent to roll in wind axes i.e. alpha, ? , beta
  //making up new names or using these is a toss-up: either way people
  //are going to get confused.
  //They are in radians.
 
  void SetAnglesToBody(double broll, double bpitch, double byaw);
  inline void  SetAnglesToBody(const FGColumnVector3& vv) {
    SetAnglesToBody(vv(eRoll), vv(ePitch), vv(eYaw));
  }
 
  void UpdateCustomTransformMatrix(void);
  void SetPitch(double pitch) {vOrient(ePitch) = pitch; UpdateCustomTransformMatrix();}
  void SetYaw(double yaw) {vOrient(eYaw) = yaw; UpdateCustomTransformMatrix();}
 
  double GetPitch(void) const {return vOrient(ePitch);}
  double GetYaw(void) const {return vOrient(eYaw);}
 
  inline const FGColumnVector3& GetAnglesToBody(void) const {return vOrient;}
  inline double GetAnglesToBody(int axis) const {return vOrient(axis);}
 
  inline void SetTransformType(TransformType ii) { ttype=ii; }
  inline TransformType GetTransformType(void) const { return ttype; }
 
  const FGMatrix33& Transform(void) const;
 
protected:
  FGFDMExec *fdmex;
  FGMassBalance* MassBalance;
  FGColumnVector3 vFn;
  FGColumnVector3 vMn;
  FGColumnVector3 vOrient;
  TransformType ttype;
  FGColumnVector3 vXYZn;
  FGColumnVector3 vActingXYZn;
  FGMatrix33 mT;
 
private:
  FGColumnVector3 vFb;
  FGColumnVector3 vM;
 
  void Debug(int from);
};
}
#endif