/disk01/web/ocssw/build/inc/osmiinc/orbit.h (r8090/r2592)

Go to the documentation of this file.

/*
 *----------------------------------------------------------------------
 *  @(#) orbit.h    1.03    5 May 95    <shc>
 *  Copyright (c) 1993, CSIRO Division of Oceanography.
 *----------------------------------------------------------------------
 *
 *  Various structures, constants and macros used in the orbit
 *  package routines.
 *
 * History:
 *  1.0 18 Oct 93   <shc>
 *      Initial version.
 *
 *  1.01    12 Dec 94   <shc>
 *      Added errstr stuff for integration with Python
 *
 *  1.02    27 Jan 95   <shc>
 *      Added SGP4 stuff.
 *
 *  1.03    5 May 95    <shc>
 *      Added TLE_VALUES struct and prototypes for tle.c
 *
 *  1.04    24 Jan 96   <shc>
 *      Modified SGP4 struct so secular rates are more accessible,
 *      changed rates from rad/min to rad/sec for conformance with
 *      package standards.
 *
 *----------------------------------------------------------------------
 */

#ifndef __ORBIT__
#define __ORBIT__

#include <stdint.h>
#include <math.h>
#include <time.h>
#ifndef NULL
#include <stdio.h>
#endif

#include "earth.h"
#include "lunsol.h"

#define DPI     3.14159265358979323846
#define D2PI        6.28318530717958647692
#define D3PI        9.42477796076937971538

#define FP_ERRVAL   -1.0e-20    /* Error value from f.p. routines */

/* Degrees to radians */
#define DTOR(X) ((X) * DPI/180.0)

/* Radians to degrees */
#define RTOD(X) ((X) * 180.0/DPI)

/* Fold an angle to the range [0..2 Pi] radians */
#define AN2PI(X) fmod(fmod((X), D2PI) + D2PI, D2PI)

/* Fold an angle to the range [-Pi .. Pi] radians */
#define ANPI(X) (fmod(fmod((X), D2PI) + D3PI, D2PI) - DPI)

/* Fold an angle to the range [0..360] degrees */
#define AN360(X) fmod(fmod((X), 360.0) + 360.0, 360.0)

/* Arc-seconds to radians */
#define ASTOR(X) ((X) * DPI/(180.0 * 3600.0))

/* Arc-seconds per century to radians per day */
#define ASPCTORPD(X) ((X) * DPI/(180.0 * 3600.0 * 36525.0))

/* Epoch(s) in my time scheme (JD % 2400000) */
#define J2000   (51545.0)


/*
 * Struct for defining the attitude (orientation) of a satellite
 * or satellite scanner vector.  Angles are in radians.
 */

struct ATTITUDE  {
    double pitch;
    double roll;
    double yaw;
};


/*
 * Structure used by the Brouwer routines.  The first 6 structure
 * members, which are set by the user, are Brouwer mean elements.
 * The remaining elements are initialised by blinit() for subsequent use by
 * blosc().  Of these, only "darp", "dran" and "dman", which are the time
 * derivatives of "arp", "ran" and "man", are independently useful.
 */

struct BROUWER {
    double  sma,    /* Semi-major axis (metres) */
        ecc,    /* Eccentricity */
        inc,    /* Inclination (radians) */
        arp,    /* Argument of perigee (radians) */
        ran,    /* Right ascension of the ascending node (radians) */
        man;    /* Mean anomaly (radians) */

    double  darp,   /* Secular rate of "arp" (radians/sec) */
        dran,   /* Secular rate of "ran" (radians/sec) */
        dman;   /* Secular rate of "man" (radians/sec) */

    /* You really don't want to know about these. */
    double  a20, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10,
        b11, b12, b13, b14, b15, edp2, eta, eta2, eta3,
        eta6, gm2, gmp2, sidp, sidph, cidph, theta, theta2;
};


/*
 * Structure for specifying geodetic coordinates (e.g. an observer's
 * location).
 */

struct GEODETIC {
    double lat; /* Geodetic latitude (radians) */
    double lon; /* Longitude (radians) */
    double height;  /* Height above the geoid (metres) */
};


/*
 * Structure for transfer of Keplerian orbital elements.
 */

struct KEPLER {
    double  sma,    /* Semi-major axis (metres) */
        ecc,    /* Eccentricity */
        inc,    /* Inclination (radians) */
        arp,    /* Argument of perigee (radians) */
        ran,    /* Right ascension of the ascending node (radians) */
        man;    /* Mean anomaly (radians) */
};


/*
 * Structure for specifying nutation angles (radians).
 */
struct NUTATION {
    double mood;        /* Mean obliquity of date */
    double nutlon;      /* Nutation in longitude */
    double nutobl;      /* Nutation in obliquity */
};
 

/*
 * Structure for specifying precession angles (radians).
 */
struct PRECESSION {
        double zeta;
        double z;
        double theta;
};
 

/*
 * Structure for specifying right ascension and declination (radians).
 */
struct RADEC {
        double ra;
        double dec;
};


/*
 * Structure used by the SGP4 routines.  The first 7 members are the
 * orbital elements at epoch + the drag coefficient.  The remaining
 * members are initialised by sgp4_init() for subsequent use by
 * sgp4_pred().
 */

struct SGP4 {
    double  xno,        /* Mean motion (radians/sec) */
        eo,     /* Eccentricity */
        xincl,      /* Inclination (radians) */
        omegao,     /* Argument of perigee (radians) */
        xnodeo,     /* Longitude of ascending node (radians) */
        xmo,        /* Mean anomaly (radians) */
        bstar;      /* Drag coefficient */

    double  omgdot,     /* Secular rate of omega (radians/sec) */
        xnodot,     /* Secular rate of xnode (radians/sec) */
        xmdot;      /* Secular rate of xm    (radians/sec) */

    /* You probably don't want to know about these. */
    int isimp;
    double  aodp, aycof, c1, c1sq, c4, c5, cosio, d2, d3, d4, delmo,
        eta, omgcof, sinio, sinmo, t2cof, t3cof, t4cof, t5cof,
        x1mth2, x3thm1, x7thm1, xhdot1, xlcof, xmcof, xnodcf, xnodp;
};


/*
 * Two-line-element values.  The function tle_parse() can be used to
 * read the values from an element set into this structure.
 */

struct TLE_VALUES {
    int satellite_number;   /* NORAD satellite number */
    char    designator[9];      /* International designator */
    int year;           /* Last two digits of year */
    double  dayofyr;        /* Day of year (1 origin) */
    double  mmdt;           /* First derivative of mean motion */
    double  mmdt2;          /* Second derivative of mean motion */
    double  bstar;          /* B* drag term */
    int ephem_type;
    int element_number;
    double  incl;           /* Inclination (deg) */
    double  raan;           /* Right ascension of asc node (deg) */
    double  ecc;            /* Eccentricity */
    double  argp;           /* Argument of perigee (deg) */
    double  manom;          /* Mean anomaly (deg) */
    double  mmotion;        /* Mean motion (revs/day) */
    int revolution;     /* Epoch orbit number */
};


/*
 * Structure for specifying topocentric coordinates.
 */

struct TOPOCENTRIC {
    double az;  /* Azimuth (radians) */
    double el;  /* Elevation (radians) */
    double range;   /* Range (metres) */
};



/*
 * Function prototypes.
 */

/* brouwer.c */
int blinit(struct BROUWER *bp, char **errstr);
int blosc(struct BROUWER *bp, double delt, struct KEPLER *kp,
          char **errstr);

/* ctogd.c */
void    ctogd(double r[3], double gha, struct GEODETIC *geod,
          double dgeod[3][3]);

/* ctok.c */
int ctok(double r[6], struct KEPLER *keplr, char **errmsg);

/* ctotc.c */
void    ctotc(double r[3], struct GEODETIC *obs, double gha,
          struct TOPOCENTRIC *top, double daer[3][3]);

/* eanom.c */
double  eanom(double manom, double ecc, char **errstr);

/* efitoeci.c */
int efitoeci(double r[6], double gha, double rp[6]);

/* efrtoeci.c */
int efrtoeci(double r[6], double gha, double rp[6]);

/* ecitoefi.c */
int ecitoefi(double r[6], double gha, double rp[6]);

/* ecitoefr.c */
int ecitoefr(double r[6], double gha, double rp[6]);

/* gmha.c */
double  gmha(double tjd);
double  gmhadot(double tjd);

/* julian.c */
void    caldat(int32_t julian, int *year, int *month, int *day);
double  itojul(int32_t date, int32_t time);
int32_t julday(int year, int month, int day);
void    jultoi(double tjd, int32_t *date, int32_t *time);
void    jultotm(double tjd, struct tm *time);
double  tmtojul(struct tm *time);

/* ktoc.c */
int ktoc(struct KEPLER *kp, double r[6], char **errstr);

/* ktosgp4.c */
int ktosgp4(struct KEPLER *kepler, struct SGP4 *sgp4, char **errmsg);

/* locate.c */
int locate(double r[6], struct ATTITUDE *sat,
           struct ATTITUDE *scanner, double loc[3]);

/* moonpos.c */
void    moonpos(double tjd, double r[3]);

/* nutate.c */
void    nut_angles(double tjd, struct NUTATION *angles, struct NUTATION *rates);
void    nut_matrix(double tjd, double a[3][3]);

/* obliq.c */
void    obliq(double tjd, double *mood, double *dmood);

/* precess.c */
void    pre_angles(double tjd0, double tjd1, struct PRECESSION *angles);
void    pre_reduce(double tjd0, struct RADEC *rad0,
           double tjd1, struct RADEC *rad1);

/* rdtotc.c */
void    rdtotc(struct RADEC *rad, struct GEODETIC *obs,
           double gmha, struct TOPOCENTRIC *top);

/* refract.c */
double  refract(double alt, double temp, double pressure);
double  unrefract(double alt, double temp, double pressure);

/* sgp4.c */
int sgp4_init(struct SGP4 *sgp4, char **errstr);
int sgp4_pred(struct SGP4 *sgp4, double tsince, double rect[6],
          char **errstr);
double  sgp4_orbit(struct SGP4 *sgp4, struct TLE_VALUES *tv, double tsince);
int sgp4_tle(double *epoch, struct SGP4 *sgp4, char *line1,
         char *line2, char **errstr);

/* sunpos.c */
int sunpos(double tjd, double r[3], char **errstr);

/* tconv.c */
double  tconv(double tjd, char conv[], char **errstr);
int tcset(double x, char what[], char **errstr);

/* tle.c */
int tle_parse(char *line1, char *line2, struct TLE_VALUES *tv,
          char **errstr);

#endif /* __ORBIT__ */