FGJSBBase.h

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 Header:       FGJSBBase.h
 Author:       Jon S. Berndt
 Date started: 07/01/01
 
 ------------- Copyright (C) 2001  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
--------------------------------------------------------------------------------
07/01/01  JSB  Created
 
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SENTRY
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
 
#ifndef FGJSBBASE_H
#define FGJSBBASE_H
 
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
INCLUDES
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
 
#include <float.h>
#include <queue>
#include <string>
#include <cmath>
#include <stdexcept>
 
#include "input_output/string_utilities.h"
 
#ifndef M_PI
#  define M_PI 3.14159265358979323846
#endif
 
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
FORWARD DECLARATIONS
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
 
namespace JSBSim {
 
class BaseException : public std::runtime_error {
  public:
    BaseException(const std::string& msg) : std::runtime_error(msg) {}
};
 
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
CLASS DOCUMENTATION
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
 
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
CLASS DECLARATION
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
 
class FGJSBBase {
public:
  FGJSBBase() {};
 
  virtual ~FGJSBBase() {};
 
  struct Message {
    unsigned int fdmId;
    unsigned int messageId;
    std::string text;
    std::string subsystem;
    enum mType {eText, eInteger, eDouble, eBool} type;
    bool bVal;
    int  iVal;
    double dVal;
  };
 
  class Filter {
    double prev_in;
    double prev_out;
    double ca;
    double cb;
  public:
    Filter(void) {}
    Filter(double coeff, double dt) {
      prev_in = prev_out = 0.0;
      double denom = 2.0 + coeff*dt;
      ca = coeff*dt/denom;
      cb = (2.0 - coeff*dt)/denom;
    }
    double execute(double in) {
      double out = (in + prev_in)*ca + prev_out*cb;
      prev_in = in;
      prev_out = out;
      return out;
    }
  };
 
 
  static char highint[5];
  static char halfint[5];
  static char normint[6];
  static char reset[5];
  static char underon[5];
  static char underoff[6];
  static char fgblue[6];
  static char fgcyan[6];
  static char fgred[6];
  static char fggreen[6];
  static char fgdef[6];
 
 
 
  void PutMessage(const Message& msg);
  void PutMessage(const std::string& text);
  void PutMessage(const std::string& text, bool bVal);
  void PutMessage(const std::string& text, int iVal);
  void PutMessage(const std::string& text, double dVal);
  int SomeMessages(void) const { return !Messages.empty(); }
  void ProcessMessage(void);
  Message* ProcessNextMessage(void);
 
  static const std::string& GetVersion(void) {return JSBSim_version;}
 
  void disableHighLighting(void);
 
  static short debug_lvl;
 
  static constexpr double KelvinToFahrenheit (double kelvin) {
    return 1.8*kelvin - 459.4;
  }
 
  static constexpr double CelsiusToRankine (double celsius) {
    return celsius * 1.8 + 491.67;
  }
 
  static constexpr double RankineToCelsius (double rankine) {
    return (rankine - 491.67)/1.8;
  }
 
  static constexpr double KelvinToRankine (double kelvin) {
    return kelvin * 1.8;
  }
 
  static constexpr double RankineToKelvin (double rankine) {
    return rankine/1.8;
  }
 
  static constexpr double FahrenheitToCelsius (double fahrenheit) {
    return (fahrenheit - 32.0)/1.8;
  }
 
  static constexpr double CelsiusToFahrenheit (double celsius) {
    return celsius * 1.8 + 32.0;
  }
 
  static constexpr double CelsiusToKelvin (double celsius) {
    return celsius + 273.15;
  }
 
  static constexpr double KelvinToCelsius (double kelvin) {
    return kelvin - 273.15;
  }
 
  static constexpr double FeetToMeters (double measure) {
    return measure*0.3048;
  }
 
  static double PitotTotalPressure(double mach, double p);
 
  static double MachFromImpactPressure(double qc, double p);
 
  static double VcalibratedFromMach(double mach, double p);
 
  static double MachFromVcalibrated(double vcas, double p);
 
  static bool EqualToRoundoff(double a, double b) {
    double eps = 2.0*DBL_EPSILON;
    return std::fabs(a - b) <= eps * std::max<double>(std::fabs(a), std::fabs(b));
  }
 
  static bool EqualToRoundoff(float a, float b) {
    float eps = 2.0*FLT_EPSILON;
    return std::fabs(a - b) <= eps * std::max<double>(std::fabs(a), std::fabs(b));
  }
 
  static bool EqualToRoundoff(float a, double b) {
    return EqualToRoundoff(a, (float)b);
  }
 
  static bool EqualToRoundoff(double a, float b) {
    return EqualToRoundoff((float)a, b);
  }
 
  static constexpr double Constrain(double min, double value, double max) {
    return value<min?(min):(value>max?(max):(value));
  }
 
  static constexpr double sign(double num) {return num>=0.0?1.0:-1.0;}
 
  static double GaussianRandomNumber(void);
 
protected:
  static Message localMsg;
 
  static std::queue <Message> Messages;
 
  static unsigned int messageId;
 
  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 ktstofps = 1.68781;
  static constexpr double fpstokts = 1.0 / ktstofps;
  static constexpr double inchtoft = 1.0/12.0;
  static constexpr double fttom = 0.3048;
  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;
  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;
  static const std::string JSBSim_version;
 
  static std::string CreateIndexedPropertyName(const std::string& Property, int index);
 
  static int gaussian_random_number_phase;
 
public:
enum {eL     = 1, eM,     eN    };
enum {eP     = 1, eQ,     eR    };
enum {eU     = 1, eV,     eW    };
enum {eX     = 1, eY,     eZ    };
enum {ePhi   = 1, eTht,   ePsi  };
enum {eDrag  = 1, eSide,  eLift };
enum {eRoll  = 1, ePitch, eYaw  };
enum {eNorth = 1, eEast,  eDown };
enum {eLat = 1, eLong, eRad     };
enum {inNone = 0, inDegrees, inRadians, inMeters, inFeet };
 
};
 
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#endif