Detailed Description

Encapsulates the JSBSim simulation executive.

This class is the executive class through which all other simulation classes are instantiated, initialized, and run. When integrated with FlightGear (or other flight simulator) this class is typically instantiated by an interface class on the simulator side.

At the time of simulation initialization, the interface class creates an instance of this executive class. The executive is subsequently directed to load the chosen aircraft specification file:

fdmex = new FGFDMExec( ... );

result = fdmex->LoadModel( ... );

JSBSim::FGFDMExec::FGFDMExec

FGFDMExec(FGPropertyManager *root=nullptr, std::shared_ptr< unsigned int > fdmctr=nullptr)

Default constructor.

Definition: FGFDMExec.cpp:78

When an aircraft model is loaded, the config file is parsed and for each of the sections of the config file (propulsion, flight control, etc.) the corresponding Load() method is called (e.g. FGFCS::Load()).

Subsequent to the creation of the executive and loading of the model, initialization is performed. Initialization involves copying control inputs into the appropriate JSBSim data storage locations, configuring it for the set of user supplied initial conditions, and then copying state variables from JSBSim. The state variables are used to drive the instrument displays and to place the vehicle model in world space for visual rendering:

copy_to_JSBsim(); // copy control inputs to JSBSim
fdmex->RunIC(); // loop JSBSim once w/o integrating
copy_from_JSBsim(); // update the bus

Once initialization is complete, cyclic execution proceeds:

copy_to_JSBsim(); // copy control inputs to JSBSim
fdmex->Run(); // execute JSBSim
copy_from_JSBsim(); // update the bus

JSBSim can be used in a standalone mode by creating a compact stub program that effectively performs the same progression of steps as outlined above for the integrated version, but with two exceptions. First, the copy_to_JSBSim() and copy_from_JSBSim() functions are not used because the control inputs are handled directly by the scripting facilities and outputs are handled by the output (data logging) class. Second, the name of a script file can be supplied to the stub program. Scripting (see FGScript) provides a way to supply command inputs to the simulation:

FDMExec = new JSBSim::FGFDMExec();
FDMExec->LoadScript( ScriptName ); // the script loads the aircraft and ICs
result = FDMExec->Run();
while (result) { // cyclic execution
  result = FDMExec->Run(); // execute JSBSim
}

The standalone mode has been useful for verifying changes before committing updates to the source code repository. It is also useful for running sets of tests that reveal some aspects of simulated aircraft performance, such as range, time-to-climb, takeoff distance, etc.

JSBSim Debugging Directives

This describes to any interested entity the debug level requested by setting the JSBSIM_DEBUG environment variable. The bitmasked value choices are as follows:

unset: In this case (the default) JSBSim would only print out the normally expected messages, essentially echoing the config files as they are read. If the environment variable is not set, debug_lvl is set to 1 internally
0: This requests JSBSim not to output any messages whatsoever
1: This value explicity requests the normal JSBSim startup messages
2: This value asks for a message to be printed out when a class is instantiated
4: When this value is set, a message is displayed when a FGModel object executes its Run() method
8: When this value is set, various runtime state variables are printed out periodically
16: When set various parameters are sanity checked and a message is printed out when they go out of bounds

Properties

simulator/do_trim (write only) Can be set to the integer equivalent to one of tLongitudinal (0), tFull (1), tGround (2), tPullup (3), tCustom (4), tTurn (5). Setting this to a legal value (such as by a script) causes a trim to be performed. This property actually maps toa function call of DoTrim().

Author: Jon S. Berndt

Version

Revision: 1.106

Definition at line 183 of file FGFDMExec.h.

#include <FGFDMExec.h>

Inheritance diagram for FGFDMExec:

Collaboration diagram for FGFDMExec:

Classes
struct	PropertyCatalogStructure

Public Types
enum	eModels { ePropagate =0 , eInput , eInertial , eAtmosphere , eWinds , eSystems , eMassBalance , eAuxiliary , ePropulsion , eAerodynamics , eGroundReactions , eExternalReactions , eBuoyantForces , eAircraft , eAccelerations , eOutput , eNumStandardModels }

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.

Public Member Functions
	FGFDMExec (FGPropertyManager *root=nullptr, std::shared_ptr< unsigned int > fdmctr=nullptr)
	Default constructor.

	~FGFDMExec ()
	Default destructor.

void	AddTemplateFunc (const std::string &name, Element *el)

void	BuildPropertyCatalog (struct PropertyCatalogStructure *pcs)
	Builds a catalog of properties. More...

void	CheckIncrementalHold (void)
	Checks if required to hold afer increment.

void	DisableOutput (void)
	Disables data logging to all outputs.

void	DoTrim (int mode)
	Executes trimming in the selected mode. More...

void	EnableIncrementThenHold (int Timesteps)
	Turn on hold after increment.

void	EnableOutput (void)
	Enables data logging to all outputs.

std::vector< std::string >	EnumerateFDMs (void)
	Returns a vector of strings representing the names of all loaded models (future)

void	ForceOutput (int idx=0)
	Forces the specified output object to print its items once.

const SGPath &	GetAircraftPath (void)
	Retrieves the aircraft path.

auto	GetChildFDM (int i) const
	Gets a particular child FDM.

int	GetDebugLevel (void) const
	Retrieves the current debug level setting.

double	GetDeltaT (void) const
	Returns the simulation delta T.

const SGPath &	GetEnginePath (void)
	Retrieves the engine path.

size_t	GetFDMCount (void) const
	Gets the number of child FDMs.

unsigned int	GetFrame (void) const
	Retrieves the current frame count.

const SGPath &	GetFullAircraftPath (void)
	Retrieves the full aircraft path name.

bool	GetHoldDown (void) const
	Gets the value of the property forces/hold-down. More...

const std::string &	GetModelName (void) const
	Returns the model name.

std::string	GetOutputFileName (int n) const
	Retrieves the current output filename. More...

const SGPath &	GetOutputPath (void)
	Retrieves the path to the output files.

std::vector< std::string > &	GetPropertyCatalog (void)

std::shared_ptr< FGPropertyManager >	GetPropertyManager (void) const
	Returns a pointer to the property manager object.

double	GetPropertyValue (const std::string &property)
	Retrieves the value of a property. More...

std::string	GetPropulsionTankReport () const

auto	GetRandomGenerator (void) const

const SGPath &	GetRootDir (void) const
	Retrieve the Root Directory. More...

double	GetSimTime (void) const
	Returns the cumulative simulation time in seconds.

const SGPath &	GetSystemsPath (void)
	Retrieves the systems path.

FGTemplateFunc_ptr	GetTemplateFunc (const std::string &name)

int	GetTrimMode (void) const

bool	GetTrimStatus (void) const

void	Hold (void)
	Pauses execution by preventing time from incrementing.

bool	Holding (void)
	Returns true if the simulation is Holding (i.e. simulation time is not moving).

double	IncrTime (void)
	Increments the simulation time if not in Holding mode. More...

void	Initialize (const FGInitialCondition *FGIC)
	Initializes the simulation with initial conditions. More...

bool	IntegrationSuspended (void) const
	Returns the simulation suspension state. More...

bool	LoadModel (const SGPath &AircraftPath, const SGPath &EnginePath, const SGPath &SystemsPath, const std::string &model, bool addModelToPath=true)
	Loads an aircraft model. More...

bool	LoadModel (const std::string &model, bool addModelToPath=true)
	Loads an aircraft model. More...

bool	LoadPlanet (const SGPath &PlanetPath, bool useAircraftPath=true)
	Loads the planet. More...

bool	LoadScript (const SGPath &Script, double deltaT=0.0, const SGPath &initfile=SGPath())
	Load a script. More...

void	PrintPropertyCatalog (void)

void	PrintSimulationConfiguration (void) const

std::string	QueryPropertyCatalog (const std::string &check, const std::string &end_of_line="\n")
	Retrieves property or properties matching the supplied string. More...

void	ResetToInitialConditions (int mode)
	Resets the initial conditions object and prepares the simulation to run again. More...

void	Resume (void)
	Resumes execution from a "Hold".

void	ResumeIntegration (void)
	Resumes the simulation by resetting delta T to the correct value.

bool	Run (void)
	This function executes each scheduled model in succession. More...

bool	RunIC (void)
	Initializes the sim from the initial condition object and executes each scheduled model without integrating i.e. More...

bool	SetAircraftPath (const SGPath &path)
	Set the path to the aircraft config file directories. More...

void	SetChild (bool ch)
	Marks this instance of the Exec object as a "child" object.

void	SetDebugLevel (int level)
	Sets the debug level.

void	Setdt (double delta_t)
	Sets the integration time step for the simulation executive. More...

bool	SetEnginePath (const SGPath &path)
	Set the path to the engine config file directories. More...

void	SetHoldDown (bool hd)
	Sets the property forces/hold-down. More...

void	SetLoggingRate (double rate)
	Sets the logging rate in Hz for all output objects (if any).

bool	SetOutputDirectives (const SGPath &fname)
	Sets the output (logging) mechanism for this run. More...

bool	SetOutputFileName (const int n, const std::string &fname)
	Sets (or overrides) the output filename. More...

bool	SetOutputPath (const SGPath &path)
	Set the directory where the output files will be written. More...

void	SetPropertyValue (const std::string &property, double value)
	Sets a property value. More...

void	SetRootDir (const SGPath &rootDir)
	Set the root directory that is used to obtain absolute paths from relative paths. More...

double	Setsim_time (double cur_time)
	Sets the current sim time. More...

bool	SetSystemsPath (const SGPath &path)
	Set the path to the systems config file directories. More...

void	SetTrimMode (int mode)

void	SetTrimStatus (bool status)

void	SuspendIntegration (void)
	Suspends the simulation and sets the delta T to zero.

void	Unbind (void)
	Unbind all tied JSBSim properties.

Top-level executive State and Model retrieval mechanism
Returns the FGAtmosphere pointer.
std::shared_ptr< FGAtmosphere >	GetAtmosphere (void) const

std::shared_ptr< FGAccelerations >	GetAccelerations (void) const
	Returns the FGAccelerations pointer.

std::shared_ptr< FGWinds >	GetWinds (void) const
	Returns the FGWinds pointer.

std::shared_ptr< FGFCS >	GetFCS (void) const
	Returns the FGFCS pointer.

std::shared_ptr< FGPropulsion >	GetPropulsion (void) const
	Returns the FGPropulsion pointer.

std::shared_ptr< FGMassBalance >	GetMassBalance (void) const
	Returns the FGAircraft pointer.

std::shared_ptr< FGAerodynamics >	GetAerodynamics (void) const
	Returns the FGAerodynamics pointer.

std::shared_ptr< FGInertial >	GetInertial (void) const
	Returns the FGInertial pointer.

std::shared_ptr< FGGroundReactions >	GetGroundReactions (void) const
	Returns the FGGroundReactions pointer.

std::shared_ptr< FGExternalReactions >	GetExternalReactions (void) const
	Returns the FGExternalReactions pointer.

std::shared_ptr< FGBuoyantForces >	GetBuoyantForces (void) const
	Returns the FGBuoyantForces pointer.

std::shared_ptr< FGAircraft >	GetAircraft (void) const
	Returns the FGAircraft pointer.

std::shared_ptr< FGPropagate >	GetPropagate (void) const
	Returns the FGPropagate pointer.

std::shared_ptr< FGAuxiliary >	GetAuxiliary (void) const
	Returns the FGAuxiliary pointer.

std::shared_ptr< FGInput >	GetInput (void) const
	Returns the FGInput pointer.

std::shared_ptr< FGOutput >	GetOutput (void) const
	Returns the FGOutput pointer.

std::shared_ptr< FGScript >	GetScript (void) const
	Retrieves the script object.

std::shared_ptr< FGInitialCondition >	GetIC (void) const
	Returns a pointer to the FGInitialCondition object.

std::shared_ptr< FGTrim >	GetTrim (void)
	Returns a pointer to the FGTrim object.

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

virtual	~FGJSBBase ()
	Destructor for FGJSBBase.

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

Static Public Attributes
static const int	DONT_EXECUTE_RUN_IC = 0x2

static const int	START_NEW_OUTPUT = 0x1
	Mode flags for ResetToInitialConditions.

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

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

Member Function Documentation

◆ BuildPropertyCatalog()

void BuildPropertyCatalog ( struct PropertyCatalogStructure * pcs )

Builds a catalog of properties.

This function descends the property tree and creates a list (an STL vector) containing the name and node for all properties.

Parameters

pcs	The "root" property catalog structure pointer.

Definition at line 1069 of file FGFDMExec.cpp.

 {
   auto pcsNew = std::make_unique<struct PropertyCatalogStructure>();
  
   for (int i=0; i<pcs->node->nChildren(); i++) {
     string access="";
     pcsNew->base_string = pcs->base_string + "/" + pcs->node->getChild(i)->getNameString();
     int node_idx = pcs->node->getChild(i)->getIndex();
     if (node_idx != 0) {
       pcsNew->base_string = CreateIndexedPropertyName(pcsNew->base_string, node_idx);
     }
     if (pcs->node->getChild(i)->nChildren() == 0) {
       if (pcsNew->base_string.substr(0,12) == string("/fdm/jsbsim/")) {
         pcsNew->base_string = pcsNew->base_string.erase(0,12);
       }
       if (pcs->node->getChild(i)->getAttribute(SGPropertyNode::READ)) access="R";
       if (pcs->node->getChild(i)->getAttribute(SGPropertyNode::WRITE)) access+="W";
       PropertyCatalog.push_back(pcsNew->base_string+" ("+access+")");
     } else {
       pcsNew->node = (FGPropertyNode*)pcs->node->getChild(i);
       BuildPropertyCatalog(pcsNew.get());
     }
   }
 }

Here is the caller graph for this function:

◆ DoTrim()

void DoTrim ( int mode )

Executes trimming in the selected mode.

Parameters

mode	Specifies how to trim: tLongitudinal=0 tFull tGround tPullup tCustom tTurn tNone

Definition at line 1297 of file FGFDMExec.cpp.

 {
   if (Constructing) return;
  
   if (mode < 0 || mode > JSBSim::tNone)
     throw("Illegal trimming mode!");
  
   FGTrim trim(this, (JSBSim::TrimMode)mode);
   bool success = trim.DoTrim();
  
   if (debug_lvl > 0)
     trim.Report();
  
   if (!success)
     throw TrimFailureException("Trim Failed");
  
   trim_completed = 1;
 }

Here is the caller graph for this function:

◆ GetHoldDown()

bool GetHoldDown ( void ) const

inline

Gets the value of the property forces/hold-down.

Returns: zero if the 'hold-down' function is disabled, non-zero otherwise.

Definition at line 611 of file FGFDMExec.h.

611 {return HoldDown;}

Here is the caller graph for this function:

◆ GetOutputFileName()

std::string GetOutputFileName ( int n ) const

inline

Retrieves the current output filename.

Parameters

n	index of file

Returns: the name of the output file for the output specified by the flight model. If none is specified, the empty string is returned.

Definition at line 465 of file FGFDMExec.h.

465 { return Output->GetOutputName(n); }

JSBSim::FGOutput::GetOutputName

std::string GetOutputName(unsigned int idx) const

Get the name identifier to which the output will be directed.

Definition: FGOutput.cpp:161

◆ GetPropertyValue()

double GetPropertyValue ( const std::string & property )

inline

Retrieves the value of a property.

Parameters

property the name of the property

Returns: the value of the specified property

Definition at line 408 of file FGFDMExec.h.

409 { return instance->GetNode()->GetDouble(property); }

◆ GetRootDir()

const SGPath& GetRootDir ( void ) const

inline

Retrieve the Root Directory.

Returns: the path to the root (base) JSBSim directory.

See also: SetRootDir

Definition at line 585 of file FGFDMExec.h.

585 {return RootDir;}

◆ IncrTime()

double IncrTime ( void )

Increments the simulation time if not in Holding mode.

The Frame counter is also incremented.

Returns: the new simulation time.

Definition at line 202 of file FGFDMExec.cpp.

                                {
   if (!holding && !IntegrationSuspended()) {
     sim_time += dT;
     Inertial->SetTime(sim_time);
     Frame++;
   }
   return sim_time;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Initialize()

void Initialize ( const FGInitialCondition * FGIC )

Initializes the simulation with initial conditions.

Parameters

FGIC	The initial conditions that will be passed to the simulation.

Definition at line 680 of file FGFDMExec.cpp.

 {
   Propagate->SetInitialState(FGIC);
   Winds->SetWindNED(FGIC->GetWindNEDFpsIC());
   Run();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IntegrationSuspended()

bool IntegrationSuspended ( void ) const

inline

Returns the simulation suspension state.

Returns: true if suspended, false if executing

Definition at line 557 of file FGFDMExec.h.

557 {return dT == 0.0;}

Here is the caller graph for this function:

◆ LoadModel() [1/2]

bool LoadModel	(	const SGPath &	AircraftPath,
		const SGPath &	EnginePath,
		const SGPath &	SystemsPath,
		const std::string &	model,
		bool	addModelToPath = `true`
	)

Loads an aircraft model.

Parameters

AircraftPath	path to the aircraft/ directory. For instance: "aircraft". Under aircraft, then, would be directories for various modeled aircraft such as C172/, x15/, etc.
EnginePath	path to the directory under which engine config files are kept, for instance "engine"
SystemsPath	path to the directory under which systems config files are kept, for instance "systems"
model	the name of the aircraft model itself. This file will be looked for in the directory specified in the AircraftPath variable, and in turn under the directory with the same name as the model. For instance: "aircraft/x15/x15.xml"
addModelToPath	set to true to add the model name to the AircraftPath, defaults to true

Returns: true if successful

Definition at line 821 of file FGFDMExec.cpp.

 {
   FGFDMExec::AircraftPath = GetFullPath(AircraftPath);
   FGFDMExec::EnginePath = GetFullPath(EnginePath);
   FGFDMExec::SystemsPath = GetFullPath(SystemsPath);
  
   return LoadModel(model, addModelToPath);
 }

Here is the caller graph for this function:

◆ LoadModel() [2/2]

bool LoadModel	(	const std::string &	model,
		bool	addModelToPath = `true`
	)

Loads an aircraft model.

The paths to the aircraft and engine config file directories must be set prior to calling this. See below.

Parameters

model	the name of the aircraft model itself. This file will be looked for in the directory specified in the AircraftPath variable, and in turn under the directory with the same name as the model. For instance: "aircraft/x15/x15.xml"
addModelToPath	set to true to add the model name to the AircraftPath, defaults to true

Returns: true if successful

Definition at line 834 of file FGFDMExec.cpp.

 {
   SGPath aircraftCfgFileName;
   bool result = false; // initialize result to false, indicating input file not yet read
  
   modelName = model; // Set the class modelName attribute
  
   if( AircraftPath.isNull() || EnginePath.isNull() || SystemsPath.isNull()) {
     cerr << "Error: attempted to load aircraft with undefined "
          << "aircraft, engine, and system paths" << endl;
     return false;
   }
  
   FullAircraftPath = AircraftPath;
   if (addModelToPath) FullAircraftPath.append(model);
   aircraftCfgFileName = FullAircraftPath/(model + ".xml");
  
   if (modelLoaded) {
     DeAllocate();
     Allocate();
   }
  
   int saved_debug_lvl = debug_lvl;
   FGXMLFileRead XMLFileRead;
   Element *document = XMLFileRead.LoadXMLDocument(aircraftCfgFileName); // "document" is a class member
  
   if (document) {
     if (IsChild) debug_lvl = 0;
  
     ReadPrologue(document);
  
     if (IsChild) debug_lvl = saved_debug_lvl;
  
     // Process the fileheader element in the aircraft config file. This element is OPTIONAL.
     Element* element = document->FindElement("fileheader");
     if (element) {
       result = ReadFileHeader(element);
       if (!result) {
         cerr << endl << "Aircraft fileheader element has problems in file " << aircraftCfgFileName << endl;
         return result;
       }
     }
  
     if (IsChild) debug_lvl = 0;
  
     // Process the planet element. This element is OPTIONAL.
     element = document->FindElement("planet");
     if (element) {
       result = LoadPlanet(element);
       if (!result) {
         cerr << endl << "Planet element has problems in file " << aircraftCfgFileName << endl;
         return result;
       }
     }
  
     // Process the metrics element. This element is REQUIRED.
     element = document->FindElement("metrics");
     if (element) {
       result = Models[eAircraft]->Load(element);
       if (!result) {
         cerr << endl << "Aircraft metrics element has problems in file " << aircraftCfgFileName << endl;
         return result;
       }
     } else {
       cerr << endl << "No metrics element was found in the aircraft config file." << endl;
       return false;
     }
  
     // Process the mass_balance element. This element is REQUIRED.
     element = document->FindElement("mass_balance");
     if (element) {
       result = Models[eMassBalance]->Load(element);
       if (!result) {
         cerr << endl << "Aircraft mass_balance element has problems in file " << aircraftCfgFileName << endl;
         return result;
       }
     } else {
       cerr << endl << "No mass_balance element was found in the aircraft config file." << endl;
       return false;
     }
  
     // Process the ground_reactions element. This element is REQUIRED.
     element = document->FindElement("ground_reactions");
     if (element) {
       result = Models[eGroundReactions]->Load(element);
       if (!result) {
         cerr << endl << element->ReadFrom()
              << "Aircraft ground_reactions element has problems in file "
              << aircraftCfgFileName << endl;
         return result;
       }
     } else {
       cerr << endl << "No ground_reactions element was found in the aircraft config file." << endl;
       return false;
     }
  
     // Process the external_reactions element. This element is OPTIONAL.
     element = document->FindElement("external_reactions");
     if (element) {
       result = Models[eExternalReactions]->Load(element);
       if (!result) {
         cerr << endl << "Aircraft external_reactions element has problems in file " << aircraftCfgFileName << endl;
         return result;
       }
     }
  
     // Process the buoyant_forces element. This element is OPTIONAL.
     element = document->FindElement("buoyant_forces");
     if (element) {
       result = Models[eBuoyantForces]->Load(element);
       if (!result) {
         cerr << endl << "Aircraft buoyant_forces element has problems in file " << aircraftCfgFileName << endl;
         return result;
       }
     }
  
     // Process the propulsion element. This element is OPTIONAL.
     element = document->FindElement("propulsion");
     if (element) {
       result = Propulsion->Load(element);
       if (!result) {
         cerr << endl << "Aircraft propulsion element has problems in file " << aircraftCfgFileName << endl;
         return result;
       }
       for (unsigned int i=0; i < Propulsion->GetNumEngines(); i++)
         FCS->AddThrottle();
     }
  
     // Process the system element[s]. This element is OPTIONAL, and there may be more than one.
     element = document->FindElement("system");
     while (element) {
       result = Models[eSystems]->Load(element);
       if (!result) {
         cerr << endl << "Aircraft system element has problems in file " << aircraftCfgFileName << endl;
         return result;
       }
       element = document->FindNextElement("system");
     }
  
     // Process the autopilot element. This element is OPTIONAL.
     element = document->FindElement("autopilot");
     if (element) {
       result = Models[eSystems]->Load(element);
       if (!result) {
         cerr << endl << "Aircraft autopilot element has problems in file " << aircraftCfgFileName << endl;
         return result;
       }
     }
  
     // Process the flight_control element. This element is OPTIONAL.
     element = document->FindElement("flight_control");
     if (element) {
       result = Models[eSystems]->Load(element);
       if (!result) {
         cerr << endl << "Aircraft flight_control element has problems in file " << aircraftCfgFileName << endl;
         return result;
       }
     }
  
     // Process the aerodynamics element. This element is OPTIONAL, but almost always expected.
     element = document->FindElement("aerodynamics");
     if (element) {
       result = Models[eAerodynamics]->Load(element);
       if (!result) {
         cerr << endl << "Aircraft aerodynamics element has problems in file " << aircraftCfgFileName << endl;
         return result;
       }
     } else {
       cerr << endl << "No expected aerodynamics element was found in the aircraft config file." << endl;
     }
  
     // Process the input element. This element is OPTIONAL, and there may be more than one.
     element = document->FindElement("input");
     while (element) {
       if (!Input->Load(element))
         return false;
  
       element = document->FindNextElement("input");
     }
  
     // Process the output element[s]. This element is OPTIONAL, and there may be
     // more than one.
     element = document->FindElement("output");
     while (element) {
       if (!Output->Load(element))
         return false;
  
       element = document->FindNextElement("output");
     }
  
     // Lastly, process the child element. This element is OPTIONAL - and NOT YET SUPPORTED.
     element = document->FindElement("child");
     if (element) {
       result = ReadChild(element);
       if (!result) {
         cerr << endl << "Aircraft child element has problems in file " << aircraftCfgFileName << endl;
         return result;
       }
     }
  
     // Since all vehicle characteristics have been loaded, place the values in the Inputs
     // structure for the FGModel-derived classes.
     LoadModelConstants();
  
     modelLoaded = true;
  
     if (IsChild) debug_lvl = saved_debug_lvl;
  
   } else {
     cerr << fgred
          << "  JSBSim failed to open the configuration file: " << aircraftCfgFileName
          << fgdef << endl;
   }
  
   for (unsigned int i=0; i< Models.size(); i++) LoadInputs(i);
  
   if (result) {
     struct PropertyCatalogStructure masterPCS;
     masterPCS.base_string = "";
     masterPCS.node = Root;
     BuildPropertyCatalog(&masterPCS);
   }
  
   return result;
 }

Here is the call graph for this function:

◆ LoadPlanet()

bool LoadPlanet	(	const SGPath &	PlanetPath,
		bool	useAircraftPath = `true`
	)

Loads the planet.

Loads the definition of the planet on which the vehicle will evolve such as its radius, gravity or its atmosphere characteristics.

Parameters

PlanetPath	The name of a planet definition file
useAircraftPath	true if path is given relative to the aircraft path.

Returns: true if successful

Definition at line 745 of file FGFDMExec.cpp.

 {
   SGPath PlanetFileName;
  
   if(useAircraftPath && PlanetPath.isRelative()) {
     PlanetFileName = AircraftPath/PlanetPath.utf8Str();
   } else {
     PlanetFileName = PlanetPath;
   }
  
   FGXMLFileRead XMLFileRead;
   Element* document = XMLFileRead.LoadXMLDocument(PlanetFileName);
  
   // Make sure that the document is valid
   if (!document) {
     stringstream s;
     s << "File: " << PlanetFileName << " could not be read.";
     cerr << s.str() << endl;
     throw BaseException(s.str());
   }
  
   if (document->GetName() != "planet") {
     stringstream s;
     s << "File: " << PlanetFileName << " is not a planet file.";
     cerr << s.str() << endl;
     throw BaseException(s.str());
   }
  
   bool result = LoadPlanet(document);
  
   if (!result)
     cerr << endl << "Planet element has problems in file " << PlanetFileName << endl;
  
   return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LoadScript()

bool LoadScript	(	const SGPath &	Script,
		double	deltaT = `0.0`,
		const SGPath &	initfile = `SGPath()`
	)

Load a script.

Parameters

Script	The full path name and file name for the script to be loaded.
deltaT	The simulation integration step size, if given. If no value is supplied then 0.0 is used and the value is expected to be supplied in the script file itself.
initfile	The initialization file that will override the initialization file specified in the script file. If no file name is given on the command line, the file specified in the script will be used. If an initialization file is not given in either place, an error will result.

Returns: true if successfully loads; false otherwise.

Definition at line 736 of file FGFDMExec.cpp.

 {
   Script = std::make_shared<FGScript>(this);
   return Script->LoadScript(GetFullPath(script), deltaT, initfile);
 }

◆ QueryPropertyCatalog()

string QueryPropertyCatalog	(	const std::string &	check,
		const std::string &	end_of_line = `"\n"`
	)

Retrieves property or properties matching the supplied string.

A string is returned that contains a carriage return delimited list of all strings in the property catalog that matches the supplied check string.

Parameters

check	The string to search for in the property catalog.
end_of_line	End of line (CR+LF if needed for Windows).

Returns: the carriage-return-delimited string containing all matching strings in the catalog.

Definition at line 1096 of file FGFDMExec.cpp.

 {
   string results;
   for (auto &catalogElm: PropertyCatalog) {
     if (catalogElm.find(in) != string::npos) results += catalogElm + end_of_line;
   }
   if (results.empty()) return "No matches found"+end_of_line;
   return results;
 }

Here is the caller graph for this function:

◆ ResetToInitialConditions()

void ResetToInitialConditions ( int mode )

Resets the initial conditions object and prepares the simulation to run again.

If the mode's first bit is set the output instances will take special actions such as closing the current output file and open a new one with a different name. If the second bit is set then RunIC() won't be executed, leaving it to the caller to call RunIC(), e.g. in case the caller wants to set some other state like control surface deflections which would've been reset.

Parameters

mode	Sets the reset mode.

Definition at line 689 of file FGFDMExec.cpp.

 {
   if (Constructing) return;
  
   // mode flags
  
   if (mode & START_NEW_OUTPUT) Output->SetStartNewOutput();
  
   InitializeModels();
  
   if (Script)
     Script->ResetEvents();
   else
     Setsim_time(0.0);
  
   if (!(mode & DONT_EXECUTE_RUN_IC))
     RunIC();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Run()

bool Run ( void )

This function executes each scheduled model in succession.

Returns: true if successful, false if sim should be ended

Definition at line 413 of file FGFDMExec.cpp.

 {
   bool success=true;
  
   Debug(2);
  
   for (auto &ChildFDM: ChildFDMList) {
     ChildFDM->AssignState(Propagate); // Transfer state to the child FDM
     ChildFDM->Run();
   }
  
   IncrTime();
  
   // returns true if success, false if complete
   if (Script && !IntegrationSuspended()) success = Script->RunScript();
  
   for (unsigned int i = 0; i < Models.size(); i++) {
     LoadInputs(i);
     Models[i]->Run(holding);
   }
  
   if (Terminate) success = false;
  
   return success;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RunIC()

bool RunIC ( void )

Initializes the sim from the initial condition object and executes each scheduled model without integrating i.e.

dt=0.

Returns: true if successful

Definition at line 643 of file FGFDMExec.cpp.

 {
   SuspendIntegration(); // saves the integration rate, dt, then sets it to 0.0.
   Initialize(IC.get());
  
   Models[eInput]->InitModel();
   Models[eOutput]->InitModel();
  
   Run();
   Propagate->InitializeDerivatives();
   ResumeIntegration(); // Restores the integration rate to what it was.
  
   if (debug_lvl > 0) {
     MassBalance->GetMassPropertiesReport(0);
  
     cout << endl << fgblue << highint
          << "End of vehicle configuration loading." << endl
          << "-------------------------------------------------------------------------------"
          << reset << std::setprecision(6) << endl;
   }
  
   for (unsigned int n=0; n < Propulsion->GetNumEngines(); ++n) {
     if (IC->IsEngineRunning(n)) {
       try {
         Propulsion->InitRunning(n);
       } catch (const string& str) {
         cerr << str << endl;
         return false;
       }
     }
   }
  
   return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetAircraftPath()

bool SetAircraftPath ( const SGPath & path )

inline

Set the path to the aircraft config file directories.

Under this path, then, would be directories for various modeled aircraft such as C172/, x15/, etc. Relative paths are taken from the root directory.

Parameters

path	path to the aircraft directory, for instance "aircraft".

See also: SetRootDir; GetAircraftPath

Definition at line 325 of file FGFDMExec.h.

                                            {
     AircraftPath = GetFullPath(path);
     return true;
   }

◆ Setdt()

void Setdt ( double delta_t )

inline

Sets the integration time step for the simulation executive.

Parameters

delta_t the time step in seconds.

Definition at line 566 of file FGFDMExec.h.

566 { dT = delta_t; }

Here is the caller graph for this function:

◆ SetEnginePath()

bool SetEnginePath ( const SGPath & path )

inline

Set the path to the engine config file directories.

Relative paths are taken from the root directory.

Parameters

path	path to the directory under which engine config files are kept, for instance "engine".

See also: SetRootDir; GetEnginePath

Definition at line 313 of file FGFDMExec.h.

                                          {
     EnginePath = GetFullPath(path);
     return true;
   }

◆ SetHoldDown()

void SetHoldDown ( bool hd )

Sets the property forces/hold-down.

This allows to do hard 'hold-down' such as for rockets on a launch pad with engines ignited.

Parameters

hd	enables the 'hold-down' function if non-zero

Definition at line 710 of file FGFDMExec.cpp.

 {
   HoldDown = hd;
   Accelerations->SetHoldDown(hd);
   if (hd) {
     Propagate->in.vPQRidot = Accelerations->GetPQRidot();
     Propagate->in.vUVWidot = Accelerations->GetUVWidot();
   }
   Propagate->SetHoldDown(hd);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetOutputDirectives()

bool SetOutputDirectives ( const SGPath & fname )

inline

Sets the output (logging) mechanism for this run.

Calling this function passes the name of an output directives file to the FGOutput object associated with this run. The call to this function should be made prior to loading an aircraft model. This call results in an FGOutput object being built as the first Output object in the FDMExec-managed list of Output objects that may be created for an aircraft model. If this call is made after an aircraft model is loaded, there is no effect. Any Output objects added by the aircraft model itself (in an <output> element) will be added after this one. Care should be taken not to refer to the same file name. An output directives file contains an <output> </output> element, within which should be specified the parameters or parameter groups that should be logged.

Parameters

fname the filename of an output directives file.

Definition at line 446 of file FGFDMExec.h.

447 { return Output->SetDirectivesFile(GetFullPath(fname)); }

JSBSim::FGOutput::SetDirectivesFile

bool SetDirectivesFile(const SGPath &fname)

Adds a new output instance to the Output Manager.

Definition: FGOutput.cpp:172

◆ SetOutputFileName()

bool SetOutputFileName	(	const int	n,
		const std::string &	fname
	)

inline

Sets (or overrides) the output filename.

Parameters

n	index of file
fname	the name of the file to output data to

Returns: true if successful, false if there is no output specified for the flight model

Definition at line 459 of file FGFDMExec.h.

459 { return Output->SetOutputName(n, fname); }

JSBSim::FGOutput::SetOutputName

bool SetOutputName(unsigned int idx, const std::string &name)

Overwrites the name identifier under which the output will be logged.

Definition: FGOutput.cpp:151

◆ SetOutputPath()

bool SetOutputPath ( const SGPath & path )

inline

Set the directory where the output files will be written.

Relative paths are taken from the root directory.

Parameters

path	path to the directory under which the output files will be written.

See also: SetRootDir; GetOutputPath

Definition at line 347 of file FGFDMExec.h.

                                          {
     OutputPath = GetFullPath(path);
     return true;
   }

◆ SetPropertyValue()

void SetPropertyValue	(	const std::string &	property,
		double	value
	)

inline

Sets a property value.

Parameters

property	the property to be set
value	the value to set the property to

Definition at line 414 of file FGFDMExec.h.

415 { instance->GetNode()->SetDouble(property, value); }

◆ SetRootDir()

void SetRootDir ( const SGPath & rootDir )

inline

Set the root directory that is used to obtain absolute paths from relative paths.

Aircraft, engine, systems and output paths are not updated by this method. You must call each methods (SetAircraftPath(), SetEnginePath(), etc.) individually if you need to update these paths as well.

Parameters

rootDir the path to the root directory.

See also: GetRootDir; SetAircraftPath; SetEnginePath; SetSystemsPath; SetOutputPath

Definition at line 580 of file FGFDMExec.h.

580 {RootDir = rootDir;}

◆ Setsim_time()

double Setsim_time ( double cur_time )

Sets the current sim time.

Parameters

cur_time the current time

Returns: the current simulation time.

Definition at line 194 of file FGFDMExec.cpp.

                                              {
   sim_time = cur_time;
   Inertial->SetTime(sim_time);
   return sim_time;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetSystemsPath()

bool SetSystemsPath ( const SGPath & path )

inline

Set the path to the systems config file directories.

Relative paths are taken from the root directory.

Parameters

path	path to the directory under which systems config files are kept, for instance "systems"

See also: SetRootDir; GetSystemsPath

Definition at line 336 of file FGFDMExec.h.

                                           {
     SystemsPath = GetFullPath(path);
     return true;
   }

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

Detailed Description

JSBSim Debugging Directives

Properties

Classes

Public Types

Public Member Functions

Static Public Attributes

Additional Inherited Members

Member Function Documentation

◆ BuildPropertyCatalog()

◆ DoTrim()

◆ GetHoldDown()

◆ GetOutputFileName()

◆ GetPropertyValue()

◆ GetRootDir()

◆ IncrTime()

◆ Initialize()

◆ IntegrationSuspended()

◆ LoadModel() [1/2]

◆ LoadModel() [2/2]

◆ LoadPlanet()

◆ LoadScript()

◆ QueryPropertyCatalog()

◆ ResetToInitialConditions()

◆ Run()

◆ RunIC()

◆ SetAircraftPath()

◆ Setdt()

◆ SetEnginePath()

◆ SetHoldDown()

◆ SetOutputDirectives()

◆ SetOutputFileName()

◆ SetOutputPath()

◆ SetPropertyValue()

◆ SetRootDir()

◆ Setsim_time()

◆ SetSystemsPath()