Detailed Description

The trimming routine for JSBSim.

FGTrim finds the aircraft attitude and control settings needed to maintain the steady state described by the FGInitialCondition object . It does this iteratively by assigning a control to each state and adjusting that control until the state is within a specified tolerance of zero. States include the recti-linear accelerations udot, vdot, and wdot, the angular accelerations qdot, pdot, and rdot, and the difference between heading and ground track. Controls include the usual flight deck controls available to the pilot plus angle of attack (alpha), sideslip angle(beta), flight path angle (gamma), pitch attitude(theta), roll attitude(phi), and altitude above ground. The last three are used for on-ground trimming. The state-control pairs used in a given trim are completely user configurable and several pre-defined modes are provided as well. They are:

tLongitudinal: Trim wdot with alpha, udot with thrust, qdot with elevator
tFull: tLongitudinal + vdot with phi, pdot with aileron, rdot with rudder and heading minus ground track (hmgt) with beta
tPullup: tLongitudinal but adjust alpha to achieve load factor input with SetTargetNlf()
tGround: wdot with altitude, qdot with theta, and pdot with phi

The remaining modes include tCustom, which is completely user defined and tNone.

Note that trims can (and do) fail for reasons that are completely outside the control of the trimming routine itself. The most common problem is the initial conditions: is the model capable of steady state flight at those conditions? Check the speed, altitude, configuration (flaps, gear, etc.), weight, cg, and anything else that may be relevant.

Example usage:

FGFDMExec* FDMExec = new FGFDMExec();
 
FGInitialCondition* fgic = new FGInitialCondition(FDMExec);
FGTrim fgt(FDMExec, fgic, tFull);
fgic->SetVcaibratedKtsIC(100);
fgic->SetAltitudeFtIC(1000);
fgic->SetClimbRate(500);
if( !fgt.DoTrim() ) {
  std::cout << "Trim Failed" << std::endl;
}
fgt.Report();

Author: Tony Peden

Definition at line 125 of file FGTrim.h.

#include <FGTrim.h>

Inheritance diagram for FGTrim:

Collaboration diagram for FGTrim:

Public Member Functions
	FGTrim (FGFDMExec *FDMExec, TrimMode tm=tGround)
	Initializes the trimming class.

bool	AddState (State state, Control control)
	Add a state-control pair to the current configuration.

void	ClearDebug (void)

void	ClearStates (void)
	Clear all state-control pairs from the current configuration.

void	DebugState (State state)
	Output debug data for one of the axes The State enum is defined in FGTrimAxis.h.

bool	DoTrim (void)
	Execute the trim.

bool	EditState (State state, Control new_control)
	Change the control used to zero a state previously configured.

bool	GetGammaFallback (void)
	query the fallback state

double	GetTargetNlf (void)

bool	RemoveState (State state)
	Remove a specific state-control pair from the current configuration.

void	Report (void)
	Print the results of the trim.

void	SetDebug (int level)
	Debug level 1 shows results of each top-level iteration Debug level 2 shows level 1 & results of each per-axis iteration.

void	SetGammaFallback (bool bb)
	automatically switch to trimming longitudinal acceleration with flight path angle (gamma) once it becomes apparent that there is not enough/too much thrust.

void	SetMaxCycles (int ii)
	Set the iteration limit.

void	SetMaxCyclesPerAxis (int ii)
	Set the per-axis iteration limit.

void	SetMode (TrimMode tm)
	Clear all state-control pairs and set a predefined trim mode.

void	SetTargetNlf (double nlf)

void	SetTolerance (double tt)
	Set the tolerance for declaring a state trimmed.

void	TrimStats ()
	Iteration statistics.

Public Member Functions inherited from FGJSBBase
	FGJSBBase ()
	Constructor for FGJSBBase.

virtual	~FGJSBBase ()
	Destructor for FGJSBBase.

void	disableHighLighting (void)
	Disables highlighting in the console output.

Additional Inherited Members
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...

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)

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/(fttomfttomfttom)

static constexpr double	in3tom3 = inchtoftinchtoftinchtoft/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__

Constructor & Destructor Documentation

◆ FGTrim()

FGTrim	(	FGFDMExec *	FDMExec,
		TrimMode	tm = `tGround`
	)

Initializes the trimming class.

Parameters

FDMExec	pointer to a JSBSim executive object.
tm	trim mode

Definition at line 62 of file FGTrim.cpp.

  : fgic(FDMExec)
{
 
  Nsub=0;
  max_iterations=60;
  max_sub_iterations=100;
  Tolerance=1E-3;
  A_Tolerance = Tolerance / 10;
 
  Debug=0;DebugLevel=0;
  fdmex=FDMExec;
  fgic = *fdmex->GetIC();
  total_its=0;
  gamma_fallback=false;
  mode=tt;
  xlo=xhi=alo=ahi=0.0;
  targetNlf=fgic.GetTargetNlfIC();
  debug_axis=tAll;
  SetMode(tt);
  if (debug_lvl & 2) {
    FGLogging log(LogLevel::DEBUG);
    log << "Instantiated: FGTrim\n";
  }
}

Here is the call graph for this function:

◆ ~FGTrim()

~FGTrim ( void )

Definition at line 90 of file FGTrim.cpp.

                    {
  if (debug_lvl & 2) {
    FGLogging log(LogLevel::DEBUG);
    log << "Destroyed:    FGTrim\n";
  }
}

Member Function Documentation

◆ AddState()

bool AddState	(	State	state,
		Control	control
	)

Add a state-control pair to the current configuration.

See the enums State and Control in FGTrimAxis.h for the available options. Will fail if the given state is already configured.

Parameters

state	the accel or other condition to zero
control	the control used to zero the state

Returns: true if add is successful

Definition at line 139 of file FGTrim.cpp.

                                                    {
  mode = tCustom;
  vector <FGTrimAxis>::iterator iAxes = TrimAxes.begin();
  for (; iAxes != TrimAxes.end(); ++iAxes) {
    if (iAxes->GetStateType() == state)
      return false;
  }
 
  TrimAxes.push_back(FGTrimAxis(fdmex,&fgic,state,control));
  sub_iterations.resize(TrimAxes.size());
  successful.resize(TrimAxes.size());
  solution.resize(TrimAxes.size());
 
  return true;
}

◆ ClearDebug()

void ClearDebug ( void )

inline

Definition at line 280 of file FGTrim.h.

280{ DebugLevel = 0; }

◆ ClearStates()

void ClearStates ( void )

Clear all state-control pairs from the current configuration.

The trimming routine must have at least one state-control pair configured to be useful

Definition at line 130 of file FGTrim.cpp.

                             {
    mode=tCustom;
    TrimAxes.clear();
  //FGLogging log(LogLevel::INFO);
  //log << "TrimAxes.size(): " << TrimAxes.size() << "\n";
}

Here is the caller graph for this function:

◆ DebugState()

void DebugState ( State state )

inline

Output debug data for one of the axes The State enum is defined in FGTrimAxis.h.

Definition at line 286 of file FGTrim.h.

286{ debug_axis=state; }

◆ DoTrim()

bool DoTrim ( void )

Execute the trim.

Definition at line 195 of file FGTrim.cpp.

                        {
  bool trim_failed=false;
  unsigned int N = 0;
  unsigned int axis_count = 0;
  auto FCS = fdmex->GetFCS();
  auto GroundReactions = fdmex->GetGroundReactions();
  vector<double> throttle0 = FCS->GetThrottleCmd();
  double elevator0 = FCS->GetDeCmd();
  double aileron0 = FCS->GetDaCmd();
  double rudder0 = FCS->GetDrCmd();
  double PitchTrim0 = FCS->GetPitchTrimCmd();
 
  for(int i=0;i < GroundReactions->GetNumGearUnits();i++)
    GroundReactions->GetGearUnit(i)->SetReport(false);
 
  fdmex->SetTrimStatus(true);
  fdmex->SuspendIntegration();
 
  fgic.SetPRadpsIC(0.0);
  fgic.SetQRadpsIC(0.0);
  fgic.SetRRadpsIC(0.0);
 
  if (mode == tGround) {
    fdmex->Initialize(&fgic);
    fdmex->Run();
    trimOnGround();
    double theta = fgic.GetThetaRadIC();
    double phi = fgic.GetPhiRadIC();
    // Take opportunity of the first approx. found by trimOnGround() to
    // refine the control limits.
    TrimAxes[0].SetControlLimits(0., fgic.GetAltitudeAGLFtIC());
    TrimAxes[1].SetControlLimits(theta - 5.0 * degtorad, theta + 5.0 * degtorad);
    TrimAxes[2].SetControlLimits(phi - 30.0 * degtorad, phi + 30.0 * degtorad);
  }
 
  //clear the sub iterations counts & zero out the controls
  for(unsigned int current_axis=0;current_axis<TrimAxes.size();current_axis++) {
    //FGLogging log(LogLevel::INFO);
    //log << current_axis << "  " << TrimAxes[current_axis]->GetStateName()
    //<< "  " << TrimAxes[current_axis]->GetControlName()<< "\n";
    xlo=TrimAxes[current_axis].GetControlMin();
    xhi=TrimAxes[current_axis].GetControlMax();
    TrimAxes[current_axis].SetControl((xlo+xhi)/2);
    TrimAxes[current_axis].Run();
    //TrimAxes[current_axis].AxisReport();
    sub_iterations[current_axis]=0;
    successful[current_axis]=0;
    solution[current_axis]=false;
  }
 
  if(mode == tPullup ) {
    FGLogging log(LogLevel::INFO);
    log << "Setting pitch rate and nlf...\n";
    setupPullup();
    log << "pitch rate done ...\n";
    TrimAxes[0].SetStateTarget(targetNlf);
    log << "nlf done\n";
  } else if (mode == tTurn) {
    setupTurn();
    //TrimAxes[0].SetStateTarget(targetNlf);
  }
 
  do {
    axis_count=0;
    for(unsigned int current_axis=0;current_axis<TrimAxes.size();current_axis++) {
      setDebug(TrimAxes[current_axis]);
      updateRates();
      Nsub=0;
      if(!solution[current_axis]) {
        if(checkLimits(TrimAxes[current_axis])) {
          solution[current_axis]=true;
          solve(TrimAxes[current_axis]);
        }
      } else if(findInterval(TrimAxes[current_axis])) {
        solve(TrimAxes[current_axis]);
      } else {
        solution[current_axis]=false;
      }
      sub_iterations[current_axis]+=Nsub;
    }
    for(unsigned int current_axis=0;current_axis<TrimAxes.size();current_axis++) {
      //these checks need to be done after all the axes have run
      if(Debug > 0) TrimAxes[current_axis].AxisReport();
      if(TrimAxes[current_axis].InTolerance()) {
        axis_count++;
        successful[current_axis]++;
      }
    }
 
    if((axis_count == TrimAxes.size()-1) && (TrimAxes.size() > 1)) {
      //FGLogging log(LogLevel::INFO);
      //log << TrimAxes.size()-1 << " out of " << TrimAxes.size() << "!" << "\n";
      //At this point we can check the input limits of the failed axis
      //and declare the trim failed if there is no sign change. If there
      //is, keep going until success or max iteration count
 
      //Oh, well: two out of three ain't bad
      for(unsigned int current_axis=0;current_axis<TrimAxes.size();current_axis++) {
        //these checks need to be done after all the axes have run
        if(!TrimAxes[current_axis].InTolerance()) {
          if(!checkLimits(TrimAxes[current_axis])) {
            // special case this for now -- if other cases arise proper
            // support can be added to FGTrimAxis
            if( (gamma_fallback) &&
                (TrimAxes[current_axis].GetStateType() == tUdot) &&
                (TrimAxes[current_axis].GetControlType() == tThrottle)) {
              FGLogging log(LogLevel::WARN);
              log << "  Can't trim udot with throttle, trying flight"
              << " path angle. (" << N << ")\n";
              if(TrimAxes[current_axis].GetState() > 0)
                TrimAxes[current_axis].SetControlToMin();
              else
                TrimAxes[current_axis].SetControlToMax();
              TrimAxes[current_axis].Run();
              TrimAxes[current_axis]=FGTrimAxis(fdmex,&fgic,tUdot,tGamma);
            } else {
              FGLogging log(LogLevel::ERROR);
              log << "  Sorry, " << TrimAxes[current_axis].GetStateName()
              << " doesn't appear to be trimmable\n";
              //total_its=k;
              trim_failed=true; //force the trim to fail
            } //gamma_fallback
          }
        } //solution check
      } //for loop
    } //all-but-one check
    N++;
    if(N > max_iterations)
      trim_failed=true;
  } while((axis_count < TrimAxes.size()) && (!trim_failed));
 
  if((!trim_failed) && (axis_count >= TrimAxes.size())) {
    total_its=N;
    if (debug_lvl > 0) {
      FGLogging log(LogLevel::DEBUG);
      log << "\n  Trim successful\n";
    }
  } else { // The trim has failed
    total_its=N;
 
    // Restore the aircraft parameters to their initial values
    fgic = *fdmex->GetIC();
    FCS->SetDeCmd(elevator0);
    FCS->SetDaCmd(aileron0);
    FCS->SetDrCmd(rudder0);
    FCS->SetPitchTrimCmd(PitchTrim0);
    for (unsigned int i=0; i < throttle0.size(); i++)
      FCS->SetThrottleCmd(i, throttle0[i]);
 
    fdmex->Initialize(&fgic);
    fdmex->Run();
 
    // If WOW is true we must make sure there are no gears into the ground.
    if (GroundReactions->GetWOW())
      trimOnGround();
 
    if (debug_lvl > 0) {
      FGLogging log(LogLevel::DEBUG);
      log << "\n  Trim failed\n";
    }
  }
 
  fdmex->GetPropagate()->InitializeDerivatives();
  fdmex->ResumeIntegration();
  fdmex->SetTrimStatus(false);
 
  for(int i=0;i < GroundReactions->GetNumGearUnits();i++)
    GroundReactions->GetGearUnit(i)->SetReport(true);
 
  return !trim_failed;
}

Here is the call graph for this function:

◆ EditState()

bool EditState	(	State	state,
		Control	new_control
	)

Change the control used to zero a state previously configured.

Parameters

state	the accel or other condition to zero
new_control	the control used to zero the state

Definition at line 180 of file FGTrim.cpp.

                                                        {
  mode = tCustom;
  vector <FGTrimAxis>::iterator iAxes = TrimAxes.begin();
  while (iAxes != TrimAxes.end()) {
      if( iAxes->GetStateType() == state ) {
        *iAxes = FGTrimAxis(fdmex,&fgic,state,new_control);
        return true;
      }
      ++iAxes;
  }
  return false;
}

◆ GetGammaFallback()

bool GetGammaFallback ( void )

inline

query the fallback state

Returns: true if fallback is enabled.

Definition at line 249 of file FGTrim.h.

249{ return gamma_fallback; }

◆ GetTargetNlf()

double GetTargetNlf ( void )

inline

Definition at line 289 of file FGTrim.h.

289{ return targetNlf; }

◆ RemoveState()

bool RemoveState ( State state )

Remove a specific state-control pair from the current configuration.

Parameters

state the state to remove

Returns: true if removal is successful

Definition at line 157 of file FGTrim.cpp.

                                      {
  bool result=false;
 
  mode = tCustom;
  vector <FGTrimAxis>::iterator iAxes = TrimAxes.begin();
  while (iAxes != TrimAxes.end()) {
      if( iAxes->GetStateType() == state ) {
        iAxes = TrimAxes.erase(iAxes);
        result=true;
        continue;
      }
      ++iAxes;
  }
  if(result) {
    sub_iterations.resize(TrimAxes.size());
    successful.resize(TrimAxes.size());
    solution.resize(TrimAxes.size());
  }
  return result;
}

◆ Report()

void Report ( void )

Print the results of the trim.

For each axis trimmed, this includes the final state value, control value, and tolerance used.

Returns: true if trim succeeds

Definition at line 121 of file FGTrim.cpp.

                        {
  FGLogging out(LogLevel::STDOUT);
  out << "  Trim Results:\n";
  for(unsigned int current_axis=0; current_axis<TrimAxes.size(); current_axis++)
    TrimAxes[current_axis].AxisReport();
}

◆ SetDebug()

void SetDebug ( int level )

inline

Debug level 1 shows results of each top-level iteration Debug level 2 shows level 1 & results of each per-axis iteration.

Definition at line 279 of file FGTrim.h.

279{ DebugLevel = level; }

◆ SetGammaFallback()

void SetGammaFallback ( bool bb )

inline

automatically switch to trimming longitudinal acceleration with flight path angle (gamma) once it becomes apparent that there is not enough/too much thrust.

Parameters

bb	true to enable fallback

Definition at line 244 of file FGTrim.h.

244{ gamma_fallback=bb; }

◆ SetMaxCycles()

void SetMaxCycles ( int ii )

inline

Set the iteration limit.

DoTrim() will return false if limit iterations are reached before trim is achieved. The default is 60. This does not ordinarily need to be changed.

Parameters

ii	integer iteration limit

Definition at line 256 of file FGTrim.h.

256{ max_iterations = ii; }

◆ SetMaxCyclesPerAxis()

void SetMaxCyclesPerAxis ( int ii )

inline

Set the per-axis iteration limit.

Attempt to zero each state by iterating limit times before moving on to the next. The default limit is 100 and also does not ordinarily need to be changed.

Parameters

ii	integer iteration limit

Definition at line 264 of file FGTrim.h.

264{ max_sub_iterations = ii; }

◆ SetMode()

void SetMode ( TrimMode tm )

Clear all state-control pairs and set a predefined trim mode.

Parameters

tm	the set of axes to trim. Can be: tLongitudinal, tFull, tGround, tCustom, or tNone

Definition at line 833 of file FGTrim.cpp.

                                {
    ClearStates();
    mode=tt;
    switch(tt) {
      case tFull:
        if (debug_lvl > 0) {
          FGLogging log(LogLevel::DEBUG);
          log << "  Full Trim\n";
        }
        TrimAxes.push_back(FGTrimAxis(fdmex,&fgic,tWdot,tAlpha));
        TrimAxes.push_back(FGTrimAxis(fdmex,&fgic,tUdot,tThrottle ));
        TrimAxes.push_back(FGTrimAxis(fdmex,&fgic,tQdot,tPitchTrim ));
        //TrimAxes.push_back(FGTrimAxis(fdmex,&fgic,tHmgt,tBeta ));
        TrimAxes.push_back(FGTrimAxis(fdmex,&fgic,tVdot,tPhi ));
        TrimAxes.push_back(FGTrimAxis(fdmex,&fgic,tPdot,tAileron ));
        TrimAxes.push_back(FGTrimAxis(fdmex,&fgic,tRdot,tRudder ));
        break;
      case tLongitudinal:
        if (debug_lvl > 0) {
          FGLogging log(LogLevel::DEBUG);
          log << "  Longitudinal Trim\n";
        }
        TrimAxes.push_back(FGTrimAxis(fdmex,&fgic,tWdot,tAlpha ));
        TrimAxes.push_back(FGTrimAxis(fdmex,&fgic,tUdot,tThrottle ));
        TrimAxes.push_back(FGTrimAxis(fdmex,&fgic,tQdot,tPitchTrim ));
        break;
      case tGround:
        if (debug_lvl > 0) {
          FGLogging log(LogLevel::DEBUG);
          log << "  Ground Trim\n";
        }
        TrimAxes.push_back(FGTrimAxis(fdmex,&fgic,tWdot,tAltAGL ));
        TrimAxes.push_back(FGTrimAxis(fdmex,&fgic,tQdot,tTheta ));
        TrimAxes.push_back(FGTrimAxis(fdmex,&fgic,tPdot,tPhi ));
        break;
      case tPullup:
        TrimAxes.push_back(FGTrimAxis(fdmex,&fgic,tNlf,tAlpha ));
        TrimAxes.push_back(FGTrimAxis(fdmex,&fgic,tUdot,tThrottle ));
        TrimAxes.push_back(FGTrimAxis(fdmex,&fgic,tQdot,tPitchTrim ));
        TrimAxes.push_back(FGTrimAxis(fdmex,&fgic,tHmgt,tBeta ));
        TrimAxes.push_back(FGTrimAxis(fdmex,&fgic,tVdot,tPhi ));
        TrimAxes.push_back(FGTrimAxis(fdmex,&fgic,tPdot,tAileron ));
        TrimAxes.push_back(FGTrimAxis(fdmex,&fgic,tRdot,tRudder ));
        break;
      case tTurn:
        TrimAxes.push_back(FGTrimAxis(fdmex,&fgic,tWdot,tAlpha ));
        TrimAxes.push_back(FGTrimAxis(fdmex,&fgic,tUdot,tThrottle ));
        TrimAxes.push_back(FGTrimAxis(fdmex,&fgic,tQdot,tPitchTrim ));
        TrimAxes.push_back(FGTrimAxis(fdmex,&fgic,tVdot,tBeta ));
        TrimAxes.push_back(FGTrimAxis(fdmex,&fgic,tPdot,tAileron ));
        TrimAxes.push_back(FGTrimAxis(fdmex,&fgic,tRdot,tRudder ));
        break;
      case tCustom:
      case tNone:
        break;
    }
    //FGLogging log(LogLevel::INFO);
    //log << "TrimAxes.size(): " << TrimAxes.size() << "\n";
    sub_iterations.resize(TrimAxes.size());
    successful.resize(TrimAxes.size());
    solution.resize(TrimAxes.size());
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetTargetNlf()

void SetTargetNlf ( double nlf )

inline

Definition at line 288 of file FGTrim.h.

288{ targetNlf=nlf; }

◆ SetTolerance()

void SetTolerance ( double tt )

inline

Set the tolerance for declaring a state trimmed.

Angular accels are held to a tolerance of 1/10th of the given. The default is 0.001 for the recti-linear accelerations and 0.0001 for the angular.

Definition at line 270 of file FGTrim.h.

                                      {
    Tolerance = tt;
    A_Tolerance = tt / 10;
  }

◆ TrimStats()

void TrimStats ( )

Iteration statistics.

Definition at line 99 of file FGTrim.cpp.

                       {
  int run_sum=0;
  FGLogging out(LogLevel::STDOUT);
  out << "\n  Trim Statistics:\n";
  out << "    Total Iterations: " << total_its << "\n";
  if( total_its > 0) {
    out << "    Sub-iterations:\n";
    for (unsigned int current_axis=0; current_axis<TrimAxes.size(); current_axis++) {
      run_sum += TrimAxes[current_axis].GetRunCount();
      out << "   " << setw(5) << TrimAxes[current_axis].GetStateName().c_str()
           << ": " << setprecision(3) << sub_iterations[current_axis]
           << " average: " << setprecision(5) << sub_iterations[current_axis]/double(total_its)
           << "  successful:  " << setprecision(3) << successful[current_axis]
           << "  stability: " << setprecision(5) << TrimAxes[current_axis].GetAvgStability()
           << "\n";
    }
    out << "    Run Count: " << run_sum << "\n";
  }
}

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

Detailed Description

Public Member Functions

Additional Inherited Members

Constructor & Destructor Documentation

◆ FGTrim()

◆ ~FGTrim()

Member Function Documentation

◆ AddState()

◆ ClearDebug()

◆ ClearStates()

◆ DebugState()

◆ DoTrim()

◆ EditState()

◆ GetGammaFallback()

◆ GetTargetNlf()

◆ RemoveState()

◆ Report()

◆ SetDebug()

◆ SetGammaFallback()

◆ SetMaxCycles()

◆ SetMaxCyclesPerAxis()

◆ SetMode()

◆ SetTargetNlf()

◆ SetTolerance()

◆ TrimStats()