FGFDMExec.h

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 Header:       FGFDMExec.h
 Author:       Jon Berndt
 Date started: 11/17/98
 file The header file for the JSBSim executive.
 
 ------------- Copyright (C) 1999  Jon S. Berndt (jon@jsbsim.org) -------------
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU Lesser General Public License as published by the Free
 Software Foundation; either version 2 of the License, or (at your option) any
 later version.
 
 This program is distributed in the hope that it will be useful, but WITHOUT
 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
 details.
 
 You should have received a copy of the GNU Lesser General Public License along
 with this program; if not, write to the Free Software Foundation, Inc., 59
 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
 Further information about the GNU Lesser General Public License can also be
 found on the world wide web at http://www.gnu.org.
 
HISTORY
--------------------------------------------------------------------------------
11/17/98   JSB   Created
7/31/99     TP   Added RunIC function that runs the sim so that every frame
                 begins with the IC values from the given FGInitialCondition
                 object and dt=0.
 
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SENTRY
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
 
#ifndef FGFDMEXEC_HEADER_H
#define FGFDMEXEC_HEADER_H
 
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
INCLUDES
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
 
#include <memory>
#include <random>
 
#include "models/FGPropagate.h"
#include "models/FGOutput.h"
#include "math/FGTemplateFunc.h"
 
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
FORWARD DECLARATIONS
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
 
namespace JSBSim {
 
class FGScript;
class FGTrim;
class FGAerodynamics;
class FGAircraft;
class FGAtmosphere;
class FGAccelerations;
class FGWinds;
class FGAuxiliary;
class FGBuoyantForces;
class FGExternalReactions;
class FGGroundReactions;
class FGFCS;
class FGInertial;
class FGInput;
class FGPropulsion;
class FGMassBalance;
class FGTrim;
 
class TrimFailureException : public BaseException {
  public:
    TrimFailureException(const std::string& msg) : BaseException(msg) {}
};
 
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
CLASS DOCUMENTATION
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
 
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
CLASS DECLARATION
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
 
class FGFDMExec : public FGJSBBase
{
  struct childData {
    FGFDMExec* exec;
    std::string info;
    FGColumnVector3 Loc;
    FGColumnVector3 Orient;
    bool mated;
    bool internal;
 
    childData(void) {
      info = "";
      Loc = FGColumnVector3(0,0,0);
      Orient = FGColumnVector3(0,0,0);
      mated = true;
      internal = false;
    }
 
    void Run(void) {exec->Run();}
    void AssignState(FGPropagate* source_prop) {
      exec->GetPropagate()->SetVState(source_prop->GetVState());
    }
 
    ~childData(void) {
      delete exec;
    }
  };
 
public:
 
  FGFDMExec(FGPropertyManager* root = 0, unsigned int* fdmctr = 0);
 
  ~FGFDMExec();
 
  // This list of enums is very important! The order in which models are listed
  // here determines the order of execution of the models.
  //
  // There are some conditions that need to be met :
  // 1. FCS can request mass geometry changes via the inertia/pointmass-*
  //    properties so it must be executed before MassBalance
  // 2. MassBalance must be executed before Propulsion, Aerodynamics,
  //    GroundReactions, ExternalReactions and BuoyantForces to ensure that
  //    their moments are computed with the updated CG position.
  enum eModels { ePropagate=0,
                 eInput,
                 eInertial,
                 eAtmosphere,
                 eWinds,
                 eSystems,
                 eMassBalance,
                 eAuxiliary,
                 ePropulsion,
                 eAerodynamics,
                 eGroundReactions,
                 eExternalReactions,
                 eBuoyantForces,
                 eAircraft,
                 eAccelerations,
                 eOutput,
                 eNumStandardModels };
 
  void Unbind(void) {instance->Unbind();}
 
  bool Run(void);
 
  bool RunIC(void);
 
  bool LoadModel(const SGPath& AircraftPath, const SGPath& EnginePath,
                 const SGPath& SystemsPath, const std::string& model,
                 bool addModelToPath = true);
 
  bool LoadModel(const std::string& model, bool addModelToPath = true);
 
  bool LoadScript(const SGPath& Script, double deltaT=0.0,
                  const SGPath& initfile=SGPath());
 
  bool SetEnginePath(const SGPath& path) {
    EnginePath = GetFullPath(path);
    return true;
  }
 
  bool SetAircraftPath(const SGPath& path) {
    AircraftPath = GetFullPath(path);
    return true;
  }
 
  bool SetSystemsPath(const SGPath& path) {
    SystemsPath = GetFullPath(path);
    return true;
  }
 
  bool SetOutputPath(const SGPath& path) {
    OutputPath = GetFullPath(path);
    return true;
  }
 
  FGAtmosphere* GetAtmosphere(void)    {return (FGAtmosphere*)Models[eAtmosphere];}
  FGAccelerations* GetAccelerations(void)    {return (FGAccelerations*)Models[eAccelerations];}
  FGWinds* GetWinds(void)    {return (FGWinds*)Models[eWinds];}
  FGFCS* GetFCS(void)                  {return (FGFCS*)Models[eSystems];}
  FGPropulsion* GetPropulsion(void)    {return (FGPropulsion*)Models[ePropulsion];}
  FGMassBalance* GetMassBalance(void)  {return (FGMassBalance*)Models[eMassBalance];}
  FGAerodynamics* GetAerodynamics(void){return (FGAerodynamics*)Models[eAerodynamics];}
  FGInertial* GetInertial(void)        {return (FGInertial*)Models[eInertial];}
  FGGroundReactions* GetGroundReactions(void) {return (FGGroundReactions*)Models[eGroundReactions];}
  FGExternalReactions* GetExternalReactions(void) {return (FGExternalReactions*)Models[eExternalReactions];}
  FGBuoyantForces* GetBuoyantForces(void) {return (FGBuoyantForces*)Models[eBuoyantForces];}
  FGAircraft* GetAircraft(void)        {return (FGAircraft*)Models[eAircraft];}
  FGPropagate* GetPropagate(void)      {return (FGPropagate*)Models[ePropagate];}
  FGAuxiliary* GetAuxiliary(void)      {return (FGAuxiliary*)Models[eAuxiliary];}
  FGInput* GetInput(void)              {return (FGInput*)Models[eInput];}
  FGOutput* GetOutput(void)            {return (FGOutput*)Models[eOutput];}
  FGScript* GetScript(void) {return Script;}
  FGInitialCondition* GetIC(void)      {return IC;}
  FGTrim* GetTrim(void);
 
  const SGPath& GetEnginePath(void) { return EnginePath; }
  const SGPath& GetAircraftPath(void) { return AircraftPath; }
  const SGPath& GetSystemsPath(void) { return SystemsPath; }
  const SGPath& GetFullAircraftPath(void) { return FullAircraftPath; }
  const SGPath& GetOutputPath(void) { return OutputPath; }
 
  inline double GetPropertyValue(const std::string& property)
  { return instance->GetNode()->GetDouble(property); }
 
  inline void SetPropertyValue(const std::string& property, double value) {
    instance->GetNode()->SetDouble(property, value);
  }
 
  const std::string& GetModelName(void) const { return modelName; }
 
  FGPropertyManager* GetPropertyManager(void);
  std::vector <std::string> EnumerateFDMs(void);
  int GetFDMCount(void) const {return (int)ChildFDMList.size();}
  childData* GetChildFDM(int i) const {return ChildFDMList[i];}
  void SetChild(bool ch) {IsChild = ch;}
 
  bool SetOutputDirectives(const SGPath& fname)
  { return Output->SetDirectivesFile(GetFullPath(fname)); }
 
  void ForceOutput(int idx=0) { Output->ForceOutput(idx); }
 
  void SetLoggingRate(double rate) { Output->SetRateHz(rate); }
 
  bool SetOutputFileName(const int n, const std::string& fname) { return Output->SetOutputName(n, fname); }
 
  std::string GetOutputFileName(int n) const { return Output->GetOutputName(n); }
 
  void DoTrim(int mode);
 
  void DisableOutput(void) { Output->Disable(); }
  void EnableOutput(void) { Output->Enable(); }
  void Hold(void) {holding = true;}
  void EnableIncrementThenHold(int Timesteps) {TimeStepsUntilHold = Timesteps; IncrementThenHolding = true;}
  void CheckIncrementalHold(void);
  void Resume(void) {holding = false;}
  bool Holding(void) {return holding;}
  static const int START_NEW_OUTPUT    = 0x1;
  static const int DONT_EXECUTE_RUN_IC = 0x2;
  void ResetToInitialConditions(int mode);
  void SetDebugLevel(int level) {debug_lvl = level;}
 
  struct PropertyCatalogStructure {
    std::string base_string;
    FGPropertyNode_ptr node;
  };
 
  void BuildPropertyCatalog(struct PropertyCatalogStructure* pcs);
 
  std::string QueryPropertyCatalog(const std::string& check);
 
  // Print the contents of the property catalog for the loaded aircraft.
  void PrintPropertyCatalog(void);
 
  // Print the simulation configuration
  void PrintSimulationConfiguration(void) const;
 
  std::vector<std::string>& GetPropertyCatalog(void) {return PropertyCatalog;}
 
  void SetTrimStatus(bool status){ trim_status = status; }
  bool GetTrimStatus(void) const { return trim_status; }
  void SetTrimMode(int mode){ ta_mode = mode; }
  int GetTrimMode(void) const { return ta_mode; }
 
  std::string GetPropulsionTankReport();
 
  double GetSimTime(void) const { return sim_time; }
 
  double GetDeltaT(void) const {return dT;}
 
  void SuspendIntegration(void) {saved_dT = dT; dT = 0.0;}
 
  void ResumeIntegration(void)  {dT = saved_dT;}
 
  bool IntegrationSuspended(void) const {return dT == 0.0;}
 
  double Setsim_time(double cur_time);
 
  void Setdt(double delta_t) { dT = delta_t; }
 
  void SetRootDir(const SGPath& rootDir) {RootDir = rootDir;}
 
  const SGPath& GetRootDir(void) const {return RootDir;}
 
  double IncrTime(void);
 
  unsigned int GetFrame(void) const {return Frame;}
 
  int GetDebugLevel(void) const {return debug_lvl;};
 
  void Initialize(FGInitialCondition *FGIC);
 
  void SetHoldDown(bool hd);
 
  bool GetHoldDown(void) const {return HoldDown;}
 
  FGTemplateFunc* GetTemplateFunc(const std::string& name) {
    return TemplateFunctions.count(name) ? TemplateFunctions[name] : nullptr;
  }
 
  void AddTemplateFunc(const std::string& name, Element* el) {
    TemplateFunctions[name] = new FGTemplateFunc(this, el);
  }
 
  const std::shared_ptr<std::default_random_engine>& GetRandomEngine(void) const
  { return RandomEngine; }
 
private:
  unsigned int Frame;
  unsigned int IdFDM;
  int disperse;
  unsigned short Terminate;
  double dT;
  double saved_dT;
  double sim_time;
  bool holding;
  bool IncrementThenHolding;
  int TimeStepsUntilHold;
  bool Constructing;
  bool modelLoaded;
  bool IsChild;
  std::string modelName;
  SGPath AircraftPath;
  SGPath FullAircraftPath;
  SGPath EnginePath;
  SGPath SystemsPath;
  SGPath OutputPath;
  std::string CFGVersion;
  std::string Release;
  SGPath RootDir;
 
  // Standard Model pointers - shortcuts for internal executive use only.
  FGPropagate* Propagate;
  FGInertial* Inertial;
  FGAtmosphere* Atmosphere;
  FGWinds* Winds;
  FGAuxiliary* Auxiliary;
  FGFCS* FCS;
  FGPropulsion* Propulsion;
  FGAerodynamics* Aerodynamics;
  FGGroundReactions* GroundReactions;
  FGExternalReactions* ExternalReactions;
  FGBuoyantForces* BuoyantForces;
  FGMassBalance* MassBalance;
  FGAircraft* Aircraft;
  FGAccelerations* Accelerations;
  FGOutput* Output;
 
  bool trim_status;
  int ta_mode;
  unsigned int ResetMode;
  int trim_completed;
 
  FGScript*           Script;
  FGInitialCondition* IC;
  FGTrim*             Trim;
 
  FGPropertyManager* Root;
  bool StandAlone;
  FGPropertyManager* instance;
 
  bool HoldDown;
 
  int RandomSeed;
  std::shared_ptr<std::default_random_engine> RandomEngine;
 
  // The FDM counter is used to give each child FDM an unique ID. The root FDM
  // has the ID 0
  unsigned int*      FDMctr;
 
  std::vector <std::string> PropertyCatalog;
  std::vector <childData*> ChildFDMList;
  std::vector <FGModel*> Models;
  std::map<std::string, FGTemplateFunc_ptr> TemplateFunctions;
 
  bool ReadFileHeader(Element*);
  bool ReadChild(Element*);
  bool ReadPrologue(Element*);
  void SRand(int sr);
  int  SRand(void) const {return RandomSeed;}
  void LoadInputs(unsigned int idx);
  void LoadPlanetConstants(void);
  void LoadModelConstants(void);
  bool Allocate(void);
  bool DeAllocate(void);
  void InitializeModels(void);
  int GetDisperse(void) const {return disperse;}
  SGPath GetFullPath(const SGPath& name) {
    if (name.isRelative())
      return RootDir/name.utf8Str();
    else
      return name;
  }
 
  void Debug(int from);
};
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#endif