 |
JSBSim Flight Dynamics Model
1.2.0 (05 Nov 2023)
An Open Source Flight Dynamics and Control Software Library in C++
|
|
JSBSim Flight Dynamics Model
1.2.0 (05 Nov 2023)
An Open Source Flight Dynamics and Control Software Library in C++
|
Utility class that aids in the conversion of forces between coordinate systems and calculation of moments.
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 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.
@author Tony Peden
#include <FGForce.h>
Inheritance diagram for FGForce: Collaboration diagram for FGForce:Public Types | |
| enum | TransformType { tNone , tWindBody , tLocalBody , tInertialBody , tCustom } |
| Public Types inherited from FGJSBBase | |
| enum | { eL = 1 , eM , eN } |
| Moments L, M, N. | |
| enum | { eP = 1 , eQ , eR } |
| Rates P, Q, R. | |
| enum | { eU = 1 , eV , eW } |
| Velocities U, V, W. | |
| enum | { eX = 1 , eY , eZ } |
| Positions X, Y, Z. | |
| enum | { ePhi = 1 , eTht , ePsi } |
| Euler angles Phi, Theta, Psi. | |
| enum | { eDrag = 1 , eSide , eLift } |
| Stability axis forces, Drag, Side force, Lift. | |
| enum | { eRoll = 1 , ePitch , eYaw } |
| Local frame orientation Roll, Pitch, Yaw. | |
| enum | { eNorth = 1 , eEast , eDown } |
| Local frame position North, East, Down. | |
| enum | { eLat = 1 , eLong , eRad } |
| Locations Radius, Latitude, Longitude. | |
| enum | { inNone = 0 , inDegrees , inRadians , inMeters , inFeet } |
| Conversion specifiers. | |
Public Member Functions | |
| FGForce (FGFDMExec *FDMExec) | |
| Constructor. | |
| virtual | ~FGForce () |
| Destructor. | |
| const FGColumnVector3 & | GetActingLocation (void) const |
| double | GetActingLocationX (void) const |
| double | GetActingLocationY (void) const |
| double | GetActingLocationZ (void) const |
| double | GetAnglesToBody (int axis) const |
| const FGColumnVector3 & | GetAnglesToBody (void) const |
| virtual const FGColumnVector3 & | GetBodyForces (void) |
| double | GetBodyXForce (void) const |
| double | GetBodyYForce (void) const |
| double | GetBodyZForce (void) const |
| const FGColumnVector3 & | GetLocation (void) const |
| double | GetLocationX (void) const |
| double | GetLocationY (void) const |
| double | GetLocationZ (void) const |
| const FGColumnVector3 & | GetMoments (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. More... | |
| double | SetActingLocationX (double x) |
| double | SetActingLocationY (double y) |
| double | SetActingLocationZ (double z) |
| void | SetAnglesToBody (const FGColumnVector3 &vv) |
| void | SetAnglesToBody (double broll, double bpitch, double byaw) |
| 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 FGMatrix33 & | Transform (void) const |
| void | UpdateCustomTransformMatrix (void) |
| Public Member Functions inherited from FGJSBBase | |
| FGJSBBase () | |
| Constructor for FGJSBBase. | |
| virtual | ~FGJSBBase () |
| Destructor for FGJSBBase. | |
| void | disableHighLighting (void) |
| Disables highlighting in the console output. | |
Protected Attributes | |
| FGFDMExec * | fdmex |
| std::shared_ptr< FGMassBalance > | MassBalance |
| FGMatrix33 | mT |
| TransformType | ttype |
| FGColumnVector3 | vActingXYZn |
| FGColumnVector3 | vFn |
| FGColumnVector3 | vMn |
| FGColumnVector3 | vOrient |
| FGColumnVector3 | vXYZn |
Additional Inherited Members | |
| Static Public Member Functions inherited from FGJSBBase | |
| static const std::string & | GetVersion (void) |
| Returns the version number of JSBSim. More... | |
| static constexpr double | KelvinToFahrenheit (double kelvin) |
| Converts from degrees Kelvin to degrees Fahrenheit. More... | |
| static constexpr double | CelsiusToRankine (double celsius) |
| Converts from degrees Celsius to degrees Rankine. More... | |
| static constexpr double | RankineToCelsius (double rankine) |
| Converts from degrees Rankine to degrees Celsius. More... | |
| static constexpr double | KelvinToRankine (double kelvin) |
| Converts from degrees Kelvin to degrees Rankine. More... | |
| static constexpr double | RankineToKelvin (double rankine) |
| Converts from degrees Rankine to degrees Kelvin. More... | |
| static constexpr double | FahrenheitToCelsius (double fahrenheit) |
| Converts from degrees Fahrenheit to degrees Celsius. More... | |
| static constexpr double | CelsiusToFahrenheit (double celsius) |
| Converts from degrees Celsius to degrees Fahrenheit. More... | |
| static constexpr double | CelsiusToKelvin (double celsius) |
| Converts from degrees Celsius to degrees Kelvin. More... | |
| static constexpr double | KelvinToCelsius (double kelvin) |
| Converts from degrees Kelvin to degrees Celsius. More... | |
| static constexpr double | FeetToMeters (double measure) |
| Converts from feet to meters. More... | |
| static bool | EqualToRoundoff (double a, double b) |
| Finite precision comparison. More... | |
| static bool | EqualToRoundoff (float a, float b) |
| Finite precision comparison. More... | |
| static bool | EqualToRoundoff (float a, double b) |
| Finite precision comparison. More... | |
| static bool | EqualToRoundoff (double a, float b) |
| Finite precision comparison. More... | |
| static constexpr double | Constrain (double min, double value, double max) |
| Constrain a value between a minimum and a maximum value. | |
| static constexpr double | sign (double num) |
| Static Public Attributes inherited from FGJSBBase | |
| static char | highint [5] = {27, '[', '1', 'm', '\0' } |
| highlights text | |
| static char | halfint [5] = {27, '[', '2', 'm', '\0' } |
| low intensity text | |
| static char | normint [6] = {27, '[', '2', '2', 'm', '\0' } |
| normal intensity text | |
| static char | reset [5] = {27, '[', '0', 'm', '\0' } |
| resets text properties | |
| static char | underon [5] = {27, '[', '4', 'm', '\0' } |
| underlines text | |
| static char | underoff [6] = {27, '[', '2', '4', 'm', '\0' } |
| underline off | |
| static char | fgblue [6] = {27, '[', '3', '4', 'm', '\0' } |
| blue text | |
| static char | fgcyan [6] = {27, '[', '3', '6', 'm', '\0' } |
| cyan text | |
| static char | fgred [6] = {27, '[', '3', '1', 'm', '\0' } |
| red text | |
| static char | fggreen [6] = {27, '[', '3', '2', 'm', '\0' } |
| green text | |
| static char | fgdef [6] = {27, '[', '3', '9', 'm', '\0' } |
| default text | |
| static short | debug_lvl = 1 |
| Static Protected Member Functions inherited from FGJSBBase | |
| static std::string | CreateIndexedPropertyName (const std::string &Property, int index) |
| Static Protected Attributes inherited from FGJSBBase | |
| static constexpr double | radtodeg = 180. / M_PI |
| static constexpr double | degtorad = M_PI / 180. |
| static constexpr double | hptoftlbssec = 550.0 |
| static constexpr double | psftoinhg = 0.014138 |
| static constexpr double | psftopa = 47.88 |
| static constexpr double | fttom = 0.3048 |
| static constexpr double | ktstofps = 1852./(3600*fttom) |
| static constexpr double | fpstokts = 1.0 / ktstofps |
| static constexpr double | inchtoft = 1.0/12.0 |
| static constexpr double | m3toft3 = 1.0/(fttom*fttom*fttom) |
| static constexpr double | in3tom3 = inchtoft*inchtoft*inchtoft/m3toft3 |
| static constexpr double | inhgtopa = 3386.38 |
| static constexpr double | slugtolb = 32.174049 |
| Note that definition of lbtoslug by the inverse of slugtolb and not to a different constant you can also get from some tables will make lbtoslug*slugtolb == 1 up to the magnitude of roundoff. More... | |
| static constexpr double | lbtoslug = 1.0/slugtolb |
| static constexpr double | kgtolb = 2.20462 |
| static constexpr double | kgtoslug = 0.06852168 |
| static const std::string | needed_cfg_version = "2.0" |
| static const std::string | JSBSim_version = JSBSIM_VERSION " " __DATE__ " " __TIME__ |
|
inline |
Acting point of application.
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.
| x | acting location of force |
| y | acting location of force |
| z | acting location of force |
1.9.1 
