FGLGear.h

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 Header:       FGLGear.h
 Author:       Jon S. Berndt
 Date started: 11/18/99
 
 ------------- Copyright (C) 1999  Jon S. Berndt (jon@jsbsim.org) -------------
 
 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
--------------------------------------------------------------------------------
11/18/99   JSB   Created
 
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SENTRY
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
 
#ifndef FGLGEAR_H
#define FGLGEAR_H
 
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
INCLUDES
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
 
#include <string>
 
#include "models/propulsion/FGForce.h"
#include "math/FGColumnVector3.h"
#include "math/LagrangeMultiplier.h"
#include "FGSurface.h"
 
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
FORWARD DECLARATIONS
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
 
namespace JSBSim {
 
class FGTable;
class Element;
class FGPropertyManager;
 
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
CLASS DOCUMENTATION
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
 
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
CLASS DECLARATION
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
 
class FGLGear : protected FGSurface, public FGForce
{
public:
  struct Inputs {
    double Vground;
    double VcalibratedKts;
    double Temperature;
    double DistanceAGL;
    double DistanceASL;
    double TotalDeltaT;
    bool TakeoffThrottle;
    bool WOW;
    FGMatrix33 Tb2l;
    FGMatrix33 Tec2l;
    FGMatrix33 Tec2b;
    FGColumnVector3 PQR;
    FGColumnVector3 UVW;
    FGColumnVector3 vXYZcg; // CG coordinates expressed in the structural frame
    FGLocation Location;
    std::vector <double> BrakePos;
    double FCSGearPos;
    double EmptyWeight;
  };
 
  enum BrakeGroup {bgNone=0, bgLeft, bgRight, bgCenter, bgNose, bgTail, bgNumBrakeGroups };
  enum SteerType {stSteer, stFixed, stCaster};
  enum ContactType {ctBOGEY, ctSTRUCTURE};
  enum ReportType {erNone=0, erTakeoff, erLand};
  enum DampType {dtLinear=0, dtSquare};
  enum FrictionType {ftRoll=0, ftSide, ftDynamic};
  FGLGear(Element* el, FGFDMExec* Executive, int number, const struct Inputs& input);
  ~FGLGear();
 
  const FGColumnVector3& GetBodyForces(FGSurface *surface = NULL);
 
  FGColumnVector3 GetBodyLocation(void) const {
    return Ts2b * (vXYZn - in.vXYZcg);
  }
  double GetBodyLocation(int idx) const {
    FGColumnVector3 vWhlBodyVec = Ts2b * (vXYZn - in.vXYZcg);
    return vWhlBodyVec(idx);
  }
 
  const FGColumnVector3& GetLocalGear(void) const { return vLocalGear; }
  double GetLocalGear(int idx) const { return vLocalGear(idx); }
 
  const std::string& GetName(void) const {return name; }
  bool    GetWOW(void) const {return WOW; }
  double  GetCompLen(void) const {return compressLength;}
  double  GetCompVel(void) const {return compressSpeed; }
  double  GetCompForce(void) const {return StrutForce;   }
 
  void SetWOW(bool wow) {WOW = wow;}
 
  void SetReport(bool flag) { ReportEnable = flag; }
  bool GetReport(void) const  { return ReportEnable; }
  double GetSteerNorm(void) const {
    return maxSteerAngle == 0.0 ? 0.0 : radtodeg/maxSteerAngle*SteerAngle;
  }
  void SetSteerCmd(double cmd) { SetSteerAngleDeg(cmd * maxSteerAngle); }
  double GetstaticFCoeff(void) const { return staticFCoeff; }
 
  int  GetBrakeGroup(void) const   { return (int)eBrakeGrp; }
  int  GetSteerType(void) const    { return (int)eSteerType; }
 
  bool GetSteerable(void) const    { return eSteerType != stFixed; }
  bool GetRetractable(void) const  { return isRetractable;   }
  bool GetGearUnitUp(void) const   { return isRetractable ? (GetGearUnitPos() < 0.01) : false; }
  bool GetGearUnitDown(void) const { return isRetractable ? (GetGearUnitPos() > 0.99) : true; }
 
  double GetWheelRollForce(void) {
    UpdateForces();
    FGColumnVector3 vForce = mTGear.Transposed() * FGForce::GetBodyForces();
    return vForce(eX)*cos(SteerAngle) + vForce(eY)*sin(SteerAngle); }
  double GetWheelSideForce(void) {
    UpdateForces();
    FGColumnVector3 vForce = mTGear.Transposed() * FGForce::GetBodyForces();
    return vForce(eY)*cos(SteerAngle) - vForce(eX)*sin(SteerAngle); }
  double GetBodyXForce(void) {
    UpdateForces();
    return FGForce::GetBodyForces()(eX);
  }
  double GetBodyYForce(void) {
    UpdateForces();
    return FGForce::GetBodyForces()(eY);
  }
  double GetBodyZForce(void) {
    UpdateForces();
    return FGForce::GetBodyForces()(eZ);
  }
  double GetWheelRollVel(void) const   { return vWhlVelVec(eX)*cos(SteerAngle)
                                              + vWhlVelVec(eY)*sin(SteerAngle);  }
  double GetWheelSideVel(void) const   { return vWhlVelVec(eY)*cos(SteerAngle)
                                              - vWhlVelVec(eX)*sin(SteerAngle);  }
  double GetWheelSlipAngle(void) const { return WheelSlip;       }
  double GetWheelVel(int axis) const   { return vWhlVelVec(axis);}
  bool IsBogey(void) const             { return (eContactType == ctBOGEY);}
  double GetGearUnitPos(void) const;
  double GetSteerAngleDeg(void) const { return radtodeg*SteerAngle; }
  void SetSteerAngleDeg(double angle) {
    if (eSteerType != stFixed && !Castered)
      SteerAngle = degtorad * angle;
  }
 
  const struct Inputs& in;
 
  void ResetToIC(void);
  void bind(void);
 
private:
  int GearNumber;
  static const FGMatrix33 Tb2s, Ts2b;
  FGMatrix33 mTGear;
  FGColumnVector3 vLocalGear;
  FGColumnVector3 vWhlVelVec, vGroundWhlVel;     // Velocity of this wheel
  FGColumnVector3 vGroundNormal;
  FGTable *ForceY_Table;
  FGFunction *fStrutForce;
  double SteerAngle;
  double kSpring;
  double bDamp;
  double bDampRebound;
  double compressLength;
  double compressSpeed;
  double rollingFCoeff;
  double Stiffness, Shape, Peak, Curvature; // Pacejka factors
  double BrakeFCoeff;
  double maxCompLen;
  double SinkRate;
  double GroundSpeed;
  double TakeoffDistanceTraveled;
  double TakeoffDistanceTraveled50ft;
  double LandingDistanceTraveled;
  double MaximumStrutForce, StrutForce;
  double MaximumStrutTravel;
  double FCoeff;
  double WheelSlip;
  double GearPos;
  bool WOW;
  bool lastWOW;
  bool FirstContact;
  bool StartedGroundRun;
  bool LandingReported;
  bool TakeoffReported;
  bool ReportEnable;
  bool isRetractable;
  bool Castered;
  bool StaticFriction;
  std::string name;
 
  BrakeGroup  eBrakeGrp;
  ContactType eContactType;
  SteerType   eSteerType;
  DampType    eDampType;
  DampType    eDampTypeRebound;
  double  maxSteerAngle;
 
  LagrangeMultiplier LMultiplier[3];
 
  FGGroundReactions* GroundReactions;
  FGPropertyManager* PropertyManager;
 
  mutable bool useFCSGearPos;
 
  void ComputeBrakeForceCoefficient(void);
  void ComputeSteeringAngle(void);
  void ComputeSlipAngle(void);
  void ComputeSideForceCoefficient(void);
  void ComputeVerticalStrutForce(void);
  void ComputeGroundFrame(void);
  void ComputeJacobian(const FGColumnVector3& vWhlContactVec);
  void UpdateForces(void);
  void SetstaticFCoeff(double coeff);
  void CrashDetect(void);
  void InitializeReporting(void);
  void ResetReporting(void);
  void ReportTakeoffOrLanding(void);
  void Report(ReportType rt);
  void Debug(int from);
};
}
 
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
#endif