FGLGear Class Reference

Detailed Description

Landing gear model.

Calculates forces and moments due to landing gear reactions. This is done in several steps, and is dependent on what kind of gear is being modeled. Here are the parameters that can be specified in the config file for modeling landing gear:

Physical Characteristics

1. X, Y, Z location, in inches in structural coordinate frame
2. Spring constant, in lbs/ft
3. Damping coefficient, in lbs/ft/sec
4. Dynamic Friction Coefficient
5. Static Friction Coefficient

Operational Properties

1. Name
2. Brake Group Membership {one of LEFT | CENTER | RIGHT | NOSE | TAIL | NONE}
3. Max Steer Angle, in degrees

Algorithm and Approach to Modeling

1. Find the location of the uncompressed landing gear relative to the CG of the aircraft. Remember, the structural coordinate frame that the aircraft is defined in is: X positive towards the tail, Y positive out the right side, Z positive upwards. The locations of the various parts are given in inches in the config file.
2. The vector giving the location of the gear (relative to the cg) is rotated 180 degrees about the Y axis to put the coordinates in body frame (X positive forwards, Y positive out the right side, Z positive downwards, with the origin at the cg). The lengths are also now given in feet.
3. The new gear location is now transformed to the local coordinate frame using the body-to-local matrix. (Mb2l).
4. Knowing the location of the center of gravity relative to the ground (height above ground level or AGL) now enables gear deflection to be calculated. The gear compression value is the local frame gear Z location value minus the height AGL. [Currently, we make the assumption that the gear is oriented - and the deflection occurs in - the Z axis only. Additionally, the vector to the landing gear is currently not modified - which would (correctly) move the point of contact to the actual compressed-gear point of contact. Eventually, articulated gear may be modeled, but initially an effort must be made to model a generic system.] As an example, say the aircraft left main gear location (in local coordinates) is Z = 3 feet (positive) and the height AGL is 2 feet. This tells us that the gear is compressed 1 foot.
5. If the gear is compressed, a Weight-On-Wheels (WOW) flag is set.
6. With the compression length calculated, the compression velocity may now be calculated. This will be used to determine the damping force in the strut. The aircraft rotational rate is multiplied by the vector to the wheel to get a wheel velocity in body frame. That velocity vector is then transformed into the local coordinate frame.
7. The aircraft cg velocity in the local frame is added to the just-calculated wheel velocity (due to rotation) to get a total wheel velocity in the local frame.
8. The compression speed is the Z-component of the vector.
9. With the wheel velocity vector no longer needed, it is normalized and multiplied by a -1 to reverse it. This will be used in the friction force calculation.
10. Since the friction force takes place solely in the runway plane, the Z coordinate of the normalized wheel velocity vector is set to zero.
11. The gear deflection force (the force on the aircraft acting along the local frame Z axis) is now calculated given the spring and damper coefficients, and the gear deflection speed and stroke length. Keep in mind that gear forces always act in the negative direction (in both local and body frames), and are not capable of generating a force in the positive sense (one that would attract the aircraft to the ground). So, the gear forces are always negative - they are limited to values of zero or less. The gear force is simply the negative of the sum of the spring compression length times the spring coefficient and the gear velocity times the damping coefficient.

12. The lateral/directional force acting on the aircraft through the landing

    gear (along the local frame X and Y axes) is calculated next. First, the friction coefficient is multiplied by the recently calculated Z-force. This is the friction force. It must be given direction in addition to magnitude. We want the components in the local frame X and Y axes. From step 9, above, the conditioned wheel velocity vector is taken and the X and Y parts are multiplied by the friction force to get the X and Y components of friction.

13. The wheel force in local frame is next converted to body frame.
14. The moment due to the gear force is calculated by multiplying r x F (radius to wheel crossed into the wheel force). Both of these operands are in body frame.

Configuration File Format for <contact> Section:

<contact type="{BOGEY | STRUCTURE}" name="{string}">
    <location unit="{IN | M}">
        <x> {number} </x>
        <y> {number} </y>
        <z> {number} </z>
    </location>
    <orientation unit="{RAD | DEG}">
        <pitch> {number} </pitch>
        <roll> {number} </roll>
        <yaw> {number} </yaw>
    </orientation>
    <static_friction> {number} </static_friction>
    <dynamic_friction> {number} </dynamic_friction>
    <rolling_friction> {number} </rolling_friction>
    <spring_coeff unit="{LBS/FT | N/M}"> {number} </spring_coeff>
    <damping_coeff type="{ | SQUARE}" unit="{LBS/FT/SEC | N/M/SEC}"> {number} </damping_coeff>
    <damping_coeff_rebound type="{ | SQUARE}" unit="{LBS/FT/SEC | N/M/SEC}"> {number} </damping_coeff_rebound>
    <max_steer unit="DEG"> {number | 0 | 360} </max_steer>
    <brake_group> {NONE | LEFT | RIGHT | CENTER | NOSE | TAIL} </brake_group>
    <retractable>{0 | 1}</retractable>
    <table name="{CORNERING_COEFF}" type="internal">
        <tableData>
            {cornering parameters}
        </tableData>
    </table>
</contact>

Author

Jon S. Berndt

See also

Richard E. McFarland, "A Standard Kinematic Model for Flight Simulation at NASA-Ames", NASA CR-2497, January 1975

Barnes W. McCormick, "Aerodynamics, Aeronautics, and Flight Mechanics", Wiley & Sons, 1979 ISBN 0-471-03032-5

W. A. Ragsdale, "A Generic Landing Gear Dynamics Model for LASRS++", AIAA-2000-4303

Definition at line 191 of file FGLGear.h.

#include <FGLGear.h>

Inheritance diagram for FGLGear:

Collaboration diagram for FGLGear:

Classes
struct	Inputs

Public Types
enum	BrakeGroup {   bgNone =0 , bgLeft , bgRight , bgCenter ,   bgNose , bgTail , bgNumBrakeGroups }
	Brake grouping enumerators. More...
enum	ContactType { ctBOGEY , ctSTRUCTURE }
	Contact point type. More...
enum	DampType { dtLinear =0 , dtSquare }
	Damping types. More...
enum	FrictionType { ftRoll =0 , ftSide , ftDynamic }
	Friction types. More...
enum	ReportType { erNone =0 , erTakeoff , erLand }
	Report type enumerators. More...
enum	SteerType { stSteer , stFixed , stCaster }
	Steering group membership enumerators. More...
Public Types inherited from FGForce
enum	TransformType {   tNone , tWindBody , tLocalBody , tInertialBody ,   tCustom }
Public Types inherited from FGJSBBase
enum	{ eL = 1 , eM , eN }
	Moments L, M, N. More...
enum	{ eP = 1 , eQ , eR }
	Rates P, Q, R. More...
enum	{ eU = 1 , eV , eW }
	Velocities U, V, W. More...
enum	{ eX = 1 , eY , eZ }
	Positions X, Y, Z. More...
enum	{ ePhi = 1 , eTht , ePsi }
	Euler angles Phi, Theta, Psi. More...
enum	{ eDrag = 1 , eSide , eLift }
	Stability axis forces, Drag, Side force, Lift. More...
enum	{ eRoll = 1 , ePitch , eYaw }
	Local frame orientation Roll, Pitch, Yaw. More...
enum	{ eNorth = 1 , eEast , eDown }
	Local frame position North, East, Down. More...
enum	{ eLat = 1 , eLong , eRad }
	Locations Radius, Latitude, Longitude. More...
enum	{   inNone = 0 , inDegrees , inRadians , inMeters ,   inFeet }
	Conversion specifiers. More...

Public Member Functions
	FGLGear (Element *el, FGFDMExec *Executive, int number, const struct Inputs &input)
	Constructor.
	~FGLGear ()
	Destructor.
const FGColumnVector3 &	GetBodyForces (void) override
	The Force vector for this gear.
double	GetBodyLocation (int idx) const
FGColumnVector3	GetBodyLocation (void) const
	Gets the location of the gear in Body axes.
double	GetBodyXForce (void)
double	GetBodyYForce (void)
double	GetBodyZForce (void)
int	GetBrakeGroup (void) const
double	GetCompForce (void) const
	Gets the gear compression force in pounds.
double	GetCompLen (void) const
	Gets the current compressed length of the gear in feet.
double	GetCompVel (void) const
	Gets the current gear compression velocity in ft/sec.
bool	GetGearUnitDown (void) const
double	GetGearUnitPos (void) const
bool	GetGearUnitUp (void) const
double	GetLocalGear (int idx) const
const FGColumnVector3 &	GetLocalGear (void) const
const std::string &	GetName (void) const
	Gets the name of the gear.
bool	GetReport (void) const
	Get the console touchdown reporting feature.
bool	GetRetractable (void) const
double	GetstaticFCoeff (void) const
bool	GetSteerable (void) const
double	GetSteerAngleDeg (void) const
double	GetSteerNorm (void) const
int	GetSteerType (void) const
double	GetWheelRollForce (void)
double	GetWheelRollVel (void) const
double	GetWheelSideForce (void)
double	GetWheelSideVel (void) const
double	GetWheelSlipAngle (void) const
double	GetWheelVel (int axis) const
bool	GetWOW (void) const
	Gets the Weight On Wheels flag value.
bool	IsBogey (void) const
void	ResetToIC (void)
void	SetReport (bool flag)
	Set the console touchdown reporting feature.
void	SetSteerAngleDeg (double angle)
void	SetSteerCmd (double cmd)
void	SetWOW (bool wow)
	Sets the weight-on-wheels flag.
Public Member Functions inherited from FGForce
	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
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.
void	SetActingLocationX (double x)
void	SetActingLocationY (double y)
void	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.

Public Attributes
const struct Inputs &	in

Additional Inherited Members
Static Public Member Functions inherited from FGJSBBase
static const std::string &	GetVersion (void)
	Returns the version number of JSBSim.
static constexpr double	KelvinToFahrenheit (double kelvin)
	Converts from degrees Kelvin to degrees Fahrenheit.
static constexpr double	CelsiusToRankine (double celsius)
	Converts from degrees Celsius to degrees Rankine.
static constexpr double	RankineToCelsius (double rankine)
	Converts from degrees Rankine to degrees Celsius.
static constexpr double	KelvinToRankine (double kelvin)
	Converts from degrees Kelvin to degrees Rankine.
static constexpr double	RankineToKelvin (double rankine)
	Converts from degrees Rankine to degrees Kelvin.
static constexpr double	FahrenheitToCelsius (double fahrenheit)
	Converts from degrees Fahrenheit to degrees Celsius.
static constexpr double	CelsiusToFahrenheit (double celsius)
	Converts from degrees Celsius to degrees Fahrenheit.
static constexpr double	CelsiusToKelvin (double celsius)
	Converts from degrees Celsius to degrees Kelvin.
static constexpr double	KelvinToCelsius (double kelvin)
	Converts from degrees Kelvin to degrees Celsius.
static constexpr double	FeetToMeters (double measure)
	Converts from feet to meters.
static bool	EqualToRoundoff (double a, double b)
	Finite precision comparison.
static bool	EqualToRoundoff (float a, float b)
	Finite precision comparison.
static bool	EqualToRoundoff (float a, double b)
	Finite precision comparison.
static bool	EqualToRoundoff (double a, float b)
	Finite precision comparison.
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)
Protected Attributes inherited from FGForce
FGFDMExec *	fdmex
std::shared_ptr< FGMassBalance >	MassBalance
FGMatrix33	mT
TransformType	ttype
FGColumnVector3	vActingXYZn
FGColumnVector3	vFn
FGColumnVector3	vMn
FGColumnVector3	vOrient
FGColumnVector3	vXYZn
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.
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__

Member Enumeration Documentation

BrakeGroup

enum BrakeGroup

Brake grouping enumerators.

Definition at line 216 of file FGLGear.h.

{bgNone=0, bgLeft, bgRight, bgCenter, bgNose, bgTail, bgNumBrakeGroups };

ContactType

enum ContactType

Contact point type.

Definition at line 220 of file FGLGear.h.

{ctBOGEY, ctSTRUCTURE};

DampType

enum DampType

Damping types.

Definition at line 224 of file FGLGear.h.

{dtLinear=0, dtSquare};

FrictionType

enum FrictionType

Friction types.

Definition at line 226 of file FGLGear.h.

{ftRoll=0, ftSide, ftDynamic};

ReportType

enum ReportType

Report type enumerators.

Definition at line 222 of file FGLGear.h.

{erNone=0, erTakeoff, erLand};

SteerType

enum SteerType

Steering group membership enumerators.

Definition at line 218 of file FGLGear.h.

{stSteer, stFixed, stCaster};

Constructor & Destructor Documentation

FGLGear()

FGLGear	(	Element *	el,
		FGFDMExec *	Executive,
		int	number,
		const struct Inputs &	input
	)

Constructor.

Parameters

el	a pointer to the XML element that contains the CONTACT info.
Executive	a pointer to the parent executive object
number	integer identifier for this instance of FGLGear

Definition at line 73 of file FGLGear.cpp.

                                                                                       :
  FGForce(fdmex),
  in(inputs),
  GearNumber(number),
  SteerAngle(0.0),
  Castered(false),
  StaticFriction(false),
  eSteerType(stSteer)
{
  kSpring = bDamp = bDampRebound = dynamicFCoeff = staticFCoeff = rollingFCoeff = maxSteerAngle = 0;
  isRetractable = false;
  eDampType = dtLinear;
  eDampTypeRebound = dtLinear;
 
  name = el->GetAttributeValue("name");
  string sContactType = el->GetAttributeValue("type");
  if (sContactType == "BOGEY") {
    eContactType = ctBOGEY;
  } else if (sContactType == "STRUCTURE") {
    eContactType = ctSTRUCTURE;
  } else {
    // Unknown contact point types will be treated as STRUCTURE.
    eContactType = ctSTRUCTURE;
  }
 
  // Default values for structural contact points
  if (eContactType == ctSTRUCTURE) {
    kSpring = in.EmptyWeight;
    bDamp = kSpring;
    bDampRebound = kSpring * 10;
    staticFCoeff = 1.0;
    dynamicFCoeff = 1.0;
  }
 
  auto PropertyManager = fdmex->GetPropertyManager();
 
  fStrutForce = 0;
  Element* strutForce = el->FindElement("strut_force");
  if (strutForce) {
    Element* springFunc = strutForce->FindElement("function");
    fStrutForce = new FGFunction(fdmex, springFunc);
  }
  else {
    if (el->FindElement("spring_coeff"))
      kSpring = el->FindElementValueAsNumberConvertTo("spring_coeff", "LBS/FT");
    if (el->FindElement("damping_coeff")) {
      Element* dampCoeff = el->FindElement("damping_coeff");
      if (dampCoeff->GetAttributeValue("type") == "SQUARE") {
        eDampType = dtSquare;
        bDamp   = el->FindElementValueAsNumberConvertTo("damping_coeff", "LBS/FT2/SEC2");
      } else {
        bDamp   = el->FindElementValueAsNumberConvertTo("damping_coeff", "LBS/FT/SEC");
      }
    }
 
    if (el->FindElement("damping_coeff_rebound")) {
      Element* dampCoeffRebound = el->FindElement("damping_coeff_rebound");
      if (dampCoeffRebound->GetAttributeValue("type") == "SQUARE") {
        eDampTypeRebound = dtSquare;
        bDampRebound   = el->FindElementValueAsNumberConvertTo("damping_coeff_rebound", "LBS/FT2/SEC2");
      } else {
        bDampRebound   = el->FindElementValueAsNumberConvertTo("damping_coeff_rebound", "LBS/FT/SEC");
      }
    } else {
      bDampRebound   = bDamp;
      eDampTypeRebound = eDampType;
    }
  }
 
  if (el->FindElement("dynamic_friction"))
    dynamicFCoeff = el->FindElementValueAsNumber("dynamic_friction");
  if (el->FindElement("static_friction"))
    staticFCoeff = el->FindElementValueAsNumber("static_friction");
  if (el->FindElement("rolling_friction"))
    rollingFCoeff = el->FindElementValueAsNumber("rolling_friction");
  if (el->FindElement("retractable"))
    isRetractable = ((unsigned int)el->FindElementValueAsNumber("retractable"))>0.0?true:false;
 
  if (el->FindElement("max_steer"))
    maxSteerAngle = el->FindElementValueAsNumberConvertTo("max_steer", "DEG");
 
  Element* castered_el = el->FindElement("castered");
 
  if ((maxSteerAngle == 360 && !castered_el)
      || (castered_el && castered_el->GetDataAsNumber() != 0.0)) {
    eSteerType = stCaster;
    Castered = true;
  }
  else if (maxSteerAngle == 0.0) {
    eSteerType = stFixed;
  }
  else
    eSteerType = stSteer;
 
  GroundReactions = fdmex->GetGroundReactions().get();
 
  ForceY_Table = 0;
  Element* force_table = el->FindElement("table");
  while (force_table) {
    string force_type = force_table->GetAttributeValue("name");
    if (force_type == "CORNERING_COEFF") {
      ForceY_Table = new FGTable(PropertyManager, force_table);
      break;
    } else {
      FGXMLLogging log(force_table, LogLevel::ERROR);
      log << "Undefined force table for " << name << " contact point\n";
    }
    force_table = el->FindNextElement("table");
  }
 
  Element* element = el->FindElement("location");
  if (element) vXYZn = element->FindElementTripletConvertTo("IN");
  else {
    XMLLogException err(el);
    err << "\nNo location given for contact " << name << "\n";
    throw err;
  }
  SetTransformType(FGForce::tCustom);
 
  element = el->FindElement("orientation");
  if (element && (eContactType == ctBOGEY)) {
    FGQuaternion quatFromEuler(element->FindElementTripletConvertTo("RAD"));
 
    mTGear = quatFromEuler.GetT();
  }
  else {
    mTGear(1,1) = 1.;
    mTGear(2,2) = 1.;
    mTGear(3,3) = 1.;
  }
 
  string sBrakeGroup = el->FindElementValue("brake_group");
 
  if      (sBrakeGroup == "LEFT"  ) eBrakeGrp = bgLeft;
  else if (sBrakeGroup == "RIGHT" ) eBrakeGrp = bgRight;
  else if (sBrakeGroup == "CENTER") eBrakeGrp = bgCenter;
  else if (sBrakeGroup == "NOSE"  ) eBrakeGrp = bgCenter; // Nose brake is not supported by FGFCS
  else if (sBrakeGroup == "TAIL"  ) eBrakeGrp = bgCenter; // Tail brake is not supported by FGFCS
  else if (sBrakeGroup == "NONE"  ) eBrakeGrp = bgNone;
  else if (sBrakeGroup.empty()    ) eBrakeGrp = bgNone;
  else {
    FGXMLLogging log(el, LogLevel::ERROR);
    log << "Improper braking group specification in config file: "
        << sBrakeGroup << " is undefined.\n";
  }
 
// Add some AI here to determine if gear is located properly according to its
// brake group type ??
 
  useFCSGearPos = false;
  ReportEnable = true;
  TakeoffReported = LandingReported = false;
 
  // Set Pacejka terms
 
  Stiffness = 0.06;
  Shape = 2.8;
  Peak = staticFCoeff;
  Curvature = 1.03;
 
  ResetToIC();
 
  bind(PropertyManager.get());
 
  Debug(0);
}

Here is the call graph for this function:

~FGLGear()

~FGLGear

(

)

Destructor.

Definition at line 242 of file FGLGear.cpp.

{
  delete ForceY_Table;
  delete fStrutForce;
  Debug(1);
}

Member Function Documentation

GetBodyForces()

const FGColumnVector3 & GetBodyForces ( void  )

overridevirtual

The Force vector for this gear.

Reimplemented from FGForce.

Definition at line 283 of file FGLGear.cpp.

{
  double gearPos = 1.0;
 
  vFn.InitMatrix();
 
  // Compute AGL
  FGColumnVector3 normal, terrainVel, dummy;
  FGLocation gearLoc, contact;
  FGColumnVector3 vWhlBodyVec = Ts2b * (vXYZn - in.vXYZcg);
 
  vLocalGear = in.Tb2l * vWhlBodyVec; // Get local frame wheel location
  gearLoc = in.Location.LocalToLocation(vLocalGear);
 
  // Compute the height of the theoretical location of the wheel (if strut is
  // not compressed) with respect to the ground level (AGL)
  double height = fdmex->GetInertial()->GetContactPoint(gearLoc, contact,
    normal, terrainVel, dummy);
 
  // Don't want strut compression when in contact with the ground to return
  // a negative AGL
  AGL = max(height, 0.0);
 
  if (isRetractable) gearPos = GetGearUnitPos();
 
  if (gearPos > 0.99) { // Gear DOWN
 
    if (!fdmex->GetTrimStatus())
      height -= GroundReactions->GetBumpHeight();
    staticFFactor = GroundReactions->GetStaticFFactor();
    rollingFFactor = GroundReactions->GetRollingFFactor();
    maximumForce = GroundReactions->GetMaximumForce();
    bumpiness = GroundReactions->GetBumpiness();
    isSolid = GroundReactions->GetSolid();
 
    FGColumnVector3 vWhlDisplVec;
    double LGearProj = 1.0;
 
    if (height < 0.0) {
      WOW = true;
      vGroundNormal = in.Tec2b * normal;
 
      // The height returned by GetGroundCallback() is the AGL and is expressed
      // in the Z direction of the local coordinate frame. We now need to
      // transform this height in actual compression of the strut (BOGEY) or in
      // the normal direction to the ground (STRUCTURE)
      double normalZ = (in.Tec2l*normal)(eZ);
      LGearProj = -(mTGear.Transposed() * vGroundNormal)(eZ);
 
      // The following equations use the vector to the tire contact patch
      // including the strut compression.
      switch(eContactType) {
      case ctBOGEY:
        if (isSolid) {
          compressLength = LGearProj > 0.0 ? height * normalZ / LGearProj : 0.0;
          vWhlDisplVec = mTGear * FGColumnVector3(0., 0., -compressLength);
        } else {
          // Gears don't (or hardly) compress in liquids
          WOW = false;
        }
        break;
      case ctSTRUCTURE:
        compressLength = height * normalZ / DotProduct(normal, normal);
        vWhlDisplVec = compressLength * vGroundNormal;
        break;
      }
    }
    else
      WOW = false;
 
    if (WOW) {
      FGColumnVector3 vWhlContactVec = vWhlBodyVec + vWhlDisplVec;
      vActingXYZn = vXYZn + Tb2s * vWhlDisplVec;
      FGColumnVector3 vBodyWhlVel = in.PQR * vWhlContactVec;
      vBodyWhlVel += in.UVW - in.Tec2b * terrainVel;
      vWhlVelVec = mTGear.Transposed() * vBodyWhlVel;
 
      InitializeReporting();
      ComputeSteeringAngle();
      ComputeGroundFrame();
 
      vGroundWhlVel = mT.Transposed() * vBodyWhlVel;
 
      if (fdmex->GetTrimStatus() || in.TotalDeltaT == 0.0)
        compressSpeed = 0.0; // Steady state is sought during trimming
      else {
        compressSpeed = -vGroundWhlVel(eZ);
        if (eContactType == ctBOGEY)
          compressSpeed /= LGearProj;
 
        // If the gear is entering in contact with the ground during the current
        // time step, the compression speed might actually be lower than the
        // aircraft velocity projected along the gear leg (compressSpeed).
        double maxCompressSpeed = compressLength/in.TotalDeltaT;
        if (fabs(compressSpeed) > maxCompressSpeed)
          compressSpeed = sign(compressSpeed)*maxCompressSpeed;
      }
 
      ComputeVerticalStrutForce();
 
      // Compute the friction coefficients in the wheel ground plane.
      if (eContactType == ctBOGEY) {
        ComputeSlipAngle();
        ComputeBrakeForceCoefficient();
        ComputeSideForceCoefficient();
      }
 
      // Prepare the Jacobians and the Lagrange multipliers for later friction
      // forces calculations.
      ComputeJacobian(vWhlContactVec);
    } else { // Gear is NOT compressed
      compressLength = 0.0;
      compressSpeed = 0.0;
      WheelSlip = 0.0;
      StrutForce = 0.0;
      vWhlDisplVec.InitMatrix();
 
      LMultiplier[ftRoll].value = 0.0;
      LMultiplier[ftSide].value = 0.0;
      LMultiplier[ftDynamic].value = 0.0;
 
      // Return to neutral position between 1.0 and 0.8 gear pos.
      SteerAngle *= max(gearPos-0.8, 0.0)/0.2;
 
      ResetReporting();
    }
  }
 
  if (!WOW) {
    // Let wheel spin down slowly
    vWhlVelVec(eX) -= 13.0 * in.TotalDeltaT;
    if (vWhlVelVec(eX) < 0.0) vWhlVelVec(eX) = 0.0;
  }
 
  if (!fdmex->GetTrimStatus()) {
    ReportTakeoffOrLanding();
 
    // Require both WOW and LastWOW to be true before checking crash conditions
    // to allow the WOW flag to be used in terminating a scripted run.
    if (WOW && lastWOW) CrashDetect();
 
    lastWOW = WOW;
  }
 
  return FGForce::GetBodyForces();
}

Here is the call graph for this function:

GetBodyLocation() [1/2]

double GetBodyLocation ( int  idx ) const

inline

Definition at line 243 of file FGLGear.h.

                                        {
    FGColumnVector3 vWhlBodyVec = Ts2b * (vXYZn - in.vXYZcg);
    return vWhlBodyVec(idx);
  }

GetBodyLocation() [2/2]

FGColumnVector3 GetBodyLocation ( void  ) const

inline

Gets the location of the gear in Body axes.

Definition at line 240 of file FGLGear.h.

                                              {
    return Ts2b * (vXYZn - in.vXYZcg);
  }

GetBodyXForce()

double GetBodyXForce ( void  )

inline

Definition at line 293 of file FGLGear.h.

                             {
    UpdateForces();
    return FGForce::GetBodyForces()(eX);
  }

GetBodyYForce()

double GetBodyYForce ( void  )

inline

Definition at line 297 of file FGLGear.h.

                             {
    UpdateForces();
    return FGForce::GetBodyForces()(eY);
  }

GetBodyZForce()

double GetBodyZForce ( void  )

inline

Definition at line 301 of file FGLGear.h.

                             {
    UpdateForces();
    return FGForce::GetBodyForces()(eZ);
  }

GetBrakeGroup()

int GetBrakeGroup ( void  ) const

inline

Definition at line 277 of file FGLGear.h.

{ return (int)eBrakeGrp; }

GetCompForce()

double GetCompForce ( void  ) const

inline

Gets the gear compression force in pounds.

Definition at line 260 of file FGLGear.h.

{return StrutForce;   }

GetCompLen()

double GetCompLen ( void  ) const

inline

Gets the current compressed length of the gear in feet.

Definition at line 256 of file FGLGear.h.

{return compressLength;}

GetCompVel()

double GetCompVel ( void  ) const

inline

Gets the current gear compression velocity in ft/sec.

Definition at line 258 of file FGLGear.h.

{return compressSpeed; }

GetGearUnitDown()

bool GetGearUnitDown ( void  ) const

inline

Definition at line 283 of file FGLGear.h.

{ return isRetractable ? (GetGearUnitPos() > 0.99) : true; }

GetGearUnitPos()

double GetGearUnitPos

(

void

)

const

Definition at line 673 of file FGLGear.cpp.

{
  // hack to provide backward compatibility to gear/gear-pos-norm property
  if( useFCSGearPos || in.FCSGearPos != 1.0 ) {
    useFCSGearPos = true;
    return in.FCSGearPos;
  }
  return GearPos;
}

GetGearUnitUp()

bool GetGearUnitUp ( void  ) const

inline

Definition at line 282 of file FGLGear.h.

{ return isRetractable ? (GetGearUnitPos() < 0.01) : false; }

GetLocalGear() [1/2]

double GetLocalGear ( int  idx ) const

inline

Definition at line 249 of file FGLGear.h.

{ return vLocalGear(idx); }

GetLocalGear() [2/2]

const FGColumnVector3 & GetLocalGear ( void  ) const

inline

Definition at line 248 of file FGLGear.h.

{ return vLocalGear; }

GetName()

const std::string & GetName ( void  ) const

inline

Gets the name of the gear.

Definition at line 252 of file FGLGear.h.

{return name; }

GetReport()

bool GetReport ( void  ) const

inline

Get the console touchdown reporting feature.

Returns

true if reporting is turned on

Definition at line 270 of file FGLGear.h.

{ return ReportEnable; }

GetRetractable()

bool GetRetractable ( void  ) const

inline

Definition at line 281 of file FGLGear.h.

{ return isRetractable;   }

GetstaticFCoeff()

double GetstaticFCoeff ( void  ) const

inline

Definition at line 275 of file FGLGear.h.

{ return staticFCoeff; }

GetSteerable()

bool GetSteerable ( void  ) const

inline

Definition at line 280 of file FGLGear.h.

{ return eSteerType != stFixed; }

GetSteerAngleDeg()

double GetSteerAngleDeg ( void  ) const

inline

Definition at line 313 of file FGLGear.h.

{ return radtodeg*SteerAngle; }

GetSteerNorm()

double GetSteerNorm ( void  ) const

inline

Definition at line 271 of file FGLGear.h.

                                  {
    return maxSteerAngle == 0.0 ? 0.0 : radtodeg/maxSteerAngle*SteerAngle;
  }

GetSteerType()

int GetSteerType ( void  ) const

inline

Definition at line 278 of file FGLGear.h.

{ return (int)eSteerType; }

GetWheelRollForce()

double GetWheelRollForce ( void  )

inline

Definition at line 285 of file FGLGear.h.

                                 {
    UpdateForces();
    FGColumnVector3 vForce = mTGear.Transposed() * FGForce::GetBodyForces();
    return vForce(eX)*cos(SteerAngle) + vForce(eY)*sin(SteerAngle); }

GetWheelRollVel()

double GetWheelRollVel ( void  ) const

inline

Definition at line 305 of file FGLGear.h.

                                       { return vWhlVelVec(eX)*cos(SteerAngle)
                                              + vWhlVelVec(eY)*sin(SteerAngle);  }

GetWheelSideForce()

double GetWheelSideForce ( void  )

inline

Definition at line 289 of file FGLGear.h.

                                 {
    UpdateForces();
    FGColumnVector3 vForce = mTGear.Transposed() * FGForce::GetBodyForces();
    return vForce(eY)*cos(SteerAngle) - vForce(eX)*sin(SteerAngle); }

GetWheelSideVel()

double GetWheelSideVel ( void  ) const

inline

Definition at line 307 of file FGLGear.h.

                                       { return vWhlVelVec(eY)*cos(SteerAngle)
                                              - vWhlVelVec(eX)*sin(SteerAngle);  }

GetWheelSlipAngle()

double GetWheelSlipAngle ( void  ) const

inline

Definition at line 309 of file FGLGear.h.

{ return WheelSlip;       }

GetWheelVel()

double GetWheelVel ( int  axis ) const

inline

Definition at line 310 of file FGLGear.h.

{ return vWhlVelVec(axis);}

GetWOW()

bool GetWOW ( void  ) const

inline

Gets the Weight On Wheels flag value.

Definition at line 254 of file FGLGear.h.

{return WOW; }

IsBogey()

bool IsBogey ( void  ) const

inline

Definition at line 311 of file FGLGear.h.

{ return (eContactType == ctBOGEY);}

ResetToIC()

void ResetToIC

(

void

)

Definition at line 251 of file FGLGear.cpp.

{
  GearPos  = 1.0;
 
  WOW = lastWOW = false;
  FirstContact = false;
  StartedGroundRun = false;
  LandingDistanceTraveled = TakeoffDistanceTraveled = TakeoffDistanceTraveled50ft = 0.0;
  MaximumStrutForce = MaximumStrutTravel = 0.0;
  SinkRate = GroundSpeed = 0.0;
  SteerAngle = 0.0;
 
  vWhlVelVec.InitMatrix();
 
  compressLength  = 0.0;
  compressSpeed   = 0.0;
  maxCompLen      = 0.0;
 
  WheelSlip = 0.0;
 
  // Initialize Lagrange multipliers
  for (int i=0; i < 3; i++) {
    LMultiplier[i].ForceJacobian.InitMatrix();
    LMultiplier[i].LeverArm.InitMatrix();
    LMultiplier[i].Min = 0.0;
    LMultiplier[i].Max = 0.0;
    LMultiplier[i].value = 0.0;
  }
}

SetReport()

void SetReport ( bool  flag )

inline

Set the console touchdown reporting feature.

Parameters

flag	true turns on touchdown reporting, false turns it off

Definition at line 267 of file FGLGear.h.

{ ReportEnable = flag; }

SetSteerAngleDeg()

void SetSteerAngleDeg ( double  angle )

inline

Definition at line 314 of file FGLGear.h.

                                      {
    if (eSteerType != stFixed && !Castered)
      SteerAngle = degtorad * angle;
  }

SetSteerCmd()

void SetSteerCmd ( double  cmd )

inline

Definition at line 274 of file FGLGear.h.

{ SetSteerAngleDeg(cmd * maxSteerAngle); }

SetWOW()

void SetWOW ( bool  wow )

inline

Sets the weight-on-wheels flag.

Definition at line 263 of file FGLGear.h.

{WOW = wow;}

Member Data Documentation

in

const struct Inputs& in

Definition at line 319 of file FGLGear.h.

---

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

• FGLGear.h
• FGLGear.cpp