convertdef.h

Go to the documentation of this file.

/********************************************************************
* Copyright (C) 2015 by Interstel Technologies, Inc.
*   and Hawaii Space Flight Laboratory.
*
* This file is part of the COSMOS/core that is the central
* module for COSMOS. For more information on COSMOS go to
* <http://cosmos-project.com>
*
* The COSMOS/core software is licenced under the
* GNU Lesser General Public License (LGPL) version 3 licence.
*
* You should have received a copy of the
* GNU Lesser General Public License
* If not, go to <http://www.gnu.org/licenses/>
*
* COSMOS/core 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 3 of
* the License, or (at your option) any later version.
*
* COSMOS/core 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.
*
* Refer to the "licences" folder for further information on the
* condititons and terms to use this software.
********************************************************************/

#ifndef _CONVERTDEF_H
#define _CONVERTDEF_H 1

#include "support/configCosmos.h"

#include "math/mathlib.h"


// TODO: move these constants to physics/constants.h
#define CLIGHT 299792458.
#define SIGMA 5.67e-8
//#define GC 6.672e-11
#define SOL (86400.*2.99792458e8)
#define RSUNM static_cast<double>(6.955e8)
#define RMOONM static_cast<double>(1738000.)
#define REARTHM static_cast<double>(6378137.)
#define REARTHKM static_cast<double>(6378.137)
#define FLATTENING (1./298.257223563)
#define FRATIO (1.-FLATTENING)
#define FRATIO2 (FRATIO*FRATIO)
#define AU static_cast<double>(1.49597870691e11)
#define MSUN 1.9891e30
#define MEARTH 5.9742e24
#define MMOON 7.3477e22
#define MJUPITER 1.8966e27
//#define GM static_cast<double>((3.98600441789e14))
#define GM static_cast<double>((3.986004415e14))
#define GMOON  static_cast<double>((4.9028029535968e+12))
#define GSUN  static_cast<double>((1.327122e20))
#define GJUPITER static_cast<double>((1.266865349218008e17))
#define LAT_HIGP RADOF(21.297440)
#define LON_HIGP RADOF(157.81630)
#define ALT_HIGP 33.
#define GEOC_HONOLULU {{-5588871.,-2278876.,2353191.}}

// TODO: create SGP4 module
// SGP4 constants
#define SGP4_CK2 5.413080E-4
#define SGP4_CK4 0.62098875E-6
#define SGP4_E6A 1E-6
#define SGP4_QOMS2T 1.88027916E-9
#define SGP4_S 1.01222928
#define SGP4_TOTHRD 2./3.
#define SGP4_XJ3 -0.253881E-5
#define SGP4_XKE 0.743669161E-1
#define SGP4_XKMPER 6378.135
#define SGP4_XMNPDA 1440.0
#define SGP4_AE 1.

// JPL Planetary Ephemeris stuff
#define JPL_MERCURY 1
#define JPL_VENUS 2
#define JPL_EARTH 3
#define JPL_MARS 4
#define JPL_JUPITER 5
#define JPL_SATURN 6
#define JPL_URANUS 7
#define JPL_NEPTUNE 8
#define JPL_PLUTO 9
#define JPL_MOON 10
#define JPL_SUN 11
#define JPL_SUN_BARY 12
#define JPL_EARTH_BARY 13
#define JPL_NUTATIONS 14

// Two Line Element
#define MAXTLE 5000



// COSMOS Planetary Bodies
#define COSMOS_MERCURY JPL_MERCURY
#define COSMOS_VENUS JPL_VENUS
#define COSMOS_EARTH JPL_EARTH
#define COSMOS_MARS JPL_MARS
#define COSMOS_JUPITER JPL_JUPITER
#define COSMOS_SATURN JPL_SATURN
#define COSMOS_URANUS JPL_URANUS
#define COSMOS_NEPTUNE JPL_NEPTUNE
#define COSMOS_PLUTO JPL_PLUTO
#define COSMOS_MOON JPL_MOON
#define COSMOS_SUN JPL_SUN




struct cartpos
{
    double utc = 0.;
    rvector s;
    rvector v;
    rvector a;
    // TODO: get rid of this kind of stuff?
    uint32_t pass = 0.;


    json11::Json to_json() const {
        return json11::Json::object {
            { "utc" , utc },
            { "s", s },
            { "v", v },
            { "a", a },
            { "pass", static_cast<int>(pass) }
        };
    }


    void from_json(const string& js) {
        string error;
        json11::Json parsed = json11::Json::parse(js,error);
        if(error.empty()) {
            if(!parsed["utc"].is_null())    utc = parsed["utc"].number_value();
            if(!parsed["s"].is_null())      s.from_json(parsed["s"].dump());
            if(!parsed["v"].is_null())      v.from_json(parsed["v"].dump());
            if(!parsed["a"].is_null())      a.from_json(parsed["a"].dump());
            if(!parsed["pass"].is_null())   pass = parsed["pass"].int_value();
        } else {
            cerr<<"ERROR = "<<error<<endl;
        }
        return;
    }
};

std::ostream& operator << (std::ostream& out, const cartpos& a);
std::istream& operator >> (std::istream& in, cartpos& a);


struct cposstruc
{
    double utc = 0.;
    cartpos pos;


    json11::Json to_json() const {
        return json11::Json::object {
            { "utc", utc },
            { "pos", pos }
        };
    }


    void from_json(const string& js) {
        string error;
        json11::Json parsed = json11::Json::parse(js,error);
        if(error.empty()) {
            if(!parsed["utc"].is_null())    utc = parsed["utc"].number_value();
            if(!parsed["pos"].is_null())    pos.from_json(parsed["pos"].dump());
        } else {
            cerr << "ERROR = "<<error<<endl;
        }
        return;
    }
};

std::ostream& operator << (std::ostream& out, const cposstruc& a);
std::istream& operator >> (std::istream& in, cposstruc& a);


struct geoidpos
{
    double utc = 0.;
    gvector s;
    gvector v;
    gvector a;
    uint32_t pass = 0;


    json11::Json to_json() const {
        return json11::Json::object {
            { "utc" , utc },
            { "s", s },
            { "v", v },
            { "a", a },
            { "pass", static_cast<int>(pass) }
        };
    }


    void from_json(const string& js) {
        string error;
        json11::Json parsed = json11::Json::parse(js,error);
        if(error.empty()) {
            if(!parsed["utc"].is_null())    utc = parsed["utc"].number_value();
            if(!parsed["s"].is_null())      s.from_json(parsed["s"].dump());
            if(!parsed["v"].is_null())      v.from_json(parsed["v"].dump());
            if(!parsed["a"].is_null())      a.from_json(parsed["a"].dump());
            if(!parsed["pass"].is_null())   pass = parsed["pass"].int_value();
        } else {
            cerr<<"ERROR = "<<error<<endl;
        }
        return;
    }
};

std::ostream& operator << (std::ostream& out, const geoidpos& a);
std::istream& operator >> (std::istream& in, geoidpos& a);


struct spherpos
{
    double utc = 0.;
    svector s;
    svector v;
    svector a;
    uint32_t pass = 0;


    json11::Json to_json() const {
        return json11::Json::object {
            { "utc" , utc },
            { "s", s },
            { "v", v },
            { "a", a },
            { "pass", static_cast<int>(pass) }
        };
    }


    void from_json(const string& js) {
        string error;
        json11::Json parsed = json11::Json::parse(js,error);
        if(error.empty()) {
            if(!parsed["utc"].is_null())    utc = parsed["utc"].number_value();
            if(!parsed["s"].is_null())      s.from_json(parsed["s"].dump());
            if(!parsed["v"].is_null())      v.from_json(parsed["v"].dump());
            if(!parsed["a"].is_null())      a.from_json(parsed["a"].dump());
            if(!parsed["pass"].is_null())   pass = parsed["pass"].int_value();
        } else {
            cerr<<"ERROR = "<<error<<endl;
        }
        return;
    }
};

std::ostream& operator << (std::ostream& out, const spherpos& a);
std::istream& operator >> (std::istream& in, spherpos& a);

struct aattstruc
{
    double utc = 0.;
    avector s;
    avector v;
    avector a;


    json11::Json to_json() const {
        return json11::Json::object {
            { "utc" , utc },
            { "s" , s },
            { "v" , v },
            { "a" , a }
        };
    }

    void from_json(const string& js) {
        string error;
        json11::Json parsed = json11::Json::parse(js,error);
        if(error.empty()) {
            if(!parsed["utc"].is_null())    utc = parsed["utc"].number_value();
            if(!parsed["s"].is_null())      s.from_json(parsed["s"].dump());
            if(!parsed["v"].is_null())      v.from_json(parsed["v"].dump());
            if(!parsed["a"].is_null())      a.from_json(parsed["a"].dump());
        } else  {
            cerr<<"ERROR = "<<error<<endl;
        }
        return;
    }
};

std::ostream& operator << (std::ostream& out, const aattstruc& a);
std::istream& operator >> (std::istream& in, aattstruc& a);

struct quatatt
{
    double utc;
    quaternion s;
    rvector v;
    rvector a;
};

std::ostream& operator << (std::ostream& out, const quatatt& a);
std::istream& operator >> (std::istream& in, quatatt& a);


struct dcmatt
{
    double utc = 0.;
    rmatrix s;
    rvector v;
    rvector a;


    json11::Json to_json() const {
        return json11::Json::object {
            { "utc" , utc },
            //{ "s", s },
            { "v", v },
            { "a", a }
        };
    }


    void from_json(const string& js) {
        string error;
        json11::Json parsed = json11::Json::parse(js,error);
        if(error.empty()) {
            if(!parsed["utc"].is_null())    utc = parsed["utc"].number_value();
            //if(!parsed["s"].is_null())        s.from_json(parsed["s"].dump());
            if(!parsed["v"].is_null())      v.from_json(parsed["v"].dump());
            if(!parsed["a"].is_null())      a.from_json(parsed["a"].dump());
        } else {
            cerr<<"ERROR = "<<error<<endl;
        }
        return;
    }
};

std::ostream& operator << (std::ostream& out, const dcmatt& a);
std::istream& operator >> (std::istream& in, dcmatt& a);


struct qatt
{
    double utc = 0.;
    quaternion s; //q
    rvector v;  //dq
    rvector a;  //ddq
    uint32_t pass = 0;


    json11::Json to_json() const {
        return json11::Json::object {
            { "utc" , utc },
            { "s" , s },
            { "v" , v },
            { "a" , a },
            { "pass" , static_cast<int>(pass) }
        };
    }


    void from_json(const string& js) {
        string error;
        json11::Json parsed = json11::Json::parse(js,error);
        if(error.empty()) {
            if(!parsed["utc"].is_null())    utc = parsed["utc"].number_value();
            if(!parsed["s"].is_null())    s.from_json(parsed["s"].dump());
            if(!parsed["v"].is_null())    v.from_json(parsed["v"].dump());
            if(!parsed["a"].is_null())    a.from_json(parsed["a"].dump());
            if(!parsed["pass"].is_null())    pass = parsed["pass"].int_value();
        } else {
            cerr<<"ERROR = "<<error<<endl;
        }
        return;
    }
};

std::ostream& operator << (std::ostream& out, const qatt& a);
std::istream& operator >> (std::istream& in, qatt& a);


struct kepstruc
{
    double utc;
    uint32_t orbit;
    double period;
    double a;
    double e;
    rvector h;
    double beta;
    double eta;
    double i;
    double raan;
    double ap;
    double alat;
    double ma;
    double ta;
    double ea;
    double mm;
    double fa;
};

std::ostream& operator << (std::ostream& out, const kepstruc& a);
std::istream& operator >> (std::istream& in, kepstruc& a);

struct bodypos
{
    double sepangle;
    double size;
    double radiance;
};

std::ostream& operator << (std::ostream& out, const bodypos& a);
std::istream& operator << (std::istream& in, bodypos& a);

struct extrapos
{
    double utc = 0.;
    double tt = 0.;
    double ut = 0.;
    double tdb = 0.;
    rmatrix j2e;
    rmatrix dj2e;
    rmatrix ddj2e;
    rmatrix e2j;
    rmatrix de2j;
    rmatrix dde2j;
    rmatrix j2t;
    rmatrix j2s;
    rmatrix t2j;
    rmatrix s2j;
    rmatrix s2t;
    rmatrix ds2t;
    rmatrix t2s;
    rmatrix dt2s;
    cartpos sun2earth;
    cartpos sun2moon;
    uint16_t closest = 0;


    json11::Json to_json() const {
        return json11::Json::object {
            { "utc"   , utc },
            { "tt"    , tt },
            { "ut"    , ut },
            { "tdb"   , tdb },

            { "j2e"   , j2e },
            { "dj2e"  , dj2e },
            { "ddj2e" , ddj2e },

            { "e2j"   , e2j },
            { "de2j"  , de2j },
            { "dde2j" , dde2j },

            { "j2t"   , j2t },
            { "j2s"   , j2s },
            { "t2j"   , t2j },
            { "s2j"   , s2j },
            { "s2t"   , s2t },
            { "ds2t"  , ds2t },
            { "t2s"   , t2s },
            { "dt2s"  , dt2s },
            
            { "sun2earth" , sun2earth },
            { "sun2moon"  , sun2moon },
            { "closest"   , closest }
        };
    }


    void from_json(const string& s) {
        string error;
        json11::Json p = json11::Json::parse(s,error);
        if(error.empty()) {
            if(!p["utc"].is_null())     utc = p["utc"].number_value();
            if(!p["tt"].is_null())      tt = p["tt"].number_value();
            if(!p["ut"].is_null())      ut = p["ut"].number_value();
            if(!p["tdb"].is_null())     tdb = p["tdb"].number_value();

            if(!p["j2e"].is_null())     j2e.from_json(p["j2e"].dump());
            if(!p["dj2e"].is_null())    dj2e.from_json(p["dj2e"].dump());
            if(!p["ddj2e"].is_null())   ddj2e.from_json(p["ddj2e"].dump());
           
            if(!p["e2j"].is_null())     e2j.from_json(p["e2j"].dump());
            if(!p["de2j"].is_null())    de2j.from_json(p["de2j"].dump());
            if(!p["dde2j"].is_null())   dde2j.from_json(p["dde2j"].dump());
           
            if(!p["j2t"].is_null())     j2t.from_json(p["j2t"].dump());
            if(!p["j2s"].is_null())     j2s.from_json(p["j2s"].dump());
            if(!p["t2j"].is_null())     t2j.from_json(p["t2j"].dump());
            if(!p["s2j"].is_null())     s2j.from_json(p["s2j"].dump());
            if(!p["s2t"].is_null())     s2t.from_json(p["s2t"].dump());
            if(!p["ds2t"].is_null())    ds2t.from_json(p["ds2t"].dump());
            if(!p["t2s"].is_null())     t2s.from_json(p["t2s"].dump());
            if(!p["dt2s"].is_null())    dt2s.from_json(p["dt2s"].dump());
            
            if(!p["sun2earth"].is_null())   sun2earth.from_json(p["sun2earth"].dump());
            if(!p["sun2moon"].is_null())    sun2moon.from_json(p["sun2moon"].dump());
            if(!p["closest"].is_null()) closest = p["closest"].int_value();
        } else {
            cerr<<"ERROR: <"<<error<<">"<<endl;
        }
        return;
    }
};

std::ostream& operator << (std::ostream& out, const extrapos& a);
std::istream& operator >> (std::istream& in, extrapos& a);

struct extraatt
{
    double utc = 0.;
    rmatrix j2b;
    rmatrix b2j;


    json11::Json to_json() const {
        return json11::Json::object {
            { "utc" , utc },
            { "j2b" , j2b },
            { "b2j" , b2j }
        };
    }


    void from_json(const string& js) {
        string error;
        json11::Json parsed = json11::Json::parse(js,error);
        if(error.empty()) {
            if(!parsed["utc"].is_null())     utc =  parsed["utc"].number_value();
            if(!parsed["j2b"].is_null())    j2b.from_json(parsed["j2b"].dump());
            if(!parsed["b2j"].is_null())    b2j.from_json(parsed["b2j"].dump());
        } else {
            cerr<<"ERROR = "<<error<<endl;
        }
        return;
    }
};

std::ostream& operator << (std::ostream& out, const extraatt& a);
std::istream& operator >> (std::istream& in, extraatt& a);

struct posstruc
{
    double utc = 0.;
    cartpos icrf;
    cartpos eci;
    cartpos sci;
    cartpos geoc;
    cartpos selc;
    geoidpos geod;
    geoidpos selg;
    spherpos geos;
    extrapos extra;
    float earthsep = 0.f;
    float moonsep = 0.f;
    float sunsize = 0.f;
    float sunradiance = 0.f;
    rvector bearth;
    double orbit = 0.;


    json11::Json to_json() const {
        return json11::Json::object {
            { "utc"  , utc },
            { "icrf" , icrf },
            { "eci"  , eci },
            { "sci"  , sci },
            { "geoc" , geoc },
            { "selc" , selc },
            { "geod" , geod },
            { "selg" , selg },
            { "geos" , geos },
            { "extra", extra },

            { "earthsep" , earthsep },
            { "moonsep"  , moonsep },
            { "sunsize"  , sunsize },
            { "sunradiance" , sunradiance },
            { "bearth"   , bearth },
            { "orbit"    , orbit }
        };
    }


    void from_json(const string& js) {
        string error;
        json11::Json parsed = json11::Json::parse(js,error);
        if(error.empty()) {
            if(!parsed["utc"].is_null())    utc = parsed["utc"].number_value();
            if(!parsed["icrf"].is_null())   icrf.from_json(parsed["icrf"].dump());
            if(!parsed["eci"].is_null())    eci.from_json(parsed["eci"].dump());
            if(!parsed["sci"].is_null())    sci.from_json(parsed["sci"].dump());
            if(!parsed["geoc"].is_null())   geoc.from_json(parsed["geoc"].dump());
            if(!parsed["selc"].is_null())   selc.from_json(parsed["selc"].dump());
            if(!parsed["geod"].is_null())   geod.from_json(parsed["geod"].dump());
            if(!parsed["selg"].is_null())   selg.from_json(parsed["selg"].dump());
            if(!parsed["geos"].is_null())   geos.from_json(parsed["geos"].dump());
            if(!parsed["extra"].is_null())  extra.from_json(parsed["extra"].dump());

            if(!parsed["earthsep"].is_null())    earthsep = parsed["earthsep"].number_value();
            if(!parsed["moonsep"].is_null())     moonsep = parsed["moonsep"].number_value();
            if(!parsed["sunsize"].is_null())     sunsize = parsed["sunsize"].number_value();
            if(!parsed["sunradiance"].is_null()) sunradiance = parsed["sunradiance"].number_value();

            if(!parsed["bearth"].is_null())   bearth.from_json(parsed["bearth"].dump());
            if(!parsed["orbit"].is_null())    orbit = parsed["orbit"].number_value();

        } else {
            cerr<<"ERROR = "<<error<<endl;
        }
        return;
    }
};

std::ostream& operator << (std::ostream& out, const posstruc& a);
std::istream& operator >> (std::istream& in, posstruc& a);

struct attstruc
{
    double utc = 0.;
    qatt topo;
    qatt lvlh;
    qatt geoc;
    qatt selc;
    qatt icrf;
    extraatt extra;


    json11::Json to_json() const {
        return json11::Json::object {
            { "utc"  , utc },
            { "topo" , topo },
            { "lvlh" , lvlh },
            { "geoc" , geoc },
            { "selc" , selc },
            { "icrf" , icrf },
            { "extra" , extra }
        };
    }


    void from_json(const string& js) {
        string error;
        json11::Json parsed = json11::Json::parse(js,error);
        if(error.empty()) {
            if(!parsed["utc"].is_null())     utc =  parsed["utc"].number_value();
            if(!parsed["topo"].is_null())    topo.from_json(parsed["utc"].dump());
            if(!parsed["lvlh"].is_null())    lvlh.from_json(parsed["lvlh"].dump());
            if(!parsed["geoc"].is_null())    geoc.from_json(parsed["geoc"].dump());
            if(!parsed["selc"].is_null())    selc.from_json(parsed["selc"].dump());
            if(!parsed["icrf"].is_null())    icrf.from_json(parsed["icrf"].dump());
            if(!parsed["extra"].is_null())   extra.from_json(parsed["extra"].dump());
        } else {
            cerr<<"ERROR = "<<error<<endl;
        }
        return;
    }
};

std::ostream& operator << (std::ostream& out, const attstruc& a);
std::istream& operator >> (std::istream& in, attstruc& a);

struct locstruc
{
    double utc = 0.;
    posstruc pos;
    attstruc att;


    json11::Json to_json() const {
        return json11::Json::object {
            { "utc" , utc },
            { "pos" , pos },
            { "att" , att }
        };
    }


    void from_json(const string& js) {
        string error;
        json11::Json parsed = json11::Json::parse(js,error);
        if(error.empty()) {
            if(!parsed["utc"].is_null())    utc =  parsed["utc"].number_value();
            if(!parsed["pos"].is_null())    pos.from_json(parsed["pos"].dump());
            if(!parsed["att"].is_null())    att.from_json(parsed["att"].dump());
        } else {
            cerr<<"ERROR = "<<error<<endl;
        }
        return;
    }
};

std::ostream& operator << (std::ostream& out, const locstruc& a);
std::istream& operator >> (std::istream& in, locstruc& a);

struct tlestruc
{
    double utc = 0.;
    // JIMNOTE: remove magic number
    char name[25] = "";
    uint16_t snumber = 0;
    // JIMNOTE: remove magic number
    char id[9] = "";
    double bstar = 0.;
    double i = 0.;
    double raan = 0.;
    double e = 0.;
    double ap = 0.;
    double ma = 0.;
    double mm = 0.;
    uint32_t orbit = 0;


    json11::Json to_json() const {
        return json11::Json::object {
            { "utc" , utc },
            { "name" , name },
            { "snumber" , snumber },
            { "id" , id },
            { "bstar" , bstar },
            { "i" , i },
            { "raan" , raan },
            { "e" , e },
            { "ap" , ap },
            { "ma" , ma },
            { "mm" , mm },
            { "orbit" , static_cast<int>(orbit) }
        };
    }


    void from_json(const string& js) {
        string error;
        json11::Json parsed = json11::Json::parse(js,error);
        if(error.empty()) {
            if(!parsed["utc"].is_null())    utc =  parsed["utc"].number_value();
            if(!parsed["name"].is_null())    strcpy(name, parsed["name"].string_value().c_str());
            if(!parsed["snumber"].is_null())    snumber =  parsed["snumber"].int_value();
            if(!parsed["id"].is_null())    strcpy(id, parsed["id"].string_value().c_str());
            if(!parsed["bstar"].is_null())    bstar =  parsed["bstar"].number_value();
            if(!parsed["i"].is_null())    i =  parsed["i"].number_value();
            if(!parsed["raan"].is_null())    raan =  parsed["raan"].number_value();
            if(!parsed["e"].is_null())    e =  parsed["e"].number_value();
            if(!parsed["ap"].is_null())    ap =  parsed["ap"].number_value();
            if(!parsed["ma"].is_null())    ma =  parsed["ma"].number_value();
            if(!parsed["mm"].is_null())    mm =  parsed["mm"].number_value();
            if(!parsed["orbit"].is_null())    orbit =  parsed["orbit"].int_value();
        } else {
            cerr<<"ERROR = "<<error<<endl;
        }
        return;
    }
};


struct stkstruc
{
    size_t count;
    double dt;
    cposstruc *pos;
};


// Name clashes with literature... these are published units (in TLE file), not for use in the SGP4 propogator itself.
struct sgp4struc
{
    // Inclination (deg)
    double i;
    // Eccentricity
    double e;
    // Right-ascension of the Ascending Node (deg)
    double raan;
    // Argument of Perigee (deg)
    double ap;
    //B-Star drag term
    double bstar;
    // Mean Motion (rev/day)
    double mm;
    // Mean Anomaly (deg)
    double ma;
    // Epoch (year.day)
    double ep;
};

#endif