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 "initialization/FGTrim.h"
#include "FGJSBBase.h"
#include "input_output/FGPropertyManager.h"
#include "input_output/FGXMLFileRead.h"
#include "models/FGPropagate.h"
#include "math/FGColumnVector3.h"
#include "models/FGOutput.h"

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

#define ID_FDMEXEC "$Id: FGFDMExec.h,v 1.82 2013/01/26 17:06:49 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 DOCUMENTATION
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
CLASS DECLARATION
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/

class FGFDMExec : public FGJSBBase, public FGXMLFileRead
{
  struct childData {
    FGFDMExec* exec;
    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.
  enum eModels { ePropagate=0,
                 eInput,
                 eInertial,
                 eAtmosphere,
                 eWinds,
                 eAuxiliary,
                 eSystems,
                 ePropulsion,
                 eAerodynamics,
                 eGroundReactions,
                 eExternalReactions,
                 eBuoyantForces,
                 eMassBalance,
                 eAircraft,
                 eAccelerations,
                 eOutput,
                 eNumStandardModels };

  void Unbind(void) {instance->Unbind();}

  void Schedule(FGModel* model, int rate=1);

  bool Run(void);

  bool RunIC(void);

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

  bool LoadModel(const string& AircraftPath, const string& EnginePath, const string& SystemsPath,
                 const string& model, bool addModelToPath = true);

  bool LoadModel(const string& model, bool addModelToPath = true);

  bool LoadScript(const string& Script, double deltaT=0.0, const string initfile="");

  bool SetEnginePath(const string& path)   { EnginePath = RootDir + path; return true; }

  bool SetAircraftPath(const string& path) { AircraftPath = RootDir + path; return true; }
  
  bool SetSystemsPath(const string& path)   { SystemsPath = RootDir + 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];}
  FGGroundCallback* GetGroundCallback(void) {return FGLocation::GetGroundCallback();}
  FGScript* GetScript(void) {return Script;}
  FGInitialCondition* GetIC(void)      {return IC;}
  FGTrim* GetTrim(void);

  const string& GetEnginePath(void)    {return EnginePath;}
  const string& GetAircraftPath(void)  {return AircraftPath;}
  const string& GetSystemsPath(void)   {return SystemsPath;}
  const string& GetFullAircraftPath(void) {return FullAircraftPath;}

  inline double GetPropertyValue(const string& property)
  { return instance->GetNode()->GetDouble(property); }

  inline void SetPropertyValue(const string& property, double value) {
    instance->GetNode()->SetDouble(property, value);
  }

  const string& GetModelName(void) const { return modelName; }
/*
  double GetSimTime(void);

  double GetDeltaT(void);
*/  
  FGPropertyManager* GetPropertyManager(void);
  vector <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 string& fname)
  {return Output->SetDirectivesFile(RootDir + fname);}

  void ForceOutput(int idx=0) { Output->ForceOutput(idx); }

  void SetLoggingRate(double rate) { Output->SetRate(rate); }

  bool SetOutputFileName(const string& fname) { return Output->SetOutputName(0, fname); }

  string GetOutputFileName(void) const { return Output->GetOutputName(0); }

  void DoTrim(int mode);
  void DoSimplexTrim(int mode);

  void DoLinearization(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(void);
  void SetDebugLevel(int level) {debug_lvl = level;}

  struct PropertyCatalogStructure {
    string base_string;
    FGPropertyNode_ptr node;
  };

  void BuildPropertyCatalog(struct PropertyCatalogStructure* pcs);

  string QueryPropertyCatalog(const string& check);

  // Print the contents of the property catalog for the loaded aircraft.
  void PrintPropertyCatalog(void);

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

  string GetPropulsionTankReport();

  double GetSimTime(void) const { return sim_time; }

  double GetDeltaT(void) const {return dT;}

  void SuspendIntegration(void) {
    if (dT != 0.0) { // check if already suspended
      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;
    return sim_time;
  }

  void Setdt(double delta_t) { dT = delta_t; }

  void SetRootDir(const string& rootDir) {RootDir = rootDir;}

  const string& GetRootDir(void) const {return RootDir;}

  double IncrTime(void) {
    if (!holding) sim_time += dT;
    Frame++;
    return sim_time;
  }

  int GetDebugLevel(void) const {return debug_lvl;};

  void Initialize(FGInitialCondition *FGIC);

private:
  int Error;
  unsigned int Frame;
  unsigned int IdFDM;
  unsigned short Terminate;
  double dT;
  double saved_dT;
  double sim_time;
  bool holding;
  bool IncrementThenHolding;
  int TimeStepsUntilHold;
  bool Constructing;
  bool modelLoaded;
  bool IsChild;
  string modelName;
  string AircraftPath;
  string FullAircraftPath;
  string EnginePath;
  string SystemsPath;
  string CFGVersion;
  string Release;
  string 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;

  FGScript*           Script;
  FGInitialCondition* IC;
  FGTrim*             Trim;

  FGPropertyManager* Root;
  bool StandAlone;
  FGPropertyManager* instance;
  
  // The FDM counter is used to give each child FDM an unique ID. The root FDM has the ID 0
  unsigned int*      FDMctr;

  vector <string> PropertyCatalog;
  vector <childData*> ChildFDMList;
  vector <FGModel*> Models;

  bool ReadFileHeader(Element*);
  bool ReadChild(Element*);
  bool ReadPrologue(Element*);
  void ResetToInitialConditions(int mode);
  void SRand(int sr);
  void LoadInputs(unsigned int idx);
  void LoadPlanetConstants(void);
  void LoadModelConstants(void);
  bool Allocate(void);
  bool DeAllocate(void);

  void Debug(int from);
};
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#endif