JSBSim Flight Dynamics Model 1.0 (23 February 2013)
An Open Source Flight Dynamics and Control Software Library in C++

FGForce Class Reference

Utility class that aids in the conversion of forces between coordinate systems and calculation of moments. More...

#include <FGForce.h>

Inheritance diagram for FGForce:
Collaboration diagram for FGForce:

List of all members.

Public Types

enum  TransformType { tNone, tWindBody, tLocalBody, tCustom }

Public Member Functions

 FGForce (FGFDMExec *FDMExec)
 Constructor.
 FGForce (const FGForce &force)
 ~FGForce ()
 Destructor.
const FGColumnVector3GetActingLocation (void) const
double GetActingLocationX (void) const
double GetActingLocationY (void) const
double GetActingLocationZ (void) const
const FGColumnVector3GetAnglesToBody (void) const
double GetAnglesToBody (int axis) const
virtual const FGColumnVector3GetBodyForces (void)
double GetBodyXForce (void) const
double GetBodyYForce (void) const
double GetBodyZForce (void) const
const FGColumnVector3GetLocation (void) const
double GetLocationX (void) const
double GetLocationY (void) const
double GetLocationZ (void) const
const FGColumnVector3GetMoments (void) const
double GetPitch (void) const
TransformType GetTransformType (void) const
double GetYaw (void) const
void SetActingLocation (const FGColumnVector3 &vv)
void SetActingLocation (double x, double y, double z)
 Acting point of application.
double SetActingLocationX (double x)
double SetActingLocationY (double y)
double SetActingLocationZ (double z)
void SetAnglesToBody (double broll, double bpitch, double byaw)
void SetAnglesToBody (const FGColumnVector3 &vv)
void SetLocation (const FGColumnVector3 &vv)
void SetLocation (double x, double y, double z)
void SetLocationX (double x)
void SetLocationY (double y)
void SetLocationZ (double z)
void SetPitch (double pitch)
void SetTransformType (TransformType ii)
void SetYaw (double yaw)
const FGMatrix33Transform (void) const
void UpdateCustomTransformMatrix (void)

Protected Attributes

FGFDMExecfdmex
FGMatrix33 mT
TransformType ttype
FGColumnVector3 vActingXYZn
FGColumnVector3 vFn
FGColumnVector3 vH
FGColumnVector3 vMn
FGColumnVector3 vOrient
FGColumnVector3 vXYZn

Detailed Description


Resolution of Applied Forces into Moments and Body Axes Components


All forces acting on the aircraft that cannot be considered a change in weight need to be resolved into body axis components so that the aircraft acceleration vectors, both translational and rotational, can be computed. Furthermore, the moments produced by each force that does not act at a location corresponding to the center of gravity also need to be computed. Unfortunately, the math required to do this can be a bit messy and errors are easily introduced so the class FGForce was created to provide these services in a consistent and reusable manner.

Basic usage

FGForce requires that its users supply it with the location of the applied force vector in JSBSim structural coordinates, the sense of each axis in that coordinate system relative to the body system, the orientation of the vector also relative to body coordinates and, of course, the force vector itself. With this information it will compute both the body axis force components and the resulting moments. Any moments inherently produced by the native system can be supplied as well and they will be summed with those computed.

A good example for demonstrating the use of this class are the aerodynamic forces: lift, drag, and side force and the aerodynamic moments about the pitch, roll and yaw axes. These "native" forces and moments are computed and stored in the FGColumnVector objects vFs and vMoments. Their native coordinate system is often referred to as the wind system and is defined as a right-handed system having its x-axis aligned with the relative velocity vector and pointing towards the rear of the aircraft , the y-axis extending out the right wing, and the z-axis directed upwards. This is different than body axes; they are defined such that the x-axis is lies on the aircraft's roll axis and positive forward, the y-axis is positive out the right wing, and the z-axis is positive downwards. In this instance, JSBSim already provides the needed transform and FGForce can make use of it by calling SetTransformType() once an object is created:

FGForce fgf(FDMExec);
fgf.SetTransformType(tWindBody);

This call need only be made once for each object. The available transforms are defined in the enumerated type TransformType and are tWindBody, tLocalBody, tCustom, and tNone. The local-to-body transform, like the wind-to-body, also makes use of that already available in JSBSim. tNone sets FGForce to do no angular transform at all, and tCustom allows for modeling force vectors at arbitrary angles relative to the body system such as that produced by propulsion systems. Setting up and using a custom transform is covered in more detail below. Continuing with the example, the point of application of the aerodynamic forces, the aerodynamic reference point in JSBSim, also needs to be set:

fgf.SetLocation(x, y, z)

where x, y, and z are in JSBSim structural coordinates.

Initialization is complete and the FGForce object is ready to do its job. As stated above, the lift, drag, and side force are computed and stored in the vector vFs and need to be passed to FGForce:

fgf.SetNativeForces(vFs);

The same applies to the aerodynamic pitching, rolling and yawing moments:

fgf.SetNativeMoments(vMoments);

Note that storing the native forces and moments outside of this class is not strictly necessary, overloaded SetNativeForces() and SetNativeMoments() methods which each accept three doubles (rather than a vector) are provided and can be repeatedly called without incurring undue overhead. The body axes force vector can now be retrieved by calling:

vFb=fgf.GetBodyForces();

This method is where the bulk of the work gets done so calling it more than once for the same set of native forces and moments should probably be avoided. Note that the moment calculations are done here as well so they should be retrieved after calling the GetBodyForces() method:

vM=fgf.GetMoments();

As an aside, the native moments are not needed to perform the computations correctly so, if the FGForce object is not being used to store them then an alternate approach is to avoid the SetNativeMoments call and perform the sum

vMoments+=fgf.GetMoments();

after the forces have been retrieved.

Use of the Custom Transform Type

In cases where the native force vector is not aligned with the body, wind, or local coordinate systems a custom transform type is provided. A vectorable engine nozzle will be used to demonstrate its usage. Initialization is much the same:

FGForce fgf(FDMExec);
fgf.SetTransformType(tCustom);
fgf.SetLocation(x,y,z);

Except that here the tCustom transform type is specified and the location of the thrust vector is used rather than the aerodynamic reference point. Thrust is typically considered to be positive when directed aft while the body x-axis is positive forward and, if the native system is right handed, the z-axis will be reversed as well. These differences in sense need to be specified using by the call:

fgf.SetSense(-1,1,-1);

The angles are specified by calling the method:

fgf.SetAnglesToBody(pitch, roll, yaw);

in which the transform matrix is computed. Note that these angles should be taken relative to the body system and not the local as the names might suggest. For an aircraft with vectorable thrust, this method will need to be called every time the nozzle angle changes, a fixed engine/nozzle installation, on the other hand, will require it to be be called only once.

Retrieval of the computed forces and moments is done as detailed above.

    
CAVEAT: If the custom system is used to compute
    the wind-to-body transform, then the sign of the sideslip
    angle must be reversed when calling SetAnglesToBody().
    This is true because sideslip angle does not follow the right
    hand rule. Using the custom transform type this way
    should not be necessary, as it is already provided as a built
    in type (and the sign differences are correctly accounted for).
    

Use as a Base Type

For use as a base type, the native force and moment vector data members are defined as protected. In this case the SetNativeForces() and SetNativeMoments() methods need not be used and, instead, the assignments to vFn, the force vector, and vMn, the moments, can be made directly. Otherwise, the usage is similar.


Author:
Tony Peden
Version:
Id:
FGForce.h,v 1.17 2012/04/01 17:05:51 bcoconni Exp

Definition at line 225 of file FGForce.h.


Member Function Documentation

void SetActingLocation ( double  x,
double  y,
double  z 
) [inline]

JSBsim structural coords used (inches, x +back, y +right, z +up). This function sets the point at which the force acts - this may not be the same as where the object resides. One area where this is true is P-Factor modeling.

Parameters:
xacting location of force
yacting location of force
zacting location of force

Definition at line 265 of file FGForce.h.

                                                              {
    vActingXYZn(eX) = x;
    vActingXYZn(eY) = y;
    vActingXYZn(eZ) = z;
  }

The documentation for this class was generated from the following files: