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 <vector>
#include <string>

#include "FGJSBBase.h"
#include "input_output/FGPropertyManager.h"
#include "models/FGPropagate.h"
#include "math/FGColumnVector3.h"
#include "models/FGOutput.h"
#include "simgear/misc/sg_path.hxx"

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
DEFINITIONS
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

#define ID_FDMEXEC "$Id: FGFDMExec.h,v 1.106 2017/02/25 14:23:18 bcoconni Exp $"

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
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 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);

  void SetGroundCallback(FGGroundCallback* gc) { FGLocation::SetGroundCallback(gc); }

  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;
  }
  
  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];}
  FGGroundCallback* GetGroundCallback(void) {return FGLocation::GetGroundCallback();}
  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;}

  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;}
  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) {
    sim_time = cur_time;
    GetGroundCallback()->SetTime(sim_time);
    return sim_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) {
    if (!holding && !IntegrationSuspended()) {
      sim_time += dT;
      GetGroundCallback()->SetTime(sim_time);
      Frame++;
    }
    return sim_time;
  }

  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;}

private:
  int Error;
  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;
  int RandomSeed;
  bool Constructing;
  bool modelLoaded;
  bool IsChild;
  std::string modelName;
  SGPath AircraftPath;
  SGPath FullAircraftPath;
  SGPath EnginePath;
  SGPath SystemsPath;
  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;

  // 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;

  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);
  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