JSBSim Flight Dynamics Model 1.2.3 (07 Jun 2025)
An Open Source Flight Dynamics and Control Software Library in C++
Loading...
Searching...
No Matches
FGPropulsion Class Reference

Detailed Description

Propulsion management class.

The Propulsion class is the container for the entire propulsion system, which is comprised of engines, and tanks. Once the Propulsion class gets the config file, it reads in the <propulsion> section. Then:

  1. The appropriate engine type instance is created
  2. At least one tank object is created, and is linked to an engine.

At Run time each engine's Calculate() method is called.

Configuration File Format:

<propulsion>
<engine file="{string}">
... see FGEngine, FGThruster, and class for engine type ...
</engine>
... more engines ...
<tank type="{FUEL | OXIDIZER}">
... see FGTank ...
</tank>
... more tanks ...
<dump-rate unit="{LBS/MIN | KG/MIN}"> {number} </dump-rate>
<refuel-rate unit="{LBS/MIN | KG/MIN}"> {number} </refuel-rate>
</propulsion>
Base class for all engines.
Definition FGEngine.h:104
Models a fuel tank.
Definition FGTank.h:203
Base class for specific thrusting devices such as propellers, nozzles, etc.
Definition FGThruster.h:77
Author
Jon S. Berndt
See also
FGEngine FGTank

Definition at line 98 of file FGPropulsion.h.

#include <FGPropulsion.h>

+ Inheritance diagram for FGPropulsion:
+ Collaboration diagram for FGPropulsion:

Public Member Functions

 FGPropulsion (FGFDMExec *)
 Constructor.
 
 ~FGPropulsion () override
 Destructor.
 
const FGMatrix33CalculateTankInertias (void)
 
void DoRefuel (double time_slice)
 
void DumpFuel (double time_slice)
 
SGPath FindFullPathName (const SGPath &path) const override
 
int GetActiveEngine (void) const
 
int GetCutoff (void) const
 
auto GetEngine (unsigned int index) const
 Retrieves an engine object pointer from the list of engines.
 
double GetForces (int n) const
 
const FGColumnVector3GetForces (void) const
 
bool GetFuelFreeze (void) const
 
double GetMoments (int n) const
 
const FGColumnVector3GetMoments (void) const
 
size_t GetNumEngines (void) const
 Retrieves the number of engines defined for the aircraft.
 
size_t GetNumTanks (void) const
 Retrieves the number of tanks defined for the aircraft.
 
std::string GetPropulsionStrings (const std::string &delimiter) const
 
std::string GetPropulsionTankReport ()
 
std::string GetPropulsionValues (const std::string &delimiter) const
 
int GetStarter (void) const
 
bool GetSteadyState (void)
 Loops the engines until thrust output steady (used for trimming)
 
auto GetTank (unsigned int index) const
 Retrieves a tank object pointer from the list of tanks.
 
const FGColumnVector3GetTanksMoment (void)
 
double GetTanksWeight (void) const
 
bool InitModel (void) override
 
void InitRunning (int n)
 Sets up the engines as running.
 
bool Load (Element *el) override
 Loads the propulsion system (engine[s] and tank[s]).
 
bool Run (bool Holding) override
 Executes the propulsion model.
 
void SetActiveEngine (int engine)
 
void SetCutoff (int setting=0)
 
void SetEngineRunning (int index)
 
void SetFuelFreeze (bool f)
 
void SetMagnetos (int setting)
 
void SetStarter (int setting)
 
double Transfer (int source, int target, double amount)
 
- Public Member Functions inherited from FGModel
 FGModel (FGFDMExec *)
 Constructor.
 
 ~FGModel () override
 Destructor.
 
FGFDMExecGetExec (void)
 
const std::string & GetName (void)
 
unsigned int GetRate (void)
 Get the output rate for the model in frames.
 
void SetPropertyManager (std::shared_ptr< FGPropertyManager > fgpm)
 
void SetRate (unsigned int tt)
 Set the ouput rate for the model in frames.
 
- Public Member Functions inherited from FGModelFunctions
std::string GetFunctionStrings (const std::string &delimeter) const
 Gets the strings for the current set of functions.
 
std::string GetFunctionValues (const std::string &delimeter) const
 Gets the function values.
 
std::shared_ptr< FGFunctionGetPreFunction (const std::string &name)
 Get one of the "pre" function.
 
bool Load (Element *el, FGFDMExec *fdmex, std::string prefix="")
 
void PostLoad (Element *el, FGFDMExec *fdmex, std::string prefix="")
 
void PreLoad (Element *el, FGFDMExec *fdmex, std::string prefix="")
 
void RunPostFunctions (void)
 
void RunPreFunctions (void)
 
- Public Member Functions inherited from FGJSBBase
 FGJSBBase ()
 Constructor for FGJSBBase.
 
virtual ~FGJSBBase ()
 Destructor for FGJSBBase.
 
void disableHighLighting (void)
 Disables highlighting in the console output.
 

Public Attributes

struct FGEngine::Inputs in
 

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
 
- Protected Member Functions inherited from FGModel
bool Upload (Element *el, bool preLoad)
 Uploads this model in memory.
 
- Static Protected Member Functions inherited from FGJSBBase
static std::string CreateIndexedPropertyName (const std::string &Property, int index)
 
- Protected Attributes inherited from FGModel
unsigned int exe_ctr
 
FGFDMExecFDMExec
 
std::string Name
 
std::shared_ptr< FGPropertyManagerPropertyManager
 
unsigned int rate
 
- Protected Attributes inherited from FGModelFunctions
FGPropertyReader LocalProperties
 
std::vector< std::shared_ptr< FGFunction > > PostFunctions
 
std::vector< std::shared_ptr< FGFunction > > PreFunctions
 
- 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

◆ FGPropulsion()

FGPropulsion ( FGFDMExec exec)

Constructor.

Definition at line 74 of file FGPropulsion.cpp.

74 : FGModel(exec)
75{
76 Name = "FGPropulsion";
77
78 ActiveEngine = -1; // -1: ALL, 0: Engine 1, 1: Engine 2 ...
79 tankJ.InitMatrix();
80 DumpRate = 0.0;
81 RefuelRate = 6000.0;
82 FuelFreeze = false;
83
84 Debug(0);
85}
void InitMatrix(void)
Initialize the matrix.
FGModel(FGFDMExec *)
Constructor.
Definition FGModel.cpp:57
+ Here is the call graph for this function:

◆ ~FGPropulsion()

~FGPropulsion ( )
override

Destructor.

Definition at line 89 of file FGPropulsion.cpp.

90{
91 Debug(1);
92}

Member Function Documentation

◆ CalculateTankInertias()

const FGMatrix33 & CalculateTankInertias ( void  )

Definition at line 579 of file FGPropulsion.cpp.

580{
581 if (Tanks.empty()) return tankJ;
582
583 tankJ.InitMatrix();
584
585 for (const auto& tank: Tanks) {
586 tankJ += FDMExec->GetMassBalance()->GetPointmassInertia( lbtoslug * tank->GetContents(),
587 tank->GetXYZ());
588 tankJ(1,1) += tank->GetIxx();
589 tankJ(2,2) += tank->GetIyy();
590 tankJ(3,3) += tank->GetIzz();
591 }
592
593 return tankJ;
594}
std::shared_ptr< FGMassBalance > GetMassBalance(void) const
Returns the FGAircraft pointer.

◆ DoRefuel()

void DoRefuel ( double  time_slice)

Definition at line 750 of file FGPropulsion.cpp.

751{
752 double fillrate = RefuelRate / 60.0 * time_slice;
753 int TanksNotFull = 0;
754
755 for (const auto& tank: Tanks) {
756 if (tank->GetPctFull() < 99.99) ++TanksNotFull;
757 }
758
759 // adds fuel equally to all tanks that are not full
760 if (TanksNotFull) {
761 for (unsigned int i=0; i<Tanks.size(); i++) {
762 if (Tanks[i]->GetPctFull() < 99.99)
763 Transfer(-1, i, fillrate/TanksNotFull);
764 }
765 }
766}

◆ DumpFuel()

void DumpFuel ( double  time_slice)

Definition at line 770 of file FGPropulsion.cpp.

771{
772 int TanksDumping = 0;
773
774 for (const auto& tank: Tanks) {
775 if (tank->GetContents() > tank->GetStandpipe()) ++TanksDumping;
776 }
777
778 if (TanksDumping == 0) return;
779
780 double dump_rate_per_tank = DumpRate / 60.0 * time_slice / TanksDumping;
781
782 for (unsigned int i=0; i<Tanks.size(); i++) {
783 if (Tanks[i]->GetContents() > Tanks[i]->GetStandpipe()) {
784 Transfer(i, -1, dump_rate_per_tank);
785 }
786 }
787}

◆ FindFullPathName()

SGPath FindFullPathName ( const SGPath &  path) const
overridevirtual

Reimplemented from FGModel.

Definition at line 446 of file FGPropulsion.cpp.

447{
448 SGPath name = FGModel::FindFullPathName(path);
449 if (!ReadingEngine && !name.isNull()) return name;
450
451#ifdef _WIN32
452 // Singular and plural are allowed for the folder names for consistency with
453 // the default engine folder name "engine" and for backward compatibility
454 // regarding the folder name "Engines".
455 const array<string, 2> dir_names = {"Engines", "engine"};
456#else
457 // Allow alternative capitalization for case sensitive OSes.
458 const array<string, 4> dir_names = {"Engines", "engines", "Engine", "engine"};
459#endif
460
461 for(const string& dir_name: dir_names) {
462 name = CheckPathName(FDMExec->GetFullAircraftPath()/dir_name, path);
463 if (!name.isNull()) return name;
464 }
465
466 return CheckPathName(FDMExec->GetEnginePath(), path);
467}
const SGPath & GetEnginePath(void)
Retrieves the engine path.
Definition FGFDMExec.h:395
const SGPath & GetFullAircraftPath(void)
Retrieves the full aircraft path name.
Definition FGFDMExec.h:401

◆ GetActiveEngine()

int GetActiveEngine ( void  ) const
inline

Definition at line 173 of file FGPropulsion.h.

173{return ActiveEngine;}

◆ GetCutoff()

int GetCutoff ( void  ) const

Definition at line 685 of file FGPropulsion.cpp.

686{
687 if (ActiveEngine < 0) {
688 bool cutoff = true;
689
690 for (auto& engine: Engines) {
691 switch (engine->GetType()) {
692 case FGEngine::etTurbine:
693 cutoff &= static_pointer_cast<FGTurbine>(engine)->GetCutoff();
694 break;
695 case FGEngine::etTurboprop:
696 cutoff &= static_pointer_cast<FGTurboProp>(engine)->GetCutoff();
697 break;
698 default:
699 return -1;
700 }
701 }
702
703 return cutoff ? 1 : 0;
704 } else {
705 auto engine = Engines[ActiveEngine];
706 switch (engine->GetType()) {
707 case FGEngine::etTurbine:
708 return static_pointer_cast<FGTurbine>(engine)->GetCutoff() ? 1 : 0;
709 case FGEngine::etTurboprop:
710 return static_pointer_cast<FGTurboProp>(engine)->GetCutoff() ? 1 : 0;
711 default:
712 break;
713 }
714 }
715
716 return -1;
717}

◆ GetEngine()

auto GetEngine ( unsigned int  index) const
inline

Retrieves an engine object pointer from the list of engines.

Parameters
indexthe engine index within the vector container
Returns
the address of the specific engine, or zero if no such engine is available

Definition at line 132 of file FGPropulsion.h.

132 {
133 assert(index < Engines.size());
134 return Engines[index];
135 }

◆ GetForces() [1/2]

double GetForces ( int  n) const
inline

Definition at line 161 of file FGPropulsion.h.

161{ return vForces(n);}

◆ GetForces() [2/2]

const FGColumnVector3 & GetForces ( void  ) const
inline

Definition at line 160 of file FGPropulsion.h.

160{return vForces; }

◆ GetFuelFreeze()

bool GetFuelFreeze ( void  ) const
inline

Definition at line 174 of file FGPropulsion.h.

174{return FuelFreeze;}

◆ GetMoments() [1/2]

double GetMoments ( int  n) const
inline

Definition at line 163 of file FGPropulsion.h.

163{return vMoments(n);}

◆ GetMoments() [2/2]

const FGColumnVector3 & GetMoments ( void  ) const
inline

Definition at line 162 of file FGPropulsion.h.

162{return vMoments;}

◆ GetNumEngines()

size_t GetNumEngines ( void  ) const
inline

Retrieves the number of engines defined for the aircraft.

Definition at line 126 of file FGPropulsion.h.

126{return Engines.size();}
+ Here is the caller graph for this function:

◆ GetNumTanks()

size_t GetNumTanks ( void  ) const
inline

Retrieves the number of tanks defined for the aircraft.

Definition at line 138 of file FGPropulsion.h.

138{return Tanks.size();}

◆ GetPropulsionStrings()

string GetPropulsionStrings ( const std::string &  delimiter) const

Definition at line 471 of file FGPropulsion.cpp.

472{
473 unsigned int i = 0;
474
475 string PropulsionStrings;
476 bool firstime = true;
477 stringstream buf;
478
479 for (auto& engine: Engines) {
480 if (firstime) firstime = false;
481 else PropulsionStrings += delimiter;
482
483 PropulsionStrings += engine->GetEngineLabels(delimiter);
484 }
485 for (auto& tank: Tanks) {
486 if (tank->GetType() == FGTank::ttFUEL) buf << delimiter << "Fuel Tank " << i++;
487 else if (tank->GetType() == FGTank::ttOXIDIZER) buf << delimiter << "Oxidizer Tank " << i++;
488
489 const string& name = tank->GetName();
490 if (!name.empty()) buf << " (" << name << ")";
491 }
492
493 PropulsionStrings += buf.str();
494
495 return PropulsionStrings;
496}

◆ GetPropulsionTankReport()

string GetPropulsionTankReport ( )

Definition at line 524 of file FGPropulsion.cpp.

525{
526 string out;
527 stringstream outstream;
528 unsigned int i = 0;
529
530 /*const FGMatrix33& mTkI =*/ CalculateTankInertias();
531
532 for (const auto& tank: Tanks) {
533 string tankdesc;
534 const string& tankname = tank->GetName();
535 if (!tankname.empty()) tankdesc = tankname + " (";
536 if (tank->GetType() == FGTank::ttFUEL && tank->GetGrainType() != FGTank::gtUNKNOWN) {
537 tankdesc += "Solid Fuel";
538 } else if (tank->GetType() == FGTank::ttFUEL) {
539 tankdesc += "Fuel";
540 } else if (tank->GetType() == FGTank::ttOXIDIZER) {
541 tankdesc += "Oxidizer";
542 } else {
543 tankdesc += "Unknown tank type";
544 }
545 if (!tankname.empty()) tankdesc += ")";
546 outstream << highint << left << setw(4) << i++ << setw(30) << tankdesc << normint
547 << right << setw(12) << tank->GetContents() << setw(8) << tank->GetXYZ(eX)
548 << setw(8) << tank->GetXYZ(eY) << setw(8) << tank->GetXYZ(eZ)
549 << setw(12) << tank->GetIxx() << setw(12) << tank->GetIyy()
550 << setw(12) << tank->GetIzz() << endl;
551 }
552 return outstream.str();
553}
static char normint[6]
normal intensity text
Definition FGJSBBase.h:154
static char highint[5]
highlights text
Definition FGJSBBase.h:150

◆ GetPropulsionValues()

string GetPropulsionValues ( const std::string &  delimiter) const

Definition at line 500 of file FGPropulsion.cpp.

501{
502 string PropulsionValues;
503 bool firstime = true;
504 stringstream buf;
505
506 for (const auto& engine: Engines) {
507 if (firstime) firstime = false;
508 else PropulsionValues += delimiter;
509
510 PropulsionValues += engine->GetEngineValues(delimiter);
511 }
512 for (const auto& tank: Tanks) {
513 buf << delimiter;
514 buf << tank->GetContents();
515 }
516
517 PropulsionValues += buf.str();
518
519 return PropulsionValues;
520}

◆ GetStarter()

int GetStarter ( void  ) const

Definition at line 636 of file FGPropulsion.cpp.

637{
638 if (ActiveEngine < 0) {
639 bool starter = true;
640
641 for (auto& engine: Engines)
642 starter &= engine->GetStarter();
643
644 return starter ? 1 : 0;
645 } else
646 return Engines[ActiveEngine]->GetStarter() ? 1: 0;
647}

◆ GetSteadyState()

bool GetSteadyState ( void  )

Loops the engines until thrust output steady (used for trimming)

Definition at line 266 of file FGPropulsion.cpp.

267{
268 double currentThrust = 0, lastThrust = -1;
269 int steady_count = 0, j = 0;
270 bool steady = false;
271 bool TrimMode = FDMExec->GetTrimStatus();
272 double TimeStep = FDMExec->GetDeltaT();
273
274 vForces.InitMatrix();
275 vMoments.InitMatrix();
276
277 if (!FGModel::Run(false)) {
278 FDMExec->SetTrimStatus(true);
279 // This is a time marching algorithm so it needs a non-zero time step to
280 // reach a steady state.
281 in.TotalDeltaT = 0.5;
282
283 for (auto& engine: Engines) {
284 steady=false;
285 steady_count=0;
286 j=0;
287 while (!steady && j < 6000) {
288 engine->Calculate();
289 lastThrust = currentThrust;
290 currentThrust = engine->GetThrust();
291 if (fabs(lastThrust-currentThrust) < 0.0001) {
292 steady_count++;
293 if (steady_count > 120) {
294 steady=true;
295 }
296 } else {
297 steady_count=0;
298 }
299 j++;
300 }
301 vForces += engine->GetBodyForces(); // sum body frame forces
302 vMoments += engine->GetMoments(); // sum body frame moments
303 }
304
305 FDMExec->SetTrimStatus(TrimMode);
306 in.TotalDeltaT = TimeStep;
307
308 return false;
309 } else {
310 return true;
311 }
312}
double GetDeltaT(void) const
Returns the simulation delta T.
Definition FGFDMExec.h:552
virtual bool Run(bool Holding)
Runs the model; called by the Executive.
Definition FGModel.cpp:89
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ GetTank()

auto GetTank ( unsigned int  index) const
inline

Retrieves a tank object pointer from the list of tanks.

Parameters
indexthe tank index within the vector container
Returns
the address of the specific tank, or zero if no such tank is available

Definition at line 144 of file FGPropulsion.h.

144 {
145 assert(index < Tanks.size());
146 return Tanks[index];
147 }

◆ GetTanksMoment()

const FGColumnVector3 & GetTanksMoment ( void  )

Definition at line 557 of file FGPropulsion.cpp.

558{
559 vXYZtank_arm.InitMatrix();
560 for (const auto& tank: Tanks)
561 vXYZtank_arm += tank->GetXYZ() * tank->GetContents();
562
563 return vXYZtank_arm;
564}

◆ GetTanksWeight()

double GetTanksWeight ( void  ) const

Definition at line 568 of file FGPropulsion.cpp.

569{
570 double Tw = 0.0;
571
572 for (const auto& tank: Tanks) Tw += tank->GetContents();
573
574 return Tw;
575}

◆ InitModel()

bool InitModel ( void  )
overridevirtual

Reimplemented from FGModel.

Definition at line 96 of file FGPropulsion.cpp.

97{
98 bool result = true;
99
100 if (!FGModel::InitModel()) return false;
101
102 vForces.InitMatrix();
103 vMoments.InitMatrix();
104
105 for (auto& tank: Tanks) tank->ResetToIC();
106 TotalFuelQuantity = 0.0;
107 TotalOxidizerQuantity = 0.0;
108 refuel = dump = false;
109
110 for (auto& engine: Engines) engine->ResetToIC();
111
112 return result;
113}

◆ InitRunning()

void InitRunning ( int  n)

Sets up the engines as running.

Definition at line 316 of file FGPropulsion.cpp.

317{
318 if (n >= 0) { // A specific engine is supposed to be initialized
319
320 if (n >= (int)GetNumEngines() ) {
321 throw(string("Tried to initialize a non-existent engine!"));
322 }
323
324 SetEngineRunning(n);
325
326 } else if (n < 0) { // -1 refers to "All Engines"
327
328 for (unsigned int i=0; i<GetNumEngines(); i++) {
329 SetEngineRunning(i);
330 }
331 }
332
334}
bool GetSteadyState(void)
Loops the engines until thrust output steady (used for trimming)
size_t GetNumEngines(void) const
Retrieves the number of engines defined for the aircraft.
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Load()

bool Load ( Element el)
overridevirtual

Loads the propulsion system (engine[s] and tank[s]).

Characteristics of the propulsion system are read in from the config file.

Parameters
elpointer to an XML element that contains the engine information.
Returns
true if successfully loaded, otherwise false

Reimplemented from FGModel.

Definition at line 349 of file FGPropulsion.cpp.

350{
351 FGModelLoader ModelLoader(this);
352
353 Debug(2);
354 ReadingEngine = false;
355 double FuelDensity = 6.0;
356
357 Name = "Propulsion Model: " + el->GetAttributeValue("name");
358
359 // Perform base class Pre-Load
360 if (!FGModel::Upload(el, true))
361 return false;
362
363 // Process tank definitions first to establish the number of fuel tanks
364
365 Element* tank_element = el->FindElement("tank");
366 unsigned int numTanks = 0;
367
368 while (tank_element) {
369 Tanks.push_back(make_shared<FGTank>(FDMExec, tank_element, numTanks));
370 const auto& tank = Tanks.back();
371 if (tank->GetType() == FGTank::ttFUEL)
372 FuelDensity = tank->GetDensity();
373 else if (tank->GetType() != FGTank::ttOXIDIZER) {
374 cerr << "Unknown tank type specified." << endl;
375 return false;
376 }
377 numTanks++;
378 tank_element = el->FindNextElement("tank");
379 }
380
381 ReadingEngine = true;
382 Element* engine_element = el->FindElement("engine");
383 unsigned int numEngines = 0;
384
385 while (engine_element) {
386 if (!ModelLoader.Open(engine_element)) return false;
387
388 try {
389 // Locate the thruster definition
390 Element* thruster_element = engine_element->FindElement("thruster");
391 if (!thruster_element || !ModelLoader.Open(thruster_element))
392 throw("No thruster definition supplied with engine definition.");
393
394 if (engine_element->FindElement("piston_engine")) {
395 Element *element = engine_element->FindElement("piston_engine");
396 Engines.push_back(make_shared<FGPiston>(FDMExec, element, numEngines, in));
397 } else if (engine_element->FindElement("turbine_engine")) {
398 Element *element = engine_element->FindElement("turbine_engine");
399 Engines.push_back(make_shared<FGTurbine>(FDMExec, element, numEngines, in));
400 } else if (engine_element->FindElement("turboprop_engine")) {
401 Element *element = engine_element->FindElement("turboprop_engine");
402 Engines.push_back(make_shared<FGTurboProp>(FDMExec, element, numEngines, in));
403 } else if (engine_element->FindElement("rocket_engine")) {
404 Element *element = engine_element->FindElement("rocket_engine");
405 Engines.push_back(make_shared<FGRocket>(FDMExec, element, numEngines, in));
406 } else if (engine_element->FindElement("electric_engine")) {
407 Element *element = engine_element->FindElement("electric_engine");
408 Engines.push_back(make_shared<FGElectric>(FDMExec, element, numEngines, in));
409 } else if (engine_element->FindElement("brushless_dc_motor")) {
410 Element *element = engine_element->FindElement("brushless_dc_motor");
411 Engines.push_back(make_shared<FGBrushLessDCMotor>(FDMExec, element, numEngines, in));
412 }
413 else {
414 cerr << engine_element->ReadFrom() << " Unknown engine type" << endl;
415 return false;
416 }
417 } catch (std::string& str) {
418 cerr << endl << fgred << str << reset << endl;
419 return false;
420 }
421
422 numEngines++;
423
424 engine_element = el->FindNextElement("engine");
425 }
426
427 if (numEngines) bind();
428
429 CalculateTankInertias();
430
431 if (el->FindElement("dump-rate"))
432 DumpRate = el->FindElementValueAsNumberConvertTo("dump-rate", "LBS/MIN");
433 if (el->FindElement("refuel-rate"))
434 RefuelRate = el->FindElementValueAsNumberConvertTo("refuel-rate", "LBS/MIN");
435
436 for (auto& engine: Engines)
437 engine->SetFuelDensity(FuelDensity);
438
439 PostLoad(el, FDMExec);
440
441 return true;
442}
static char fgred[6]
red text
Definition FGJSBBase.h:166
static char reset[5]
resets text properties
Definition FGJSBBase.h:156
bool Upload(Element *el, bool preLoad)
Uploads this model in memory.
Definition FGModel.cpp:110
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ Run()

bool Run ( bool  Holding)
overridevirtual

Executes the propulsion model.

The initial plan for the FGPropulsion class calls for Run() to be executed, calculating the power available from the engine. Can pass in a value indicating if the executive is directing the simulation to Hold.

Parameters
Holdingif true, the executive has been directed to hold the sim from advancing time. Some models may ignore this flag, such as the Input model, which may need to be active to listen on a socket for the "Resume" command to be given.
Returns
false if no error

Reimplemented from FGModel.

Definition at line 117 of file FGPropulsion.cpp.

118{
119 if (FGModel::Run(Holding)) return true;
120 if (Holding) return false;
121
122 RunPreFunctions();
123
124 vForces.InitMatrix();
125 vMoments.InitMatrix();
126
127 for (auto& engine: Engines) {
128 engine->Calculate();
129 ConsumeFuel(engine.get());
130 vForces += engine->GetBodyForces(); // sum body frame forces
131 vMoments += engine->GetMoments(); // sum body frame moments
132 }
133
134 TotalFuelQuantity = 0.0;
135 TotalOxidizerQuantity = 0.0;
136 for (auto& tank: Tanks) {
137 tank->Calculate( in.TotalDeltaT, in.TAT_c);
138 switch (tank->GetType()) {
139 case FGTank::ttFUEL:
140 TotalFuelQuantity += tank->GetContents();
141 break;
142 case FGTank::ttOXIDIZER:
143 TotalOxidizerQuantity += tank->GetContents();
144 break;
145 default:
146 break;
147 }
148 }
149
150 if (refuel) DoRefuel( in.TotalDeltaT );
151 if (dump) DumpFuel( in.TotalDeltaT );
152
153 RunPostFunctions();
154
155 return false;
156}
+ Here is the call graph for this function:

◆ SetActiveEngine()

void SetActiveEngine ( int  engine)

Definition at line 721 of file FGPropulsion.cpp.

722{
723 if (engine >= (int)Engines.size() || engine < 0)
724 ActiveEngine = -1;
725 else
726 ActiveEngine = engine;
727}

◆ SetCutoff()

void SetCutoff ( int  setting = 0)

Definition at line 651 of file FGPropulsion.cpp.

652{
653 bool bsetting = setting == 0 ? false : true;
654
655 if (ActiveEngine < 0) {
656 for (auto& engine: Engines) {
657 switch (engine->GetType()) {
658 case FGEngine::etTurbine:
659 static_pointer_cast<FGTurbine>(engine)->SetCutoff(bsetting);
660 break;
661 case FGEngine::etTurboprop:
662 static_pointer_cast<FGTurboProp>(engine)->SetCutoff(bsetting);
663 break;
664 default:
665 break;
666 }
667 }
668 } else {
669 auto engine = Engines[ActiveEngine];
670 switch (engine->GetType()) {
671 case FGEngine::etTurbine:
672 static_pointer_cast<FGTurbine>(engine)->SetCutoff(bsetting);
673 break;
674 case FGEngine::etTurboprop:
675 static_pointer_cast<FGTurboProp>(engine)->SetCutoff(bsetting);
676 break;
677 default:
678 break;
679 }
680 }
681}

◆ SetEngineRunning()

void SetEngineRunning ( int  index)

Definition at line 338 of file FGPropulsion.cpp.

339{
340 in.ThrottleCmd[engineIndex] = in.ThrottlePos[engineIndex] = 1; // Set the throttle command and position
341 in.MixtureCmd[engineIndex] = in.MixturePos[engineIndex] = 1; // Set the mixture command and position
342 FDMExec->GetFCS()->SetMixturePos(engineIndex, 1); // Also set FCS values
343 FDMExec->GetFCS()->SetMixtureCmd(engineIndex, 1);
344 GetEngine(engineIndex)->InitRunning();
345}
std::shared_ptr< FGFCS > GetFCS(void) const
Returns the FGFCS pointer.
auto GetEngine(unsigned int index) const
Retrieves an engine object pointer from the list of engines.

◆ SetFuelFreeze()

void SetFuelFreeze ( bool  f)

Definition at line 791 of file FGPropulsion.cpp.

792{
793 FuelFreeze = f;
794 for (auto& engine: Engines) engine->SetFuelFreeze(f);
795}

◆ SetMagnetos()

void SetMagnetos ( int  setting)

Definition at line 598 of file FGPropulsion.cpp.

599{
600 if (ActiveEngine < 0) {
601 for (auto& engine: Engines) {
602 // ToDo: first need to make sure the engine Type is really appropriate:
603 // do a check to see if it is of type Piston. This should be done for
604 // all of this kind of possibly across-the-board settings.
605 if (engine->GetType() == FGEngine::etPiston)
606 static_pointer_cast<FGPiston>(engine)->SetMagnetos(setting);
607 }
608 } else {
609 auto engine = dynamic_pointer_cast<FGPiston>(Engines[ActiveEngine]);
610 if (engine)
611 engine->SetMagnetos(setting);
612 }
613}

◆ SetStarter()

void SetStarter ( int  setting)

Definition at line 617 of file FGPropulsion.cpp.

618{
619 if (ActiveEngine < 0) {
620 for (auto& engine: Engines) {
621 if (setting == 0)
622 engine->SetStarter(false);
623 else
624 engine->SetStarter(true);
625 }
626 } else {
627 if (setting == 0)
628 Engines[ActiveEngine]->SetStarter(false);
629 else
630 Engines[ActiveEngine]->SetStarter(true);
631 }
632}

◆ Transfer()

double Transfer ( int  source,
int  target,
double  amount 
)

Definition at line 731 of file FGPropulsion.cpp.

732{
733 double shortage, overage;
734
735 if (source == -1) {
736 shortage = 0.0;
737 } else {
738 shortage = Tanks[source]->Drain(amount);
739 }
740 if (target == -1) {
741 overage = 0.0;
742 } else {
743 overage = Tanks[target]->Fill(amount - shortage);
744 }
745 return overage;
746}

Member Data Documentation

◆ in

struct FGEngine::Inputs in

Definition at line 185 of file FGPropulsion.h.


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