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.
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 not 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.
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).
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.