JSBSim Flight Dynamics Model 1.2.2 (22 Mar 2025)
An Open Source Flight Dynamics and Control Software Library in C++
Loading...
Searching...
No Matches
Public Member Functions | List of all members
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;
JSBSim::FGTable
Lookup table class.
Definition FGTable.h:234

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.
 
 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.
 
double GetValue (double rowKey, double colKey) const
 Get a value from a 2D internal table.
 
double GetValue (double rowKey, double colKey, double TableKey) const
 Get a value from a 3D internal table.
 
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.
 
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. 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/(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__
 

Constructor & Destructor Documentation

◆ ~FGTable()

~FGTable ( )

Destructor.

Definition at line 436 of file FGTable.cpp.

437{
438 // Untie the bound property so that it makes no further reference to this
439 // instance of FGTable after the destruction is completed.
440 if (!Name.empty() && !internal) {
441 string tmp = PropertyManager->mkPropertyName(Name, false);
442 FGPropertyNode* node = PropertyManager->GetNode(tmp);
443 if (node && node->isTied())
444 PropertyManager->Untie(node);
445 }
446
447 Debug(1);
448}

◆ FGTable() [1/4]

FGTable ( const FGTable &  table)

This is the very important copy constructor.

Parameters
tablea const reference to a table.

Definition at line 77 of file FGTable.cpp.

78 : PropertyManager(t.PropertyManager)
79{
80 Type = t.Type;
81 nRows = t.nRows;
82 nCols = t.nCols;
83 internal = t.internal;
84 Name = t.Name;
85 lookupProperty[0] = t.lookupProperty[0];
86 lookupProperty[1] = t.lookupProperty[1];
87 lookupProperty[2] = t.lookupProperty[2];
88
89 // Deep copy of t.Tables
90 Tables.reserve(t.Tables.size());
91 for(const auto &t: t.Tables)
92 Tables.push_back(std::make_unique<FGTable>(*t));
93
94 Data = t.Data;
95}
JSBSim::FGTable::FGTable
FGTable(const FGTable &table)
This is the very important copy constructor.
Definition FGTable.cpp:77

◆ FGTable() [2/4]

FGTable ( std::shared_ptr< FGPropertyManager >  propMan,
Element *  el,
const std::string &  prefix = "" 
)

The constructor for a table.

Definition at line 113 of file FGTable.cpp.

115 : PropertyManager(pm)
116{
117 string brkpt_string;
118 Element *tableData = nullptr;
119
120 // Is this an internal lookup table?
121
122 Name = el->GetAttributeValue("name"); // Allow this table to be named with a property
123 string call_type = el->GetAttributeValue("type");
124 if (call_type == "internal") {
125 internal = true;
126 } else if (!call_type.empty()) {
127 std::cerr << el->ReadFrom()
128 <<" An unknown table type attribute is listed: " << call_type
129 << endl;
130 throw BaseException("Unknown table type.");
131 }
132
133 // Determine and store the lookup properties for this table unless this table
134 // is part of a 3D table, in which case its independentVar property indexes
135 // will be set by a call from the owning table during creation
136
137 unsigned int dimension = 0;
138
139 Element* axisElement = el->FindElement("independentVar");
140 if (axisElement) {
141
142 // The 'internal' attribute of the table element cannot be specified
143 // at the same time that independentVars are specified.
144 if (internal) {
145 cerr << el->ReadFrom()
146 << fgred << " This table specifies both 'internal' call type" << endl
147 << " and specific lookup properties via the 'independentVar' element." << endl
148 << " These are mutually exclusive specifications. The 'internal'" << endl
149 << " attribute will be ignored." << fgdef << endl << endl;
150 internal = false;
151 }
152
153 while (axisElement) {
154 string property_string = axisElement->GetDataLine();
155 if (property_string.find("#") != string::npos) {
156 if (is_number(Prefix)) {
157 property_string = replace(property_string,"#",Prefix);
158 }
159 }
160
161 FGPropertyValue_ptr node = new FGPropertyValue(property_string,
162 PropertyManager, axisElement);
163 string lookup_axis = axisElement->GetAttributeValue("lookup");
164 if (lookup_axis == string("row")) {
165 lookupProperty[eRow] = node;
166 dimension = std::max(dimension, 1u);
167 } else if (lookup_axis == string("column")) {
168 lookupProperty[eColumn] = node;
169 dimension = std::max(dimension, 2u);
170 } else if (lookup_axis == string("table")) {
171 lookupProperty[eTable] = node;
172 dimension = std::max(dimension, 3u);
173 } else if (!lookup_axis.empty()) {
174 throw BaseException("Lookup table axis specification not understood: " + lookup_axis);
175 } else { // assumed single dimension table; row lookup
176 lookupProperty[eRow] = node;
177 dimension = std::max(dimension, 1u);
178 }
179 axisElement = el->FindNextElement("independentVar");
180 }
181
182 } else if (internal) { // This table is an internal table
183
184 // determine how many rows, columns, and tables in this table (dimension).
185
186 if (el->GetNumElements("tableData") > 1) {
187 dimension = 3; // this is a 3D table
188 } else {
189 tableData = el->FindElement("tableData");
190 if (tableData) {
191 unsigned int nLines = tableData->GetNumDataLines();
192 unsigned int nColumns = FindNumColumns(tableData->GetDataLine(0));
193 if (nLines > 1) {
194 unsigned int nColumns1 = FindNumColumns(tableData->GetDataLine(1));
195 if (nColumns1 == nColumns + 1) {
196 dimension = 2;
197 nColumns = nColumns1;
198 }
199 else
200 dimension = 1;
201
202 // Check that every line (but the header line) has the same number of
203 // columns.
204 for(unsigned int i=1; i<nLines; ++i) {
205 if (FindNumColumns(tableData->GetDataLine(i)) != nColumns) {
206 std::cerr << tableData->ReadFrom()
207 << "Invalid number of columns in line "
208 << tableData->GetLineNumber()+i << endl;
209 throw BaseException("Invalid number of columns in table");
210 }
211 }
212 }
213 else
214 dimension = 1;
215
216 if (dimension == 1 && nColumns != 2) {
217 std::cerr << tableData->ReadFrom()
218 << "Too many columns for a 1D table" << endl;
219 throw BaseException("Too many columns for a 1D table");
220 }
221 }
222 }
223
224 } else {
225 brkpt_string = el->GetAttributeValue("breakPoint");
226 if (brkpt_string.empty()) {
227 // no independentVars found, and table is not marked as internal, nor is it
228 // a 3D table
229 std::cerr << el->ReadFrom()
230 << "No independentVars found, and table is not marked as internal,"
231 << " nor is it a 3D table." << endl;
232 throw BaseException("No independent variable found for table.");
233 }
234 }
235 // end lookup property code
236
237 if (brkpt_string.empty()) { // Not a 3D table "table element"
238 // Force the dimension to 3 if there are several instances of <tableData>.
239 // This is needed for sanity checks.
240 if (el->GetNumElements("tableData") > 1) dimension = 3;
241 tableData = el->FindElement("tableData");
242 } else { // This is a table in a 3D table
243 tableData = el;
244 dimension = 2; // Currently, infers 2D table
245 }
246
247 if (!tableData) {
248 std::cerr << el->ReadFrom()
249 << "FGTable: <tableData> elements are missing" << endl;
250 throw BaseException("FGTable: <tableData> elements are missing");
251 }
252 else if (tableData->GetNumDataLines() == 0) {
253 std::cerr << tableData->ReadFrom() << "<tableData> is empty." << endl;
254 throw BaseException("<tableData> is empty.");
255 }
256
257 // Check that the lookup axes match the declared dimension of the table.
258 if (!internal && brkpt_string.empty()) {
259 switch (dimension) {
260 case 3u:
261 if (!lookupProperty[eTable]) {
262 std::cerr << el->ReadFrom()
263 << "FGTable: missing lookup axis \"table\"";
264 throw BaseException("FGTable: missing lookup axis \"table\"");
265 }
266 // Don't break as we want to investigate the other lookup axes as well.
267 case 2u:
268 if (!lookupProperty[eColumn]) {
269 std::cerr << el->ReadFrom()
270 << "FGTable: missing lookup axis \"column\"";
271 throw BaseException("FGTable: missing lookup axis \"column\"");
272 }
273 // Don't break as we want to investigate the last lookup axes as well.
274 case 1u:
275 if (!lookupProperty[eRow]) {
276 std::cerr << el->ReadFrom()
277 << "FGTable: missing lookup axis \"row\"";
278 throw BaseException("FGTable: missing lookup axis \"row\"");
279 }
280 break;
281 default:
282 assert(false); // Should never be called
283 break;
284 }
285 }
286
287 stringstream buf;
288
289 for (unsigned int i=0; i<tableData->GetNumDataLines(); i++) {
290 string line = tableData->GetDataLine(i);
291 if (line.find_first_not_of("0123456789.-+eE \t\n") != string::npos) {
292 cerr << " In file " << tableData->GetFileName() << endl
293 << " Illegal character found in line "
294 << tableData->GetLineNumber() + i + 1 << ": " << endl << line << endl;
295 throw BaseException("Illegal character");
296 }
297 buf << line << " ";
298 }
299
300 switch (dimension) {
301 case 1:
302 nRows = tableData->GetNumDataLines();
303 nCols = 1;
304 Type = tt1D;
305 // Fill unused elements with NaNs to detect illegal access.
306 Data.push_back(std::numeric_limits<double>::quiet_NaN());
307 Data.push_back(std::numeric_limits<double>::quiet_NaN());
308 *this << buf;
309 break;
310 case 2:
311 nRows = tableData->GetNumDataLines()-1;
312 nCols = FindNumColumns(tableData->GetDataLine(0));
313 Type = tt2D;
314 // Fill unused elements with NaNs to detect illegal access.
315 Data.push_back(std::numeric_limits<double>::quiet_NaN());
316 *this << buf;
317 break;
318 case 3:
319 nRows = el->GetNumElements("tableData");
320 nCols = 1;
321 Type = tt3D;
322 // Fill unused elements with NaNs to detect illegal access.
323 Data.push_back(std::numeric_limits<double>::quiet_NaN());
324
325 tableData = el->FindElement("tableData");
326 while (tableData) {
327 Tables.push_back(std::make_unique<FGTable>(PropertyManager, tableData));
328 Data.push_back(tableData->GetAttributeValueAsNumber("breakPoint"));
329 Tables.back()->lookupProperty[eRow] = lookupProperty[eRow];
330 Tables.back()->lookupProperty[eColumn] = lookupProperty[eColumn];
331 tableData = el->FindNextElement("tableData");
332 }
333
334 break;
335 default:
336 assert(false); // Should never be called
337 break;
338 }
339
340 Debug(0);
341
342 // Sanity checks: lookup indices must be increasing monotonically
343
344 // find next xml element containing a name attribute
345 // to indicate where the error occured
346 Element* nameel = el;
347 while (nameel != 0 && nameel->GetAttributeValue("name") == "")
348 nameel=nameel->GetParent();
349
350 // check breakpoints, if applicable
351 if (Type == tt3D) {
352 for (unsigned int b=2; b<=Tables.size(); ++b) {
353 if (Data[b] <= Data[b-1]) {
354 std::cerr << el->ReadFrom()
355 << fgred << highint
356 << " FGTable: breakpoint lookup is not monotonically increasing" << endl
357 << " in breakpoint " << b;
358 if (nameel != 0) std::cerr << " of table in " << nameel->GetAttributeValue("name");
359 std::cerr << ":" << reset << endl
360 << " " << Data[b] << "<=" << Data[b-1] << endl;
361 throw BaseException("Breakpoint lookup is not monotonically increasing");
362 }
363 }
364 }
365
366 // check columns, if applicable
367 if (Type == tt2D) {
368 for (unsigned int c=2; c<=nCols; ++c) {
369 if (Data[c] <= Data[c-1]) {
370 std::cerr << el->ReadFrom()
371 << fgred << highint
372 << " FGTable: column lookup is not monotonically increasing" << endl
373 << " in column " << c;
374 if (nameel != 0) std::cerr << " of table in " << nameel->GetAttributeValue("name");
375 std::cerr << ":" << reset << endl
376 << " " << Data[c] << "<=" << Data[c-1] << endl;
377 throw BaseException("FGTable: column lookup is not monotonically increasing");
378 }
379 }
380 }
381
382 // check rows
383 if (Type != tt3D) { // in 3D tables, check only rows of subtables
384 for (size_t r=2; r<=nRows; ++r) {
385 if (Data[r*(nCols+1)]<=Data[(r-1)*(nCols+1)]) {
386 std::cerr << el->ReadFrom()
387 << fgred << highint
388 << " FGTable: row lookup is not monotonically increasing" << endl
389 << " in row " << r;
390 if (nameel != 0) std::cerr << " of table in " << nameel->GetAttributeValue("name");
391 std::cerr << ":" << reset << endl
392 << " " << Data[r*(nCols+1)] << "<=" << Data[(r-1)*(nCols+1)] << endl;
393 throw BaseException("FGTable: row lookup is not monotonically increasing");
394 }
395 }
396 }
397
398 // Check the table has been entirely populated.
399 switch (Type) {
400 case tt1D:
401 if (Data.size() != 2*nRows+2) missingData(el, 2*nRows, Data.size()-2);
402 break;
403 case tt2D:
404 if (Data.size() != static_cast<size_t>(nRows+1)*(nCols+1))
405 missingData(el, (nRows+1)*(nCols+1)-1, Data.size()-1);
406 break;
407 case tt3D:
408 if (Data.size() != nRows+1) missingData(el, nRows, Data.size()-1);
409 break;
410 default:
411 assert(false); // Should never be called
412 break;
413 }
414
415 bind(el, Prefix);
416
417 if (debug_lvl & 1) Print();
418}
JSBSim::FGJSBBase::fgred
static char fgred[6]
red text
Definition FGJSBBase.h:166
JSBSim::FGJSBBase::fgdef
static char fgdef[6]
default text
Definition FGJSBBase.h:170
JSBSim::FGJSBBase::reset
static char reset[5]
resets text properties
Definition FGJSBBase.h:156
JSBSim::FGJSBBase::highint
static char highint[5]
highlights text
Definition FGJSBBase.h:150
+ Here is the call graph for this function:

◆ FGTable() [3/4]

FGTable ( int  NRows)

Definition at line 54 of file FGTable.cpp.

55 : nRows(NRows), nCols(1)
56{
57 Type = tt1D;
58 // Fill unused elements with NaNs to detect illegal access.
59 Data.push_back(std::numeric_limits<double>::quiet_NaN());
60 Data.push_back(std::numeric_limits<double>::quiet_NaN());
61 Debug(0);
62}

◆ FGTable() [4/4]

FGTable ( int  NRows,
int  NCols 
)

Definition at line 66 of file FGTable.cpp.

67 : nRows(NRows), nCols(NCols)
68{
69 Type = tt2D;
70 // Fill unused elements with NaNs to detect illegal access.
71 Data.push_back(std::numeric_limits<double>::quiet_NaN());
72 Debug(0);
73}

Member Function Documentation

◆ GetElement()

double GetElement ( unsigned int  r,
unsigned int  c 
) const

Definition at line 452 of file FGTable.cpp.

453{
454 assert(r <= nRows && c <= nCols);
455 if (Type == tt3D) {
456 assert(Data.size() == nRows+1);
457 return Data[r];
458 }
459 assert(Data.size() == (nCols+1)*(nRows+1));
460 return Data[r*(nCols+1)+c];
461}

◆ GetMinValue()

double GetMinValue ( void  ) const

Definition at line 582 of file FGTable.cpp.

583{
584 assert(Type == tt1D);
585 assert(Data.size() == 2*nRows+2);
586
587 double minValue = HUGE_VAL;
588
589 for(unsigned int i=1; i<=nRows; ++i)
590 minValue = std::min(minValue, Data[2*i+1]);
591
592 return minValue;
593}

◆ GetName()

std::string GetName ( void  ) const
inlinevirtual

Implements FGParameter.

Definition at line 314 of file FGTable.h.

314{return Name;}

◆ GetNumRows()

unsigned int GetNumRows ( ) const
inline

Definition at line 310 of file FGTable.h.

310{return nRows;}

◆ GetValue() [1/4]

double GetValue ( double  key) const

Get a value from a 1D internal table.

Parameters
keyRow coordinate at which the value must be interpolated
Returns
The interpolated value

Definition at line 493 of file FGTable.cpp.

494{
495 assert(nCols == 1);
496 assert(Data.size() == 2*nRows+2);
497 // If the key is off the end (or before the beginning) of the table, just
498 // return the boundary-table value, do not extrapolate.
499 if (key <= Data[2])
500 return Data[3];
501 else if (key >= Data[2*nRows])
502 return Data[2*nRows+1];
503
504 // Search for the right breakpoint.
505 // This is a linear search, the algorithm is O(n).
506 unsigned int r = 2;
507 while (Data[2*r] < key) r++;
508
509 double x0 = Data[2*r-2];
510 double Span = Data[2*r] - x0;
511 assert(Span > 0.0);
512 double Factor = (key - x0) / Span;
513 assert(Factor >= 0.0 && Factor <= 1.0);
514
515 double y0 = Data[2*r-1];
516 return Factor*(Data[2*r+1] - y0) + y0;
517}

◆ GetValue() [2/4]

double GetValue ( double  rowKey,
double  colKey 
) const

Get a value from a 2D internal table.

Parameters
rowKeyRow coordinate at which the value must be interpolated
colKeyColumn coordinate at which the value must be interpolated
Returns
The interpolated value

Definition at line 521 of file FGTable.cpp.

522{
523 if (nCols == 1) return GetValue(rowKey);
524
525 assert(Type == tt2D);
526 assert(Data.size() == (nCols+1)*(nRows+1));
527
528 unsigned int c = 2;
529 while(Data[c] < colKey && c < nCols) c++;
530 double x0 = Data[c-1];
531 double Span = Data[c] - x0;
532 assert(Span > 0.0);
533 double cFactor = Constrain(0.0, (colKey - x0) / Span, 1.0);
534
535 if (nRows == 1) {
536 double y0 = Data[(nCols+1)+c-1];
537 return cFactor*(Data[(nCols+1)+c] - y0) + y0;
538 }
539
540 size_t r = 2;
541 while(Data[r*(nCols+1)] < rowKey && r < nRows) r++;
542 x0 = Data[(r-1)*(nCols+1)];
543 Span = Data[r*(nCols+1)] - x0;
544 assert(Span > 0.0);
545 double rFactor = Constrain(0.0, (rowKey - x0) / Span, 1.0);
546 double col1temp = rFactor*Data[r*(nCols+1)+c-1]+(1.0-rFactor)*Data[(r-1)*(nCols+1)+c-1];
547 double col2temp = rFactor*Data[r*(nCols+1)+c]+(1.0-rFactor)*Data[(r-1)*(nCols+1)+c];
548
549 return cFactor*(col2temp-col1temp)+col1temp;
550}
JSBSim::FGJSBBase::Constrain
static constexpr double Constrain(double min, double value, double max)
Constrain a value between a minimum and a maximum value.
Definition FGJSBBase.h:288
JSBSim::FGTable::GetValue
double GetValue(void) const
Get the current table value.
Definition FGTable.cpp:465
+ Here is the call graph for this function:

◆ GetValue() [3/4]

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

Get a value from a 3D internal table.

Parameters
rowKeyRow coordinate at which the value must be interpolated
colKeyColumn coordinate at which the value must be interpolated
TableKeyTable coordinate at which the value must be interpolated
Returns
The interpolated value

Definition at line 554 of file FGTable.cpp.

555{
556 assert(Type == tt3D);
557 assert(Data.size() == nRows+1);
558 // If the key is off the end (or before the beginning) of the table, just
559 // return the boundary-table value, do not extrapolate.
560 if(tableKey <= Data[1])
561 return Tables[0]->GetValue(rowKey, colKey);
562 else if (tableKey >= Data[nRows])
563 return Tables[nRows-1]->GetValue(rowKey, colKey);
564
565 // Search for the right breakpoint.
566 // This is a linear search, the algorithm is O(n).
567 unsigned int r = 2;
568 while (Data[r] < tableKey) r++;
569
570 double x0 = Data[r-1];
571 double Span = Data[r] - x0;
572 assert(Span > 0.0);
573 double Factor = (tableKey - x0) / Span;
574 assert(Factor >= 0.0 && Factor <= 1.0);
575
576 double y0 = Tables[r-2]->GetValue(rowKey, colKey);
577 return Factor*(Tables[r-1]->GetValue(rowKey, colKey) - y0) + y0;
578}

◆ GetValue() [4/4]

double GetValue ( void  ) const
virtual

Get the current table value.

Implements FGParameter.

Definition at line 465 of file FGTable.cpp.

466{
467 assert(!internal);
468
469 switch (Type) {
470 case tt1D:
471 assert(lookupProperty[eRow]);
472 return GetValue(lookupProperty[eRow]->getDoubleValue());
473 case tt2D:
474 assert(lookupProperty[eRow]);
475 assert(lookupProperty[eColumn]);
476 return GetValue(lookupProperty[eRow]->getDoubleValue(),
477 lookupProperty[eColumn]->getDoubleValue());
478 case tt3D:
479 assert(lookupProperty[eRow]);
480 assert(lookupProperty[eColumn]);
481 assert(lookupProperty[eTable]);
482 return GetValue(lookupProperty[eRow]->getDoubleValue(),
483 lookupProperty[eColumn]->getDoubleValue(),
484 lookupProperty[eTable]->getDoubleValue());
485 default:
486 assert(false); // Should never be called
487 return std::numeric_limits<double>::quiet_NaN();
488 }
489}
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ operator()()

double operator() ( unsigned int  r,
unsigned int  c 
) const
inline

Definition at line 302 of file FGTable.h.

303 { return GetElement(r, c); }

◆ operator<<() [1/2]

FGTable & operator<< ( const double  x)

Definition at line 611 of file FGTable.cpp.

612{
613 assert(Type != tt3D);
614 Data.push_back(x);
615
616 // Check column is monotically increasing
617 size_t n = Data.size();
618 if (Type == tt2D && nCols > 1 && n >= 3 && n <= nCols+1) {
619 if (Data.at(n-1) <= Data.at(n-2))
620 throw BaseException("FGTable: column lookup is not monotonically increasing");
621 }
622
623 // Check row is monotically increasing
624 size_t row = (n-1) / (nCols+1);
625 if (row >=2 && row*(nCols+1) == n-1) {
626 if (Data.at(row*(nCols+1)) <= Data.at((row-1)*(nCols+1)))
627 throw BaseException("FGTable: row lookup is not monotonically increasing");
628 }
629
630 return *this;
631}

◆ operator<<() [2/2]

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 597 of file FGTable.cpp.

598{
599 double x;
600 assert(Type != tt3D);
601
602 in_stream >> x;
603 while(in_stream) {
604 Data.push_back(x);
605 in_stream >> x;
606 }
607}

◆ Print()

void Print ( void  )

Definition at line 635 of file FGTable.cpp.

636{
637 ios::fmtflags flags = cout.setf(ios::fixed); // set up output stream
638 cout.precision(4);
639
640 switch(Type) {
641 case tt1D:
642 cout << " 1 dimensional table with " << nRows << " rows." << endl;
643 break;
644 case tt2D:
645 cout << " 2 dimensional table with " << nRows << " rows, " << nCols << " columns." << endl;
646 break;
647 case tt3D:
648 cout << " 3 dimensional table with " << nRows << " breakpoints, "
649 << Tables.size() << " tables." << endl;
650 break;
651 }
652 unsigned int startCol=1, startRow=1;
653 unsigned int p = 1;
654
655 if (Type == tt1D) {
656 startCol = 0;
657 p = 2;
658 }
659 if (Type == tt2D) startRow = 0;
660
661 for (unsigned int r=startRow; r<=nRows; r++) {
662 cout << "\t";
663 if (Type == tt2D) {
664 if (r == startRow)
665 cout << "\t";
666 else
667 startCol = 0;
668 }
669
670 for (unsigned int c=startCol; c<=nCols; c++) {
671 cout << Data[p++] << "\t";
672 if (Type == tt3D) {
673 cout << endl;
674 Tables[r-1]->Print();
675 }
676 }
677 cout << endl;
678 }
679 cout.setf(flags); // reset
680}

◆ SetColumnIndexProperty()

void SetColumnIndexProperty ( FGPropertyNode *  node)
inline

Definition at line 307 of file FGTable.h.

308 { lookupProperty[eColumn] = new FGPropertyValue(node); }

◆ SetRowIndexProperty()

void SetRowIndexProperty ( FGPropertyNode *  node)
inline

Definition at line 305 of file FGTable.h.

306 { lookupProperty[eRow] = new FGPropertyValue(node); }
The documentation for this class was generated from the following files: