BrawlerUtil.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI//REL TO USA ONLY
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2003-2015 The Boeing Company. All rights reserved.
//
// The use, dissemination or disclosure of data in this file is subject to
// limitation or restriction. See accompanying README and LICENSE for details.
// ****************************************************************************
 
#ifndef BRAWLERUTIL_HPP
#define BRAWLERUTIL_HPP
 
#include "UtEntity.hpp"
class UtInput;
#include "brawler_export.h"
 
#include "UtFortMat3.hpp"
#include "UtMatrix.hpp"
#include "UtVec3.hpp"

namespace BRAWLER
{
// BRAWLER Constants
double const grav           = 32.17405;
double const pi             = 3.141592654;
double const rad            = pi / 180.0;
double const hafpi          = 1.570796327; // pi/2.0;
double const twopi          = 6.283185308; // pi*2.0;
double const root2          = 1.414213562;
double const ftnmi          = 0.000164578834;
double const eps            = 1.e-35;
double const re             = 20890377.0;
double const xlarge         = 1.e38;
double const degrees2meters = 111194.92664456; // 111194.92664455873734580833886041
double const degrees2feet   = 364812.76313;    // 364812.76313253408783362183046679
double const cFtSec2PerG    = 32.1740;         // TODO - use "grav" instead?

// BRAWLER enumerations  /// ////////////////////////////////////////////
enum WeaponType
{
   nowepn = 0, // none
   kndsrm = 1, // short range missile
   kndmrm = 2, // medium range missile
   kndlrm = 3, // long range missile
   kndmis = 3, // missile
   kndgun = 4, // guns
   knddew = 5, // directed energy weapon
   kndwpn = 5  // weapon
};
enum ManeuverValueComponentType // used by TunnelVisionMultiplier() to replace "tnl_mult", copied from valhst.fi
{
   i_voffef  = 1,  // offensive
   i_vlospd  = 2,  // low speed recovery
   i_vform   = 3,  // station keeping (formation)
   i_compr   = 4,  // route-point
   i_valdfx  = 5,  // defensive
   i_gaval   = 6,  // ground avoidance
   i_vvec    = 7,  // vector following
   i_villum  = 8,  // illumination (missile guiding)
   i_vmusup  = 9,  // mutual support
   i_valevd  = 10, // missile evasion
   i_vmaim   = 11, // missile aiming
   i_vdisng  = 12, // disengage
   i_sepval  = 13, // separation
   i_vescrt  = 14, // escort bomber
   i_vsamz   = 15, // SAM avoidance
   i_vavbdd  = 16, // bad aspect avoidance
   i_hddval  = 17, // hard-deck
   i_terrval = 18, // terrain
   i_vdew    = 19, // directed energy weapon
   i_vtpt    = 20  // third part targeting
};
enum MissileModeState
{
   NOTASK     = 0, 
   INTERCEPT  = 1, 
   AIMFIRE    = 2, 
   ILLUMINATE = 3  
};
enum WeaponSeekerType
{
   mxskr  = 4,
   irskr  = 1,
   saskr  = 2,
   acskr  = 3,
   armskr = 4
};
enum InherentBiasFaultTypes
{
   i_ovroff = 1, // OVERLY OFFENSIVE
   i_nmusup = 2, // ATTENTION TO MUTUAL SUPPORT
   i_nospd  = 3  // ATTENTION TO AIRSPEED MAINTENANCE
};
enum JobType
{
   FLIGHT_LEAD  = 1,
   ELEMENT_LEAD = 2,
   WINGMAN      = 3
};
enum MissionType
{
   ROUTE  = 1,
   ESCORT = 2,
   CAP    = 3
};

// BRAWLER utility functions ////////////////////////////////////////////

BRAWLER_EXPORT double amin1(const double a, const double b);
BRAWLER_EXPORT double amax1(const double a, const double b);
BRAWLER_EXPORT double amax1(const double a, const double b, const double c);

int    sign(const int a, const int b);
double sign(const double a, const double b);

bool btest(const int var, const int pos);
bool lbit(const int word, const int n);

double arccos(const double a);
double arcsin(const double a);

double avnorm(const UtVec3d& x);
 
/*not needed yet*/
// lmatch(a,b,c) (std::find(std::begin(a), std::end(a), c) != std::end(a))
// iand(a,b) (a&b)

double border(const double z, const double z0);

double cauchy(const double z, const double z0);

double reward(const double z, const double z0);

double dist(const UtVec3d& a, const UtVec3d& b);

double energy(const UtVec3d& pos, const UtVec3d& vel);

double egy(double z, double s);

UtFortMat3d makecs(const UtVec3d& xVec, const UtVec3d& zVec);

UtFortMat3d makcsi(const UtVec3d& xVec, const UtVec3d& zVec);

UtFortMat3d makex(const UtVec3d& cxin);

UtFortMat3d makeh(const UtVec3d& cxin);
// makecs_inner(const UtVec3d& bx, const UtVec3d& by);
 
double headeg(UtVec3d v);

BRAWLER_EXPORT double ramp(const double xlo, const double xval, const double xhi);

void vsplit(const UtVec3d& v, const UtVec3d& x, UtVec3d& vl, UtVec3d& vt);

double xlimit(const double xreq, const double xmax, const double xmin);
 
 
UtFortMat3d bodyax(const UtFortMat3d& rwe, // returns rbe,  leave in util???
                   double             alpha);
 
UtFortMat3d NEDToECSRotation(UtEntity& ref);
 
UtFortMat3d mrotx(UtFortMat3d a, double chi);
double AtmosphereDensityRatio(double altitude);
double SpeedOfSound(double altitude);

double LOSangleSigma(const UtFortMat3d& M, const UtMatrixd& R6, double R);

BRAWLER_EXPORT void nabort(const std::string& str);

BRAWLER_EXPORT double param1(int i, double xx, double* aray);

BRAWLER_EXPORT double tbl1(double x, double* z, double* xval, int nxval);

double tbl1b(double x, double* z, int nx, double xmin, double xmax); // TODO

BRAWLER_EXPORT double tbl2(double x, double y, double* z, double* xval, int nxval, double* yval, int nyval);

double tbl2e(double x, double y, double* z, double* xval, int nxval, double* yval, int nyval);

BRAWLER_EXPORT void invtb2(double* tbl, double z, int nr, int ir, double pr, bool revdir, int nc, int& ic, double& pc);

BRAWLER_EXPORT void srch(double* x, int nx, double xint, int& ilow, double& p);

bool maxcnt(int& count, bool zprnt, int mcount, const std::string& subnam);
 
double dsxdot(double xdes, double x, double xdot, double xdotmx, double tau);
 
UtVec3d vorth(const UtVec3d& a, const UtVec3d& b);
 
UtVec3d rotz(double phi, const UtVec3d& vin);
 
// replicates aimpt()
BRAWLER_EXPORT bool AimPoint(const UtVec3d& xa, double sa, const UtVec3d& xt, const UtVec3d& vt, double st, UtVec3d& aimp);
 
 
BRAWLER_EXPORT void intcpt(const UtVec3d& xa,
                           double         sa,
                           const UtVec3d& xt,
                           const UtVec3d& vt,
                           double         closmn,
                           double         angint,
                           double         hdes,
                           UtVec3d&       desdir,
                           double&        sdes);
 
void intcpt_inner(const UtVec3d& x_atkr,
                  double         sa,
                  const UtVec3d& x_tgt,
                  const UtVec3d& vt,
                  double         closmn,
                  double         angint,
                  double         hdes,
                  double         vs,
                  const UtVec3d& xlos,
                  double         range,
                  UtVec3d&       desdir,
                  double&        sdes);
 
BRAWLER_EXPORT bool TryReadCommand(UtInput& aInput, std::string& aCommand);
BRAWLER_EXPORT void ReadValue(UtInput& aInput, int& aValue);
BRAWLER_EXPORT void ReadValue(UtInput& aInput, double& aValue);
} // namespace BRAWLER
 
#endif