FGTable Class Reference

Detailed Description

Lookup table class.

Models a one, two, or three dimensional lookup table for use in aerodynamics and function definitions.

For a single "vector" lookup table, the format is as follows:

<table name="property_name">
  <independentVar lookup="row"> property_name </independentVar>
  <tableData>
    key_1 value_1
    key_2 value_2
    ...  ...
    key_n value_n
  </tableData>
</table>

The lookup="row" attribute in the independentVar element is option in this case; it is assumed that the independentVar is a row variable.

A "real life" example is as shown here:

<table>
  <independentVar lookup="row"> aero/alpha-rad </independentVar>
  <tableData>
   -1.57  1.500
   -0.26  0.033
    0.00  0.025
    0.26  0.033
    1.57  1.500
  </tableData>
</table>

The first column in the data table represents the lookup index (or "key"). In this case, the lookup index is aero/alpha-rad (angle of attack in radians). If alpha is 0.26 radians, the value returned from the lookup table would be 0.033.

The definition for a 2D table, is as follows:

<table name="property_name">
  <independentVar lookup="row"> property_name </independentVar>
  <independentVar lookup="column"> property_name </independentVar>
  <tableData>
                {col_1_key   col_2_key   ...  col_n_key }
    {row_1_key} {col_1_data  col_2_data  ...  col_n_data}
    {row_2_key} {...         ...         ...  ...       }
    { ...     } {...         ...         ...  ...       }
    {row_n_key} {...         ...         ...  ...       }
  </tableData>
</table>

The data is in a gridded format.

A "real life" example is as shown below. Alpha in radians is the row lookup (alpha breakpoints are arranged in the first column) and flap position in degrees is

<table>
  <independentVar lookup="row">aero/alpha-rad</independentVar>
  <independentVar lookup="column">fcs/flap-pos-deg</independentVar>
  <tableData>
                0.0         10.0        20.0         30.0
    -0.0523599  8.96747e-05 0.00231942  0.0059252    0.00835082
    -0.0349066  0.000313268 0.00567451  0.0108461    0.0140545
    -0.0174533  0.00201318  0.0105059   0.0172432    0.0212346
     0.0        0.0051894   0.0168137   0.0251167    0.0298909
     0.0174533  0.00993967  0.0247521   0.0346492    0.0402205
     0.0349066  0.0162201   0.0342207   0.0457119    0.0520802
     0.0523599  0.0240308   0.0452195   0.0583047    0.0654701
     0.0698132  0.0333717   0.0577485   0.0724278    0.0803902
     0.0872664  0.0442427   0.0718077   0.088081     0.0968405
  </tableData>
</table>

The definition for a 3D table in a coefficient would be (for example):

<table name="property_name">
  <independentVar lookup="row"> property_name </independentVar>
  <independentVar lookup="column"> property_name </independentVar>
  <tableData breakpoint="table_1_key">
                {col_1_key   col_2_key   ...  col_n_key }
    {row_1_key} {col_1_data  col_2_data  ...  col_n_data}
    {row_2_key} {...         ...         ...  ...       }
    { ...     } {...         ...         ...  ...       }
    {row_n_key} {...         ...         ...  ...       }
  </tableData>
  <tableData breakpoint="table_2_key">
                {col_1_key   col_2_key   ...  col_n_key }
    {row_1_key} {col_1_data  col_2_data  ...  col_n_data}
    {row_2_key} {...         ...         ...  ...       }
    { ...     } {...         ...         ...  ...       }
    {row_n_key} {...         ...         ...  ...       }
  </tableData>
  ...
  <tableData breakpoint="table_n_key">
                {col_1_key   col_2_key   ...  col_n_key }
    {row_1_key} {col_1_data  col_2_data  ...  col_n_data}
    {row_2_key} {...         ...         ...  ...       }
    { ...     } {...         ...         ...  ...       }
    {row_n_key} {...         ...         ...  ...       }
  </tableData>
</table>

[Note the "breakpoint" attribute in the tableData element, above.]

Here's an example:

<table>
  <independentVar lookup="row">fcs/row-value</independentVar>
  <independentVar lookup="column">fcs/column-value</independentVar>
  <independentVar lookup="table">fcs/table-value</independentVar>
  <tableData breakPoint="-1.0">
           -1.0     1.0
    0.0     1.0000  2.0000
    1.0     3.0000  4.0000
  </tableData>
  <tableData breakPoint="0.0000">
            0.0     10.0
    2.0     1.0000  2.0000
    3.0     3.0000  4.0000
  </tableData>
  <tableData breakPoint="1.0">
           0.0     10.0     20.0
     2.0   1.0000   2.0000   3.0000
     3.0   4.0000   5.0000   6.0000
    10.0   7.0000   8.0000   9.0000
  </tableData>
</table>

In addition to using a Table for something like a coefficient, where all the row and column elements are read in from a file, a Table could be created and populated completely within program code:

// First column is thi, second is neta (combustion efficiency)
Lookup_Combustion_Efficiency = new FGTable(12);
 
*Lookup_Combustion_Efficiency << 0.00 << 0.980;
*Lookup_Combustion_Efficiency << 0.90 << 0.980;
*Lookup_Combustion_Efficiency << 1.00 << 0.970;
*Lookup_Combustion_Efficiency << 1.05 << 0.950;
*Lookup_Combustion_Efficiency << 1.10 << 0.900;
*Lookup_Combustion_Efficiency << 1.15 << 0.850;
*Lookup_Combustion_Efficiency << 1.20 << 0.790;
*Lookup_Combustion_Efficiency << 1.30 << 0.700;
*Lookup_Combustion_Efficiency << 1.40 << 0.630;
*Lookup_Combustion_Efficiency << 1.50 << 0.570;
*Lookup_Combustion_Efficiency << 1.60 << 0.525;
*Lookup_Combustion_Efficiency << 2.00 << 0.345;

The first column in the table, above, is thi (the lookup index, or key). The second column is the output data - in this case, "neta" (the Greek letter referring to combustion efficiency). Later on, the table is used like this:

combustion_efficiency = Lookup_Combustion_Efficiency->GetValue(equivalence_ratio);

Author

Jon S. Berndt

Definition at line 233 of file FGTable.h.

#include <FGTable.h>

Inheritance diagram for FGTable:

Collaboration diagram for FGTable:

Public Member Functions
	FGTable (const FGTable &table)
	This is the very important copy constructor. More...
	FGTable (int)
	FGTable (int, int)
	FGTable (std::shared_ptr< FGPropertyManager > propMan, Element *el, const std::string &prefix="")
	The constructor for a table.
	~FGTable ()
	Destructor.
double	GetElement (unsigned int r, unsigned int c) const
double	GetMinValue (double colKey) const
double	GetMinValue (double colKey, double TableKey) const
double	GetMinValue (void) const
std::string	GetName (void) const
unsigned int	GetNumRows () const
double	GetValue (double key) const
	Get a value from a 1D internal table. More...
double	GetValue (double rowKey, double colKey) const
	Get a value from a 2D internal table. More...
double	GetValue (double rowKey, double colKey, double TableKey) const
	Get a value from a 3D internal table. More...
double	GetValue (void) const
	Get the current table value.
double	operator() (unsigned int r, unsigned int c) const
FGTable &	operator<< (const double x)
void	operator<< (std::istream &)
	Read the table in. More...
FGTable &	operator= (const FGTable &)
	Copy assignment constructor.
void	Print (void)
void	SetColumnIndexProperty (FGPropertyNode *node)
void	SetRowIndexProperty (FGPropertyNode *node)
Public Member Functions inherited from FGParameter
double	getDoubleValue (void) const
virtual bool	IsConstant (void) const
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.
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.
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__

Constructor & Destructor Documentation

FGTable()

FGTable

(

const FGTable &

table

)

This is the very important copy constructor.

Parameters

table

a const reference to a table.

Definition at line 76 of file FGTable.cpp.

  : PropertyManager(t.PropertyManager)
{
  Type = t.Type;
  nRows = t.nRows;
  nCols = t.nCols;
  internal = t.internal;
  Name = t.Name;
  lookupProperty[0] = t.lookupProperty[0];
  lookupProperty[1] = t.lookupProperty[1];
  lookupProperty[2] = t.lookupProperty[2];
 
  // Deep copy of t.Tables
  Tables.reserve(t.Tables.size());
  for(const auto &t: t.Tables)
    Tables.push_back(std::make_unique<FGTable>(*t));
 
  Data = t.Data;
}

Member Function Documentation

GetValue() [1/3]

double GetValue

(

double

key

)

const

Get a value from a 1D internal table.

Parameters

key	Row coordinate at which the value must be interpolated

Returns

The interpolated value

Definition at line 492 of file FGTable.cpp.

{
  assert(nCols == 1);
  assert(Data.size() == 2*nRows+2);
  // If the key is off the end (or before the beginning) of the table, just
  // return the boundary-table value, do not extrapolate.
  if (key <= Data[2])
    return Data[3];
  else if (key >= Data[2*nRows])
    return Data[2*nRows+1];
 
  // Search for the right breakpoint.
  // This is a linear search, the algorithm is O(n).
  unsigned int r = 2;
  while (Data[2*r] < key) r++;
 
  double x0 = Data[2*r-2];
  double Span = Data[2*r] - x0;
  assert(Span > 0.0);
  double Factor = (key - x0) / Span;
  assert(Factor >= 0.0 && Factor <= 1.0);
 
  double y0 = Data[2*r-1];
  return Factor*(Data[2*r+1] - y0) + y0;
}

GetValue() [2/3]

double GetValue	(	double	rowKey,
		double	colKey
	)		const

Get a value from a 2D internal table.

Parameters

rowKey	Row coordinate at which the value must be interpolated
colKey	Column coordinate at which the value must be interpolated

Returns

The interpolated value

Definition at line 520 of file FGTable.cpp.

{
  if (nCols == 1) return GetValue(rowKey);
 
  assert(Type == tt2D);
  assert(Data.size() == (nCols+1)*(nRows+1));
 
  unsigned int c = 2;
  while(Data[c] < colKey && c < nCols) c++;
  double x0 = Data[c-1];
  double Span = Data[c] - x0;
  assert(Span > 0.0);
  double cFactor = Constrain(0.0, (colKey - x0) / Span, 1.0);
 
  if (nRows == 1) {
    double y0 = Data[(nCols+1)+c-1];
    return cFactor*(Data[(nCols+1)+c] - y0) + y0;
  }
 
  size_t r = 2;
  while(Data[r*(nCols+1)] < rowKey && r < nRows) r++;
  x0 = Data[(r-1)*(nCols+1)];
  Span = Data[r*(nCols+1)] - x0;
  assert(Span > 0.0);
  double rFactor = Constrain(0.0, (rowKey - x0) / Span, 1.0);
  double col1temp = rFactor*Data[r*(nCols+1)+c-1]+(1.0-rFactor)*Data[(r-1)*(nCols+1)+c-1];
  double col2temp = rFactor*Data[r*(nCols+1)+c]+(1.0-rFactor)*Data[(r-1)*(nCols+1)+c];
 
  return cFactor*(col2temp-col1temp)+col1temp;
}

Here is the call graph for this function:

GetValue() [3/3]

double GetValue	(	double	rowKey,
		double	colKey,
		double	TableKey
	)		const

Get a value from a 3D internal table.

Parameters

rowKey	Row coordinate at which the value must be interpolated
colKey	Column coordinate at which the value must be interpolated
TableKey	Table coordinate at which the value must be interpolated

Returns

The interpolated value

Definition at line 553 of file FGTable.cpp.

{
  assert(Type == tt3D);
  assert(Data.size() == nRows+1);
  // If the key is off the end (or before the beginning) of the table, just
  // return the boundary-table value, do not extrapolate.
  if(tableKey <= Data[1])
    return Tables[0]->GetValue(rowKey, colKey);
  else if (tableKey >= Data[nRows])
    return Tables[nRows-1]->GetValue(rowKey, colKey);
 
  // Search for the right breakpoint.
  // This is a linear search, the algorithm is O(n).
  unsigned int r = 2;
  while (Data[r] < tableKey) r++;
 
  double x0 = Data[r-1];
  double Span = Data[r] - x0;
  assert(Span > 0.0);
  double Factor = (tableKey - x0) / Span;
  assert(Factor >= 0.0 && Factor <= 1.0);
 
  double y0 = Tables[r-2]->GetValue(rowKey, colKey);
  return Factor*(Tables[r-1]->GetValue(rowKey, colKey) - y0) + y0;
}

operator<<()

void operator<<

(

std::istream &

in_stream

)

Read the table in.

Data in the config file should be in matrix format with the row independents as the first column and the column independents in the first row. The implication of this layout is that there should be no value in the upper left corner of the matrix e.g:

     0  10  20 30 ...
-5   1  2   3  4  ...
 ...
 

For multiple-table (i.e. 3D) data sets there is an additional number key in the table definition. For example:

 0.0
     0  10  20 30 ...
-5   1  2   3  4  ...
 ...
 

Definition at line 596 of file FGTable.cpp.

{
  double x;
  assert(Type != tt3D);
 
  in_stream >> x;
  while(in_stream) {
    Data.push_back(x);
    in_stream >> x;
  }
}

---

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

• FGTable.h
• FGTable.cpp