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 "models/FGPropagate.h"
#include "models/FGOutput.h"
#include "models/FGInput.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 FGPropulsion;
class FGMassBalance;
class FGLogger;
 
class TrimFailureException : public BaseException {
  public:
    TrimFailureException(const std::string& msg) : BaseException(msg) {}
};
 
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
CLASS DOCUMENTATION
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
 
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
CLASS DECLARATION
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
 
class JSBSIM_API FGFDMExec : public FGJSBBase
{
  struct childData {
    std::unique_ptr<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());
    }
  };
 
public:
 
  FGFDMExec(FGPropertyManager* root = nullptr, std::shared_ptr<unsigned int> fdmctr = nullptr);
 
  ~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 LoadPlanet(const SGPath& PlanetPath, bool useAircraftPath = true);
 
  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;
  }
 
  std::shared_ptr<FGAtmosphere>        GetAtmosphere(void) const;
  std::shared_ptr<FGAccelerations>     GetAccelerations(void) const;
  std::shared_ptr<FGWinds>             GetWinds(void) const;
  std::shared_ptr<FGFCS>               GetFCS(void) const;
  std::shared_ptr<FGPropulsion>        GetPropulsion(void) const;
  std::shared_ptr<FGMassBalance>       GetMassBalance(void) const;
  std::shared_ptr<FGAerodynamics>      GetAerodynamics(void) const;
  std::shared_ptr<FGInertial>          GetInertial(void) const;
  std::shared_ptr<FGGroundReactions>   GetGroundReactions(void) const;
  std::shared_ptr<FGExternalReactions> GetExternalReactions(void) const;
  std::shared_ptr<FGBuoyantForces>     GetBuoyantForces(void) const;
  std::shared_ptr<FGAircraft>          GetAircraft(void) const;
  std::shared_ptr<FGPropagate>         GetPropagate(void) const;
  std::shared_ptr<FGAuxiliary>         GetAuxiliary(void) const;
  std::shared_ptr<FGInput>             GetInput(void) const;
  std::shared_ptr<FGOutput>            GetOutput(void) const;
  std::shared_ptr<FGScript>            GetScript(void) const {return Script;}
  std::shared_ptr<FGInitialCondition>  GetIC(void) const {return IC;}
  std::shared_ptr<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; }
 
  double GetPropertyValue(const std::string& property)
  { return instance->GetNode()->getDoubleValue(property.c_str()); }
 
  void SetPropertyValue(const std::string& property, double value)
  { instance->GetNode()->setDoubleValue(property.c_str(), value); }
 
  const std::string& GetModelName(void) const { return modelName; }
 
  std::shared_ptr<FGPropertyManager> GetPropertyManager(void) const { return instance; }
  std::vector <std::string> EnumerateFDMs(void);
  size_t GetFDMCount(void) const {return ChildFDMList.size();}
  auto 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 DoLinearization(int);
 
  void DisableOutput(void) { Output->Disable(); }
  void EnableOutput(void) { Output->Enable(); }
  void DisableInput(void) { Input->Disable(); }
  void EnableInput(void) { Input->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;
    SGPropertyNode_ptr node;
  };
 
  void BuildPropertyCatalog(struct PropertyCatalogStructure* pcs);
 
  std::string QueryPropertyCatalog(const std::string& check, const std::string& end_of_line="\n");
 
  // 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() const;
 
  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(const FGInitialCondition* FGIC);
 
  void SetHoldDown(bool hd);
 
  bool GetHoldDown(void) const {return HoldDown;}
 
  FGTemplateFunc_ptr GetTemplateFunc(const std::string& name) {
    return TemplateFunctions.count(name) ? TemplateFunctions[name] : nullptr;
  }
 
  void AddTemplateFunc(const std::string& name, Element* el) {
    TemplateFunctions[name] = std::make_shared<FGTemplateFunc>(this, el);
  }
 
  auto GetRandomGenerator(void) const { return RandomGenerator; }
 
  int  SRand(void) const { return RandomSeed; }
 
private:
  unsigned int Frame;
  unsigned int IdFDM;
  int disperse;
  bool 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.
  // DO NOT TRY TO DELETE THEM !!!
  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;
  FGInput* Input;
 
  bool trim_status;
  int ta_mode;
  int trim_completed;
 
  std::shared_ptr<FGInitialCondition> IC;
  std::shared_ptr<FGScript>           Script;
  std::shared_ptr<FGTrim>             Trim;
 
  SGPropertyNode_ptr Root;
  std::shared_ptr<FGPropertyManager> instance;
 
  bool HoldDown;
 
  unsigned int RandomSeed;
  std::shared_ptr<RandomNumberGenerator> RandomGenerator;
 
  // The FDM counter is used to give each child FDM an unique ID. The root FDM
  // has the ID 0
  std::shared_ptr<unsigned int> FDMctr;
 
  std::vector <std::string> PropertyCatalog;
  std::vector <std::shared_ptr<childData>> ChildFDMList;
  std::vector <std::shared_ptr<FGModel>> Models;
  std::map<std::string, FGTemplateFunc_ptr> TemplateFunctions;
 
  bool ReadFileHeader(Element*);
  bool ReadChild(Element*);
  bool ReadPrologue(Element*);
  void SRand(int sr);
  void LoadInputs(unsigned int idx);
  void LoadPlanetConstants(void);
  bool LoadPlanet(Element* el);
  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