Time handling functions

Collaboration diagram for Time handling functions:

Functions
double	currentmjd (double offset)
	Current UTC in Modified Julian Days. More...
double	currentmjd ()
unsigned long int	get_unix_time ()
string	get_local_time ()
double	unix2utc (struct timeval unixtime)
	Unix time to UTC. More...
double	unix2utc (double unixtime)
	Unix time to UTC. More...
struct timeval	utc2unix (double utc)
	UTC to Unix time. More...
double	utc2unixseconds (double utc)
	UTC to Unix time. More...
calstruc	mjd2cal (double mjd)
	MJD to Calendar. More...
int32_t	mjd2ymd (double mjd, int32_t &year, int32_t &month, double &day)
	MJD to Year, Month, and Decimal Day (overloaded) More...
int32_t	mjd2ymd (double mjd, int32_t &year, int32_t &month, double &day, double &doy)
	MJD to Year, Month, Decimal Day, and Julian Day (overloaded) More...
double	cal2mjd (int32_t year, int32_t month, int32_t day, int32_t hour, int32_t minute, int32_t second, int32_t nsecond)
	Calendar representation to Modified Julian Day - full. More...
double	cal2mjd (double year)
	Calendar representation YYYY.ffff to Modified Julian Day - overloaded. More...
double	cal2mjd (int32_t year, double dayOfYear)
	Calendar representation YYYY,DDD.ffff to Modified Julian Day - overloaded. More...
double	cal2mjd (int32_t year, int32_t month, double day)
	Calendar representation to Modified Julian Day - shortened. More...
double	cal2mjd (calstruc date)
	Calendar representation to Modified Julian Day - structure. More...
double	gregorianToModJulianDate (int32_t year, int32_t month, int32_t day, int32_t hour, int32_t minute, double second)
double	utc2jcentt (double mjd)
	TT Julian Century. More...
double	utc2jcenut1 (double mjd)
	UT1 Julian Century. More...
rvector	utc2nuts (double mjd)
	Nutation values. More...
double	utc2dpsi (double mjd)
	Nutation Delta Psi value. More...
double	utc2depsilon (double mjd)
	Nutation Delta Epsilon value. More...
double	utc2epsilon (double mjd)
	Nutation Epsilon value. More...
double	utc2L (double mjd)
	Nutation L value. More...
double	utc2Lp (double mjd)
	Nutation L prime value. More...
double	utc2F (double mjd)
	Nutation F value. More...
double	utc2D (double mjd)
	Nutation D value. More...
double	utc2omega (double mjd)
	Nutation omega value. More...
double	utc2zeta (double utc)
	Precession zeta value. More...
double	utc2z (double utc)
	Precession z value. More...
double	utc2theta (double utc)
	Precession theta value. More...
double	utc2dut1 (double mjd)
	Calculate DUT1. More...
double	utc2ut1 (double mjd)
	Convert UTC to UT1. More...
double	julcen (double mjd)
	Julian Century. More...
double	utc2tdb (double mjd)
	Convert UTC to TDB. More...
double	tt2utc (double mjd)
	Convert TT to UTC. More...
double	utc2tt (double mjd)
	Convert UTC to TT. More...
double	utc2gps (double utc)
	Convert UTC to GPS. More...
double	gps2utc (double gps)
	Convert GPS to UTC. More...
void	gps2week (double gps, uint32_t &week, double &seconds)
	GPS Weeks and Seconds from GPS time. More...
double	week2gps (uint32_t week, double seconds)
	GPS Time from GPS Week and Seconds. More...
double	mjd2year (double mjd)
	Year from MJD. More...
double	mjd2doy (double mjd)
	Day of Year from MJD. More...
double	utc2era (double mjd)
	Earth Rotation Angle. More...
double	utc2gast (double mjd)
	UTC to GAST. More...
double	utc2gmst1982 (double mjd)
	UTC (Modified Julian Day) to GMST. More...
double	utc2gmst2000 (double utc)
double	ranrm (double angle)
int16_t	isleap (int32_t year)
	Check for Leap year. More...
int32_t	load_iers ()
	Load IERS Polar Motion, UT1-UTC, Leap Seconds. More...
int32_t	leap_seconds (double mjd)
	Leap Seconds. More...
cvector	polar_motion (double mjd)
	Polar motion. More...
string	utc2unixdate (double utc)
	Time for setting unix date. More...
string	utc2iso8601 (double utc)
	ISO 8601 version of time. More...
double	iso86012utc (string date)
string	mjd2iso8601 (double mjd)
int32_t	dayFraction2hms (double dayFraction, int32_t *hour, int32_t *minute, int32_t *second)
int32_t	mjdToGregorian (double mjd, int32_t &year, int32_t &month, int32_t &day, int32_t &hour, int32_t &minute, int32_t &second)
string	mjdToGregorian (double mjd)
string	mjdToGregorianFormat (double mjd)
string	mjdToGregorianDDMMMYYYY (double mjd)
string	mjdToGregorianDDMmmYYYY (double mjd)
string	seconds2DDHHMMSS (double elapsed_seconds)
	Convert Elapsed Time in Seconds to Human Readable Format (used for GPS simulator) More...
double	mjd2jd (double mjd)
	Modified Julian Day to Julian Day. More...
double	jd2mjd (double jd)
	Julian Day to Modified Julian Day. More...
int32_t	timed_countdown (int32_t seconds, int32_t step, string message)
int32_t	mjdToGregorian (double mjd, int32_t *year, int32_t *month, int32_t *day, int32_t *hour, int32_t *minute, int32_t *second)
int32_t	mjd2tlef (double mjd, string &tle)
	Convert mjd to the TLE epoch format. More...
double	tt2tdb (double mjd)
double	set_local_clock (double utc_to)

Detailed Description

Function Documentation

double currentmjd

(

double

offset

)

Current UTC in Modified Julian Days.

Parameters

offset

MJD offset to be apllied to turn actual time in to simulated time.

Returns

simulated time in Modified Julian Days.

{
    double mjd;

    // unfortunatelly MSVC does not support gettimeofday
#ifdef COSMOS_WIN_BUILD_MSVC
    TimeUtils tu;
    mjd = unix2utc(tu.secondsSinceEpoch() + _timezone);
#else
    struct timeval mytime;
    gettimeofday(&mytime, NULL);
    mjd = unix2utc(mytime);
#endif
    return mjd+offset;
}

double currentmjd

(

)

{
    return currentmjd(0.);
}

unsigned long get_unix_time

(

)

{
    unsigned long int unix_time = time(NULL);
    return unix_time;
}

string get_local_time

(

)

{
    time_t rawtime;
    struct tm * timeinfo;

    time (&rawtime);
    timeinfo = localtime (&rawtime);
    //printf ("Current local time and date: %s", asctime(timeinfo));

    int year = 1900 + timeinfo->tm_year;
    int month = 1 + timeinfo->tm_mon;
    int day = timeinfo->tm_mday;
    int hour = timeinfo->tm_hour;
    int minute = timeinfo->tm_min;
    int second = timeinfo->tm_sec;

    char time_string[25];

    sprintf(time_string, "%04d-%02d-%02dT%02d%02d%02d", year, month, day, hour, minute, second);

    return string(time_string);
}

double unix2utc

(

struct timeval

unixtime

)

Unix time to UTC.

Convert Unix time in a timeval structure to a double precision number representing Mofidied Julian Day.

Parameters

unixtime

Unix time to be converted.

Returns

UTC as Modified Julian day.

{
    double utc;
    utc = MJD_UNIX_OFFSET + (unixtime.tv_sec + unixtime.tv_usec / 1000000.) / 86400.;

    return utc;
}

double unix2utc

(

double

unixtime

)

Unix time to UTC.

Convert Unix time in seconds to a double precision number representing Mofidied Julian Day.

Parameters

unixtime

Unix time in decimal seconds.

Returns

UTC as Modified Julian day.

{
    double utc;
    struct tm *mytm;
    time_t thetime;

    thetime = (time_t)unixtime;
    mytm = gmtime(&thetime);
    utc = cal2mjd(mytm->tm_year+1900,mytm->tm_mon+1,mytm->tm_mday);
    utc += ((mytm->tm_hour + (mytm->tm_min + (mytm->tm_sec + (unixtime-(time_t)unixtime)) / 60.) / 60.) / 24.);

    return utc;
}

struct timeval utc2unix

(

double

utc

)

UTC to Unix time.

Convert UTC in Modified Julian Day to a timeval structure representing Unix time.

Parameters

utc	as Modified Julian Day.

Returns

Timeval structure with Unix time.

{
    struct timeval unixtime;
    double unixseconds = 86400. * (utc - MJD_UNIX_OFFSET);
    unixtime.tv_sec = (int)unixseconds;
    unixtime.tv_usec = 1000000. * (unixseconds - unixtime.tv_sec);

    return unixtime;
}

double utc2unixseconds

(

double

utc

)

UTC to Unix time.

Convert UTC in Modified Julian Day to a double representing Unix time.

Parameters

utc	as Modified Julian Day.

Returns

Double with Unix time.

{
    double unixseconds = 86400. * (utc - MJD_UNIX_OFFSET);

    return unixseconds;
}

calstruc mjd2cal

(

double

mjd

)

MJD to Calendar.

Convert Modified Julian Day to Calendar Year, Month, Day, Hour, Minute, Second and Nanosecond.

Parameters

mjd	Modified Julian Day

Returns

Calendar representation in calstruc

{
    static double lmjd = 0.;
    static calstruc date;

    if (lmjd != mjd)
    {
        double dom;
        double doy;

        lmjd = mjd;

        mjd2ymd(mjd, date.year, date.month, dom, doy);
        date.doy = (int32_t)doy;
        date.dom = (int32_t)dom;
        doy = (doy - date.doy) * 24.;
        date.hour = (int32_t)doy;
        doy = (doy - date.hour) * 60.;
        date.minute = (int32_t)doy;
        doy = (doy - date.minute) * 60.;
        date.second = (int32_t)doy;
        doy = (doy - date.second) * 1e9;
        date.nsecond = (int32_t)(doy + .5);
    }

    return date;
}

int32_t mjd2ymd	(	double	mjd,
		int32_t &	year,
		int32_t &	month,
		double &	day
	)

MJD to Year, Month, and Decimal Day (overloaded)

Convert Modified Julian Day to Calendar Year, Month, Decimal Day. basically it just calls mjd2ymd with all the arguments

Parameters

mjd	Modified Julian Day
year	Pointer to return Calendar Year
month	Pointer to return Calendar Month
day	Pointer to return Decimal Day of the Month

Returns

0, otherwise negative error

{
    double doy;
    return mjd2ymd(mjd, year, month, day, doy);
}

int32_t mjd2ymd	(	double	mjd,
		int32_t &	year,
		int32_t &	month,
		double &	day,
		double &	doy
	)

MJD to Year, Month, Decimal Day, and Julian Day (overloaded)

Convert Modified Julian Day to Calendar Year, Month, Decimal Day.

Parameters

mjd	Modified Julian Day
year	Pointer to return Calendar Year
month	Pointer to return Calendar Month
day	Pointer to return Decimal Day of the Month
doy	Pointer to return Decimal Day of the Year

Returns

0, otherwise negative error

{
    static double lmjd = 0.;
    static int32_t lyear = 1858;
    static int32_t lmonth = 11;
    static double lday = 17.;
    static double ldoy = 321.;

    if (mjd != lmjd)
    {
        int32_t a, b, c, d, e, z, alpha;
        double f;

        lmjd = mjd;
        mjd += 2400001.;
        z = (int32_t)mjd;
        f = mjd - z;

        if (z<2299161)
            a = z;
        else
        {
            alpha = (int32_t)((z - 1867216.25)/36524.25);
            a = z +1 + alpha - (int32_t)(alpha/4);
        }

        b = a + 1524;
        c = (int32_t)((b - 122.1)/365.25);
        d = (int32_t)(365.25*c);
        e = (int32_t)((b - d)/30.6001);

        lday = b - d - (int32_t)(30.6001 * e) + f;
        if (e < 14)
            lmonth = e - 1;
        else
            lmonth = e - 13;
        if (lmonth > 2)
            lyear = c - 4716;
        else
            lyear = c - 4715;
        ldoy = (int32_t)((275 * lmonth)/9) - (2-isleap(lyear))*(int32_t)((lmonth+9)/12) + lday - 30;
    }

    year = lyear;
    month = lmonth;
    day = lday;
    doy  = ldoy;
    return 0;
}

double cal2mjd	(	int32_t	year,
		int32_t	month,
		int32_t	day,
		int32_t	hour,
		int32_t	minute,
		int32_t	second,
		int32_t	nsecond
	)

Calendar representation to Modified Julian Day - full.

Convert a full calendar representation of date and time to MJD. If month is given as zero, then day will be taken as day of the year.

Parameters

year	Full representation of year.
month	Calendar month, or zero.
day	Day of month if 1 <= month <=12, otherwise day of year.
hour	Hour of day (0-23)
minute	Minute of day (0-59)
second	Second of day (0-59)
nsecond	Nanosecond of day (0-999999999)

Returns

Modified Julian Day

{
    double mjd;
    calstruc date;

    date.year = year;
    date.month = month;
    if (month == 0)
    {
        date.dom = 0;
        date.doy = day;
    }
    else
    {
        date.dom = day;
        date.doy = 0;
    }
    date.hour = hour;
    date.minute = minute;
    date.second = second;
    date.nsecond = nsecond;

    mjd = cal2mjd(date);

    return mjd;
}

double cal2mjd

(

double

year

)

Calendar representation YYYY.ffff to Modified Julian Day - overloaded.

Convert a shortened calendar representation of date to MJD.

Parameters

year	Full representation of decimal year.

Returns

Modified Julian Day

{
    double dyear;
    double dday;

    dday = 365. * modf(year, &dyear);

    return cal2mjd(static_cast<int32_t>(dyear), 0 , dday);
}

double cal2mjd	(	int32_t	year,
		double	dayOfYear
	)

Calendar representation YYYY,DDD.ffff to Modified Julian Day - overloaded.

Convert a shortened calendar representation of date to MJD. Day argument is day of year.

Parameters

year	Full representation of year.
dayOfYear	day of year.

Returns

Modified Julian Day

{
    return cal2mjd(year, 0 , dayOfYear);
}

double cal2mjd	(	int32_t	year,
		int32_t	month,
		double	day
	)

Calendar representation to Modified Julian Day - shortened.

Convert a shortened calendar representation of date to MJD. Time is taken from the fractional part of the day. If month is given as zero, then day will be taken as day of the year.

Parameters

year	Full representation of year.
month	Calendar month, or zero.
day	Day of month if 1 <= month <=12, otherwise day of year.

Returns

Modified Julian Day

{
    double mjd;
    calstruc date;

    date.year = year;
    date.month = month;
    if (month == 0)
    {
        date.dom = 0;
        date.doy = 1;
    }
    else
    {
        date.dom = 1;
        date.doy = 0;
    }
    date.hour = date.minute = date.second = date.nsecond = 0;

    mjd = cal2mjd(date);
    // Add day-1 because absolute date starts at day 0, but JD and DOM start at 1
    mjd += day - 1.;

    return mjd;
}

double cal2mjd

(

calstruc

date

)

Calendar representation to Modified Julian Day - structure.

Convert a full calendar representation of date and time to MJD. If month is given as zero, then day will be taken as day of the year.

Parameters

date	Full representation of date and time in calstruc.

Returns

Modified Julian Day

{
    double mjd;
    int32_t a, b;

    if (date.year < -4712)
        return (-2400001.);

    switch (date.month)
    {
    case 0:
        ++date.month;
    case 1:
    case 2:
        date.year--;
        date.month += 12;
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
    case 11:
    case 12:
        a = (int32_t)(date.year / 100);
        if ((date.year > 1582) || (date.year == 1582 && date.month > 10) || (date.year == 1582 && date.month == 10 && date.dom > 4))
            b = 2 - a + (int32_t)(a/4);
        else
            b = 0;
        break;
    default:
        return (-2400001.);
    }
    if (date.dom)
    {
        mjd = (int32_t)(365.25 * (date.year+4716)) + (int32_t)(30.6001*(date.month+1)) + date.dom + b - 2401525.;
    }
    else
    {
        mjd = (int32_t)(365.25 * (date.year+4716)) + (int32_t)(30.6001*(date.month+1)) + date.doy + b - 2401525.;
    }
    mjd += ((date.hour + (date.minute + (date.second + date.nsecond / 1e9) / 60.) / 60.) / 24.);

    return (mjd);
}

double gregorianToModJulianDate	(	int32_t	year,
		int32_t	month,
		int32_t	day,
		int32_t	hour,
		int32_t	minute,
		double	second
	)

Get Modified Julian Date from Gregorian Calendar Date in UTC

Parameters

year
month
day
hour
minute
second	(for high precision mjd)

Returns

mjd (Modified Julian Date)

{

    double dayFraction = hour/24.0 + minute/(1440.) + second/(86400.);
    double mjd = cal2mjd(year, month, day + dayFraction); //cal2mjd2
    return mjd;
}

double utc2jcentt

(

double

mjd

)

TT Julian Century.

Caculate the number of centuries since J2000, Terrestrial Time, for the provided date.

Parameters

mjd	Date in Modified Julian Day.

Returns

Julian century in decimal form, otherwise negative error.

{
    static double lmjd=0.;
    static double lcalc=0.;

    if (mjd != lmjd)
    {
        double tt = utc2tt(mjd);
        if (tt <= 0.)
        {
            lcalc = tt;
        }
        else
        {
            lcalc = (tt - 51544.5) / 36525.;
            lmjd = mjd;
        }
    }
    return (lcalc);
}

double utc2jcenut1

(

double

mjd

)

UT1 Julian Century.

Caculate the number of centuries since J2000, UT1, for the provided date.

Parameters

mjd	Date in Modified Julian Day.

Returns

Julian century in decimal form.

{
    static double lmjd=0.;
    static double lcalc=0.;

    if (mjd != lmjd)
    {
        lcalc = (utc2ut1(mjd)-51544.5) / 36525.;
        lmjd = mjd;
    }
    return (lcalc);
}

rvector utc2nuts

(

double

mjd

)

Nutation values.

Calculate the nutation values from the JPL Ephemeris for the provided UTC date. Values are in order: Psi, Epsilon, dPsi, dEpsilon. Units are radians and radians/second.

Parameters

mjd	UTC in Modified Julian Day.

Returns

Nutation values in an rvector.

{
    static double lmjd=0.;
    static uvector lcalc={{{0.,0.,0.},0.}};

    if (mjd != lmjd)
    {
        double tt = utc2tt(mjd);
        if (tt > 0.)
        {
            jplnut(tt,(double *)&lcalc.a4);
            lmjd = mjd;
        }
    }
    return (lcalc.r);
}

double utc2dpsi

(

double

mjd

)

Nutation Delta Psi value.

Calculate the Delta Psi value (nutation in longitude), for use in the Nutation matrix, for the provided UTC date.

Parameters

mjd	UTC in Modified Julian Day.

Returns

Delta Psi in radians.

{
    static double lmjd=0.;
    static double lcalc=0.;
    rvector nuts;

    if (mjd != lmjd)
    {
        nuts = utc2nuts(mjd);
        lcalc = nuts.col[0];
        lmjd = mjd;
    }
    return (lcalc);
}

double utc2depsilon

(

double

mjd

)

Nutation Delta Epsilon value.

Calculate the Delta Psi value (nutation in obliquity), for use in the Nutation matrix, for the provided UTC date.

Parameters

mjd	UTC in Modified Julian Day.

Returns

Delta Psi in radians.longitudilon

{
    static double lmjd=0.;
    static double lcalc=0.;
    rvector nuts;

    if (mjd != lmjd)
    {
        nuts = utc2nuts(mjd);
        lcalc = nuts.col[1];
        lmjd = mjd;
    }
    return (lcalc);
}

double utc2epsilon

(

double

mjd

)

Nutation Epsilon value.

Calculate the Epsilon value (obliquity of the ecliptic), for use in the Nutation matrix, for the provided UTC date.

Parameters

mjd	UTC in Modified Julian Day.

Returns

Epsilon in radians.

{
    // Vallado, et al, AAS-06_134, eq. 17
    static double lmjd=0.;
    static double lcalc=0.;
    double jcen;

    if (mjd != lmjd)
    {
        jcen = utc2jcentt(mjd);
        lcalc = DAS2R*(84381.406+jcen*(-46.836769+jcen*(-.0001831+jcen*(0.0020034+jcen*(-0.000000576+jcen*(-0.0000000434))))));
        lcalc = ranrm(lcalc);
        lmjd = mjd;
    }
    return (lcalc);
}

double utc2L

(

double

mjd

)

Nutation L value.

Calculate the L value, for use in the Nutation matrix, for the provided UTC date.

Parameters

mjd	UTC in Modified Julian Day.

Returns

L in radians.

{
    static double lmjd=0.;
    static double lcalc=0.;
    double jcen;

    if (mjd != lmjd)
    {
        jcen = utc2jcentt(mjd);
        lcalc = DAS2R*(485868.249036+jcen*(1717915923.2178+jcen*(31.8792+jcen*(.051635+jcen*(-.0002447)))));
        lcalc = ranrm(lcalc);
        lmjd = mjd;
    }
    return (lcalc);
}

double utc2Lp

(

double

mjd

)

Nutation L prime value.

Calculate the L prime value, for use in the Nutation matrix, for the provided UTC date.

Parameters

mjd	UTC in Modified Julian Day.

Returns

L prime in radians.

{
    static double lmjd=0.;
    static double lcalc=0.;
    double jcen;

    if (mjd != lmjd)
    {
        jcen = utc2jcentt(mjd);
        lcalc = DAS2R*(1287104.79305+jcen*(129596581.0481+jcen*(-.5532+jcen*(.000136+jcen*(-.00001149)))));
        lcalc = ranrm(lcalc);
        lmjd = mjd;
    }
    return (lcalc);
}

double utc2F

(

double

mjd

)

Nutation F value.

Calculate the F value, for use in the Nutation matrix, for the provided UTC date.

Parameters

mjd	UTC in Modified Julian Day.

Returns

F in radians.

{
    static double lmjd=0.;
    static double lcalc=0.;
    double jcen;

    if (mjd != lmjd)
    {
        jcen = utc2jcentt(mjd);
        lcalc = DAS2R*(335779.526232+jcen*(1739527262.8478+jcen*(-12.7512+jcen*(-.001037+jcen*(.00000417)))));
        lcalc = ranrm(lcalc);
        lmjd = mjd;
    }
    return (lcalc);
}

double utc2D

(

double

mjd

)

Nutation D value.

Calculate the D value, for use in the Nutation matrix, for the provided UTC date.

Parameters

mjd	UTC in Modified Julian Day.

Returns

D in radians.

{
    static double lmjd=0.;
    static double lcalc=0.;
    double jcen;

    if (mjd != lmjd)
    {
        jcen = utc2jcentt(mjd);
        lcalc = DAS2R*(1072260.70369+jcen*(1602961601.209+jcen*(-6.3706+jcen*(.006593+jcen*(-.00003169)))));
        lcalc = ranrm(lcalc);
        lmjd = mjd;
    }
    return (lcalc);
}

double utc2omega

(

double

mjd

)

Nutation omega value.

Calculate the omega value, for use in the Nutation matrix, for the provided UTC date.

Parameters

mjd	UTC in Modified Julian Day.

Returns

Omega in radians.

{
    static double lmjd=0.;
    static double lcalc=0.;
    double jcen;

    if (mjd != lmjd)
    {
        jcen = utc2jcentt(mjd);
        lcalc = DAS2R*(450160.398036+jcen*(-6962890.5431+jcen*(7.4722+jcen*(.007702+jcen*(-.00005939)))));
        lcalc = ranrm(lcalc);
        lmjd = mjd;
    }
    return (lcalc);
}

double utc2zeta

(

double

utc

)

Precession zeta value.

Calculate angle zeta used in the calculation of Precession, re. Capitaine, et. al, A&A, 412, 567-586 (2003) Expressions for IAU 2000 precession quantities Equation 40

Parameters

utc	Epoch in Modified Julian Day.

Returns

Zeta in radians

{
    double ttc = utc2jcentt(utc);
    //  double zeta = (2.650545 + ttc*(2306.083227 + ttc*(0.2988499 + ttc*(0.01801828 + ttc*(-0.000005971 + ttc*(0.0000003173))))))*DAS2R;
    // Vallado, eqn. 3-88
    double zeta = (ttc*(2306.2181 + ttc*(0.30188 + ttc*(0.017998))))*DAS2R;
    return zeta;
}

double utc2z

(

double

utc

)

Precession z value.

Calculate angle z used in the calculation of Precession, re. Capitaine, et. al, A&A, 412, 567-586 (2003) Expressions for IAU 2000 precession quantities Equation 40

Parameters

utc	Epoch in Modified Julian Day.

Returns

Zeta in radians

{
    double ttc = utc2jcentt(utc);
    //  double z = (-2.650545 + ttc*(2306.077181 + ttc*(1.0927348 + ttc*(0.01826837 + ttc*(-0.000028596 + ttc*(0.0000002904))))))*DAS2R;
    // Vallado, eqn. 3-88
    double z = (ttc*(2306.2181 + ttc*(1.09468 + ttc*(0.018203))))*DAS2R;
    return z;
}

double utc2theta

(

double

utc

)

Precession theta value.

Calculate angle theta used in the calculation of Precession, re. Capitaine, et. al, A&A, 412, 567-586 (2003) Expressions for IAU 2000 precession quantities Equation 40

Parameters

utc	Epoch in Modified Julian Day.

Returns

Zeta in radians

{
    double ttc = utc2jcentt(utc);
    //  double theta = ttc*(2004.191903 + ttc*(-0.4294934 + ttc*(-0.04182264 + ttc*(-0.000007089 + ttc*(-0.0000001274)))))*DAS2R;
    // Vallado, eqn. 3-88
    double theta = ttc*(2004.3109 + ttc*(-0.42665 + ttc*(-0.041833)))*DAS2R;
    return theta;
}

double utc2dut1

(

double

mjd

)

Calculate DUT1.

Calculate DUT1 = UT1 - UTC, based on lookup in IERS Bulletin A.

Parameters

mjd	UTC in Modified Julian Day.

Returns

DUT1 in Modified Julian Day, otherwise 0.

{
    static double lmjd=0.;
    static double lcalc = 0.;
    double frac;
    //  uint32_t mjdi;
    uint32_t iersidx;

    if (mjd != lmjd)
    {
        if (load_iers() && iers.size() > 2)
        {
            if ((uint32_t)mjd >= iersbase)
            {
                if ((iersidx=(uint32_t)mjd-iersbase) > iers.size())
                {
                    iersidx = iers.size() - 2;
                }
            }
            else
            {
                iersidx = 0;
            }
            //          mjdi = (uint32_t)mjd;
            frac = mjd - (uint32_t)mjd;
            lcalc = ((frac*iers[1+iersidx].dutc+(1.-frac)*iers[iersidx].dutc)/86400.);
            lmjd = mjd;
        }
        else
            lcalc = 0.;
    }
    return (lcalc);
}

double utc2ut1

(

double

mjd

)

Convert UTC to UT1.

Convert Coordinated Universal Time to Universal Time by correcting for the offset between them at the given time. Table of DUT1 is first initialized from disk if it hasn't yet been.

Parameters

mjd	UTC in Modified Julian Day.

Returns

UTC1 in Modified Julian Day, otherwise 0.

{
    static double lmjd=0.;
    static double lut=0.;

    if (mjd != lmjd)
    {
        if (load_iers())
        {
            lut = mjd + utc2dut1(mjd);
            lmjd = mjd;
        }
        else
            lut = 0.;
    }
    return (lut);
}

double julcen

(

double

mjd

)

Julian Century.

Convert time supplied in Modified Julian Day to the Julian Century.

Parameters

mjd	Time in Modified Julian Day.

Returns

Decimal century.

{
    return ((mjd - 51544.5) / 36525.);
}

double utc2tdb

(

double

mjd

)

Convert UTC to TDB.

Convert Coordinated Universal Time to Barycentric Dynamical Time by correcting for the mean variations as a function of Julian days since 4713 BC Jan 1.5.

Parameters

mjd	UTC in Modified Julian Day.

Returns

TDB in Modified Julian Day, otherwise 0.

{
    static double lmjd=0.;
    static double ltdb=0.;
    double tt, g;

    if (mjd != lmjd)
    {
        tt = utc2tt(mjd);
        if (tt > 0.)
        {
            g = 6.2400756746 + .0172019703436*(mjd-51544.5);
            ltdb = (tt + (.001658*sin(g)+.000014*sin(2*g))/86400.);
            lmjd = mjd;
        }
    }
    return (ltdb);
}

double tt2utc

(

double

mjd

)

Convert TT to UTC.

Convert Terrestrial Dynamical Time to Coordinated Universal Time by correcting for the appropriate number of Leap Seconds. Leap Second table is first initialized from disk if it hasn't yet been.

Parameters

mjd	TT in Modified Julian Day.

Returns

UTC in Modified Julian Day, otherwise 0.

{
    uint32_t iersidx;
    int32_t iretn;

    if ((iretn=load_iers()) && iers.size() > 1)
    {
        if ((uint32_t)mjd >= iersbase)
        {
            if ((iersidx=(uint32_t)mjd-iersbase) > iers.size())
            {
                iersidx = iers.size() - 1;
            }
        }
        else
        {
            iersidx = 0;
            return ((double)iretn);
        }
        return (mjd-(32.184+iers[iersidx].ls)/86400.);
    }
    else
        return (0.);
}

double utc2tt

(

double

mjd

)

Convert UTC to TT.

Convert Coordinated Universal Time to Terrestrial Dynamical Time by correcting for the appropriate number of Leap Seconds. Leap Second table is first initialized from disk if it hasn't yet been.

Parameters

mjd	UTC in Modified Julian Day.

Returns

TT in Modified Julian Day, otherwise negative error

{
    static double lmjd=0.;
    static double ltt=0.;
    uint32_t iersidx=0;
    int32_t iretn;

    if (mjd != lmjd)
    {
        if ((iretn=load_iers()) && iers.size() > 1)
        {
            if ((uint32_t)mjd >= iersbase)
            {
                if ((iersidx=(uint32_t)mjd-iersbase) > iers.size())
                {
                    iersidx = iers.size() - 1;
                }
            }
            else
            {
                iersidx = 0;
            }
            ltt = (mjd+(32.184+iers[iersidx].ls)/86400.);
            lmjd = mjd;
            return (ltt);
        }
        else
        {
            return ((double)iretn);
        }
    }
    return (ltt);
}

double utc2gps

(

double

utc

)

Convert UTC to GPS.

Convert Coordinated Universal Time to GPS Time, correcting for the appropriate number of leap seconds. Leap Second table is first initialized from disk if it hasn't yet been.

Parameters

utc	UTC expressed in Modified Julian Days

Returns

GPS Time expressed in Modified Julian Days, otherwise negative error

{
    double gps;

    if ((gps=utc2tt(utc)) <= 0.)
    {
        return (gps);
    }

    gps -= 51.184 / 86400.;

    return (gps);
}

double gps2utc

(

double

gps

)

Convert GPS to UTC.

Convert GPS Time to Coordinated Universal Time, correcting for the appropriate number of leap seconds. Leap Second table is first initialized from disk if it hasn't yet been.

Parameters

gps	GPS Time expressed in Modified Julian Days

Returns

UTC expressed in Modified Julian Days, otherwise 0.

{
    double utc;

    gps += 51.184 / 86400.;

    if ((utc=tt2utc(gps)) <= 0.)
    {
        return (utc);
    }

    return (utc);
}

void gps2week	(	double	gps,
		uint32_t &	week,
		double &	seconds
	)

GPS Weeks and Seconds from GPS time.

Calculate the appropriate GPS week and remaining seconds from the provided GPS time.

Parameters

gps	GPS time expressed as Modified Julian Day
week	Pointer to the returned GPS week.
seconds	Ponter to the returned GPS seconds.

{
    double elapsed;

    elapsed = gps - 44244.;
    week = (uint32_t)(elapsed / 7.);
    seconds = 86400. * (elapsed - week * 7.);
    //  *week %= 1024;
}

double week2gps	(	uint32_t	week,
		double	seconds
	)

GPS Time from GPS Week and Seconds.

Calculate the appropriate GPS Time from the provided GPS Week and Seconds.

Parameters

week	GPS Week.
seconds	GPS Seconds.

Returns

GPS Time as Modified Julian Day.

{
    double elapsed;

    elapsed = 44244. + week * 7. + seconds / 86400.;

    return elapsed;
}

double mjd2year

(

double

mjd

)

Year from MJD.

Return the Decimal Year for the provided MJD

Parameters

mjd	Modified Julian Data

Returns

Decimal year.

{
    double day, doy, dyear;
    int32_t month, year;

    mjd2ymd(mjd,year,month,day,doy);
    dyear = year + (doy-1) / (365.+isleap(year));
    return (dyear);
}

double mjd2doy

(

double

mjd

)

Day of Year from MJD.

Return the Decimal Day of Year for the provided MJD

Parameters

mjd	Modified Julian Data

Returns

Decimal doy.

{
    double day, doy;
    int32_t month, year;

    mjd2ymd(mjd,year,month,day,doy);
    return (doy);
}

double utc2era

(

double

mjd

)

Earth Rotation Angle.

Calculate the Earth Rotation Angle for a given Earth Rotation Time based on the provided UTC.

Parameters

mjd	Coordinated Universal Time as Modified Julian Day.

Returns

Earth Rotation Angle, theta, in radians.

{
    static double lmjd=0.;
    static double ltheta=0.;
    double ut1;

    if (mjd != lmjd)
    {
        ut1 = utc2ut1(mjd);
        ltheta = D2PI * (.779057273264 + 1.00273781191135448 * (ut1 - 51544.5));
        //        ltheta = ranrm(ltheta);
    }

    return (ltheta);
}

double utc2gast

(

double

mjd

)

UTC to GAST.

Convert current UTC to Greenwhich Apparent Sidereal Time. Accounts for nutations.

Parameters

mjd	UTC as Modified Julian Day

Returns

GAST as Modified Julian Day

{
    static double lmjd=0.;
    static double lgast=0.;
    double omega, F, D;

    if (mjd != lmjd)
    {
        omega = utc2omega(mjd);
        F = utc2F(mjd);
        D = utc2D(mjd);
        lgast = utc2gmst1982(mjd) + utc2dpsi(mjd) * cos(utc2epsilon(mjd));
        lgast += DAS2R * .00264096 * sin(omega);
        lgast += DAS2R * .00006352 * sin(2.*omega);
        lgast += DAS2R * .00001175 * sin(2.*F - 2.*D + 3.*omega);
        lgast += DAS2R * .00001121 * sin(2.*F - 2.*D + omega);
        lgast = ranrm(lgast);
        lmjd = mjd;
    }
    return (lgast);
}

double utc2gmst1982

(

double

mjd

)

UTC (Modified Julian Day) to GMST.

Convert current UT to Greenwhich Mean Sidereal Time

Parameters

mjd	UT as Modified Julian Day

Returns

GMST as radians

{
    static double lmjd=0.;
    static double lcalc=0.;
    double jcen;

    if (mjd != lmjd)
    {
        jcen = utc2jcentt(mjd);
        lcalc = utc2era(mjd) + DS2R*(.014506+jcen*(4612.156534+jcen*(1.3915817+jcen*(-.00000044+jcen*(-.000029956+jcen*(-.0000000368))))))/15.;
        lcalc = ranrm(lcalc);
        lmjd = mjd;
    }

    return (lcalc);
}

double utc2gmst2000

(

double

utc

)

{
    static double lutc=0.;
    static double lgmst = 0.;
    double tt;

    if (utc != lutc)
    {
        //      ut1 = utc2ut1(utc);
        tt = utc2jcentt(utc);
        lgmst = 24110.54841 + 8640184.812866 * utc2jcenut1(utc) + tt * tt * (0.093104 + tt * (-0.0000062));
        lgmst = ranrm(lgmst);
    }

    return lgmst;
}

double ranrm

(

double

angle

)

{
    double result;

    result = fmod(angle,D2PI);

    return (result >= 0.)?result:result+D2PI;
}

int16_t isleap

(

int32_t

year

)

Check for Leap year.

Check whether the specified year (Gregorian or Julian calendar) is a Leap year.

Parameters

year	Year to check

Returns

0 if not a Leap year, 1 if a Leap year

{
    if (!(year % 4))
    {
        if (!(year%100))
        {
            if (!(year%400))
            {
                return (1);
            }
            else
            {
                return 0;
            }
        }
        else
        {
            return 1;
        }
    }
    else
    {
        return 0;
    }
}

int32_t load_iers

(

)

Load IERS Polar Motion, UT1-UTC, Leap Seconds.

Allocate and load array for storing data from IERS file. Each record includes the MJD, the Polar Motion for X and Y in radians, UT1-UTC in seconds of time, and the number of Leap Seconds since the creation of TAI in 1958. The following are then defined:

• TT = TAI +32.184
• TAI = UTC + Leap_Seconds
• UT1 = UTC + (UT1-UTC)

  Returns

  Number of records.

{
    FILE *fdes;
    iersstruc tiers;

    if (iers.size() == 0)
    {
        string fname;
        int32_t iretn = get_cosmosresources(fname);
        if (iretn < 0)
        {
            return iretn;
        }
        fname += "/general/iers_pm_dut_ls.txt";
        if ((fdes=fopen(fname.c_str(),"r")) != NULL)
        {
            char data[100];
            while (fgets(data,100,fdes))
            {
                sscanf(data,"%u %lg %lg %lg %u",&tiers.mjd,&tiers.pmx,&tiers.pmy,&tiers.dutc,&tiers.ls);
                iers.push_back(tiers);
            }
            fclose(fdes);
        }
        if (iers.size())
            iersbase = iers[0].mjd;
    }
    return (iers.size());
}

int32_t leap_seconds

(

double

mjd

)

Leap Seconds.

Returns number of leap seconds for provided Modified Julian Day.

Parameters

mjd	Provided time.

Returns

Number of leap seconds, or 0.

{
    uint32_t iersidx;

    if (load_iers() && iers.size() > 1)
    {
        if ((uint32_t)mjd >= iersbase)
        {
            if ((iersidx=(uint32_t)mjd-iersbase) > iers.size())
            {
                iersidx = iers.size() - 1;
            }
        }
        else
        {
            iersidx = 0;
        }
        return (iers[iersidx].ls);
    }
    else
        return 0;
}

cvector polar_motion

(

double

mjd

)

Polar motion.

Returns polar motion in radians for provided Modified Julian Day.

Parameters

mjd	Provided time.

Returns

Polar motion in rvector.

{
    cvector pm;
    double frac;
    //  uint32_t mjdi;
    uint32_t iersidx;

    pm = cv_zero();
    if (load_iers() && iers.size() > 2)
    {
        if ((uint32_t)mjd >= iersbase)
        {
            if ((iersidx=(uint32_t)mjd-iersbase) > iers.size())
            {
                iersidx = iers.size() - 2;
            }
        }
        else
        {
            iersidx = 0;
        }
        //      mjdi = (uint32_t)mjd;
        frac = mjd - (uint32_t)mjd;
        pm = cv_zero();
        pm.x = frac*iers[1+iersidx].pmx+(1.-frac)*iers[iersidx].pmx;
        pm.y = frac*iers[1+iersidx].pmy+(1.-frac)*iers[iersidx].pmy;
    }

    return (pm);
}

string utc2unixdate

(

double

utc

)

Time for setting unix date.

Represent the given UTC on a format appropriate for setting Unix date format: MMDDhhmmYY.ss

Parameters

utc	Coordinated Universal Time expressed in Modified Julian Days.

Returns

C++ String containing the Unix date.

{
    char buffer[25];
    int32_t iy=0, im=0, id=0, ihh, imm, iss;
    double fd=0.;

    mjd2ymd(utc, iy, im, fd);
    id = static_cast <int32_t>(fd);
    fd -= id;
    ihh = static_cast <int32_t>(24 * fd);
    fd -= ihh / 24.;
    imm = static_cast <int32_t>(1440 * fd);
    fd -= imm / 1440.;
    iss = static_cast <int32_t>(86400 * fd + .5);
    sprintf(buffer, "%02d%02d%02d%02d%02d.%02d", im, id, ihh, imm, iy, iss);

    return string(buffer);
}

string utc2iso8601

(

double

utc

)

ISO 8601 version of time.

Represent the given UTC as an extended calendar format ISO 8601 string in the format: YYYY-MM-DDTHH:MM:SS

Parameters

utc	Coordinated Universal Time expressed in Modified Julian Days.

Returns

C++ String containing the ISO 8601 date.

{
    char buffer[25];
    int32_t iy=0, im=0, id=0, ihh, imm, iss;
    double fd=0.;

    mjd2ymd(utc, iy, im, fd);
    id = (int32_t)fd;
    fd -= id;
    ihh = (int32_t)(24 * fd);
    fd -= ihh / 24.;
    imm = (int32_t)(1440 * fd);
    fd -= imm / 1440.;
    iss = (int32_t)(86400 * fd);
    sprintf(buffer, "%04d-%02d-%02dT%02d:%02d:%02d", iy, im, id, ihh, imm, iss);

    return string(buffer);
}

double iso86012utc

(

string

date

)

{
    double utc = 0.;
    int32_t iy=0, im=0, id=0, ihh, imm, iss;

    sscanf(date.c_str(), "%d-%d-%dT%d:%d:%d", &iy, &im, &id, &ihh, &imm, &iss);
    utc = cal2mjd(iy, im, id, ihh, imm, iss);
    return utc;
}

string mjd2iso8601

(

double

mjd

)

                              {
    return utc2iso8601(mjd);
}

int32_t dayFraction2hms	(	double	dayFraction,
		int32_t *	hour,
		int32_t *	minute,
		int32_t *	second
	)

Convert Modified Julian Date to Time of day (hour, minute, second.fff)

Parameters

dayFraction
hour	Pointer to return Hour of the day
minute	Pointer to return Minute of the day
second	Pointer to return Second of the day (decimal)

Returns

0 or negative error.

{
    double secs;
    *hour = (int32_t)(24. * dayFraction);
    dayFraction -= *hour / 24.;
    *minute = (int32_t)(1440. * dayFraction);
    dayFraction -= *minute / 1440.;
    secs = (86400. * dayFraction);
    //    double secondOfMinute = (86400. * dayFraction);
    *second = (int32_t)round(secs);

    // don't let seconds be 60
    if (*second == 60.){
        *second = 0;
        *minute = *minute + 1;
    }

    // don't let minutes be 60
    if (*minute == 60){
        *minute = 0;
        *hour = *hour + 1;
    }

    return 0;
}

int32_t mjdToGregorian	(	double	mjd,
		int32_t &	year,
		int32_t &	month,
		int32_t &	day,
		int32_t &	hour,
		int32_t &	minute,
		int32_t &	second
	)

Convert Modified Julian Date to standard Gregorian Date-Time

Parameters

mjd	(Modified Julian Days)
year	Pointer to return Calendar Year
month	Pointer to return Calendar Month
day	Pointer to return Decimal Day of the Month
hour	Pointer to return Hour of the day
minute	Pointer to return Minute of the day
second	Pointer to return Second of the day (decimal)

Returns

0 or negative error.

{

    //    double dayFraction;
    //    mjd2ymdf(mjd,year,month,&dayFraction);
    //    *day = (int)dayFraction;

    //    int j;
    calstruc cal = mjd2cal(mjd); //, year, month, day, &dayFraction, &j);
    year = cal.year;
    month = cal.month;
    day = cal.dom;
    hour = cal.hour;
    minute = cal.minute;
    second = cal.second;

    // now remove the day part and keep the fraction only
    //    dayFraction --;
    //    dayFraction2hms(dayFraction,hour,minute,second);
    return 0;
}

string mjdToGregorian

(

double

mjd

)

Convert Modified Julian Date to international standard Gregorian Date-Time in the format: YYYY-MM-DD HH:MM:SS (ex. 2014-09-15 12:00:00) (previously this function was named mjd2human)

Parameters

mjd	Time in Modified Julian Days

Returns

gregorianDateTime (YYYY-MM-DD HH:MM:SS)

{
    char gregorianDateTime[25];
    int year=0, month=0, day=0;
    int hour=0, minute=0, second=0;

    mjdToGregorian(mjd, year, month, day, hour, minute, second);

    sprintf(gregorianDateTime, "%04d-%02d-%02d %02d:%02d:%02d",
            year, month, day,
            hour, minute, second);

    return string(gregorianDateTime);
}

string mjdToGregorianFormat

(

double

mjd

)

Convert Modified Julian Date to international standard Gregorian Date-Time in the format: YYYY-MM-DDTHHMMSS (ex. 2014-09-15T120000)

Parameters

mjd	Time in Modified Julian Days

Returns

gregorianDateTime in the format (YYYY-MM-DDTHHMMSS)

{
    char gregorianDateTime[25];
    int year=0, month=0, day=0;
    int hour=0, minute=0, second=0;

    mjdToGregorian(mjd, year, month, day, hour, minute, second);

    sprintf(gregorianDateTime, "%04d-%02d-%02dT%02d%02d%02d",
            year, month, day,
            hour, minute, second);

    return string(gregorianDateTime);
}

string mjdToGregorianDDMMMYYYY

(

double

mjd

)

Convert Modified Julian Date to US standard Gregorian Date-Time with 3-letter month format: DD-MMM-YYYY HH:MM:SS (ex. 15-SEP-2014 12:00:00) (previously this function was named mjd2human2)

Parameters

mjd	Time in Modified Julian Days

Returns

gregorianDateTime (YYYY-MM-DD HH:MM:SS)

{
    char gregorianDateTime[25];
    int year=0, month=0, day=0, hour=0, minute=0, second=0;
    //    double fd=0.; //?? is this fraction of day

    static const char month_name[][4] = {
        "JAN", "FEB", "MAR", "APR", "MAY", "JUN",
        "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"
    };

    //mjd2cal(mjd, &year, &month, &day, &fd, &j);

    mjdToGregorian(mjd, year, month, day, hour, minute, second);

    //    hours = (int)(24 * fd);
    //    fd -= hours / 24.;
    //    minutes = (int)(1440 * fd);
    //    fd -= minutes / 1440.;
    //    seconds = (86400 * fd);
    //    int int_seconds = (int)round(seconds);
    sprintf(gregorianDateTime, "%02d-%3s-%04d %02d:%02d:%02d",
            day, month_name[month-1], year,
            hour, minute, second);

    return string(gregorianDateTime);
}

string mjdToGregorianDDMmmYYYY

(

double

mjd

)

Convert Modified Julian Date to US standard Gregorian Date-Time with 3-letter month format in small caps: DD mmm YYYY HH:MM:SS.FFF (15 Sep 2014 12:00:00.000) Used for STK remote (previously this function was named mjd2human3)

Parameters

mjd	Time in Modified Julian Days

Returns

gregorianDateTime (YYYY-MM-DD HH:MM:SS)

{
    char gregorianDateTime[50];
    int year=0, month=0, day=0, hour=0, minute=0, second=0;
    int msec = 0;
    //    double fd=0.;

    static const char month_name[][4] = {
        "Jan", "Feb", "Mar", "Apr", "May", "Jun",
        "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
    };

    //    mjd2cal(mjd, &year, &month, &day, &fd, &j);
    mjdToGregorian(mjd, year, month, day, hour, minute, second);
    //    hh = (int)(24 * fd);
    //    fd -= hh / 24.;
    //    min = (int)(1440 * fd);
    //    fd -= min / 1440.;
    //    sec = (int)(86400 * fd);
    //    fd -= sec / 86400.;
    //    msec = (int)(86400*1000 * fd);
    sprintf(gregorianDateTime, "%02d %3s %04d %02d:%02d:%02d.%03d",
            day, month_name[month-1], year,
            hour, minute, second, msec);

    return string(gregorianDateTime);
}

string seconds2DDHHMMSS

(

double

elapsed_seconds

)

Convert Elapsed Time in Seconds to Human Readable Format (used for GPS simulator)

UTC string in the format: DD HH:MM:SS

Parameters

elapsed_seconds

Returns

C++ String containing human readable formated date.

                                               {

    char buffer[50];

    if (elapsed_seconds < 0){
        return "invalid time";
    }

    double days = elapsed_seconds/86400.;       // convert to elapsed days
    int day    = int(days);                     // get the day number
    double fd  = days-day;                    // get the day fraction
    /*
    temp       = elapsed_seconds - day * 86400; // get the seconds of the day

    int hour   = temp/3600.;                    // get the number of hours
    temp       = temp - hour*3600;              // take off the number of seconds of the hours run

    //int min  = ((elapsed_seconds) % 3600.)/60.;
    int min    = temp/60;                       // get the number of minutes

    //int sec  = (elapsed_seconds) % 60.;
    int sec    = temp - min*60;                 // get the number of seconds

    int msec    = (temp - sec)*1000;            // get the number of miliseconds
*/

    int hour = (int)(24 * fd);
    fd -= hour / 24.;
    int min = (int)(1440 * fd);
    fd -= min / 1440.;
    int sec = (int)(86400 * fd);
    fd -= sec / 86400.;
    int msec = (int)round((86400*1000 * fd));

    if (msec == 1000){
        sec ++;
        msec = 0;
    }
    // specific format for SimGEN
    //sprintf(buffer,"%d %02d:%02d:%.2f", day, hour, min, sec);
    sprintf(buffer,"%02d:%02d:%02d.%03d", hour, min, sec, msec);
    return string(buffer);
}

double mjd2jd

(

double

mjd

)

Modified Julian Day to Julian Day.

Convert date in Modified Julian Day format to date in Julian Day format.

Parameters

mjd	Date in Modified Julian Day format.

Returns

Date in Julian Day format.

                          {
    return MJD2JD(mjd);
}

double jd2mjd

(

double

jd

)

Julian Day to Modified Julian Day.

Convert date in Julian Day format to date in Modified Julian Day format.

Parameters

jd	Date in Julian Day format.

Returns

Date in Modified Julian Day format.

                          {
    return JD2MJD(jd);
}

int32_t timed_countdown	(	int32_t	seconds,
		int32_t	step,
		string	message
	)

{
    ElapsedTime et;
    ElapsedTime set;

    if (message.length())
    {
        printf("%s", message.c_str());
        fflush(stdout);
    }

    while (et.split() < seconds)
    {
        int32_t nextstep = static_cast <int32_t>((seconds - et.split()) / step);
        COSMOS_SLEEP((seconds - et.split()) - nextstep * step);
        printf("...%d", nextstep * step);
        fflush(stdout);
    }
    printf("\n");
    return 0;
}

int32_t mjdToGregorian	(	double	mjd,
		int32_t *	year,
		int32_t *	month,
		int32_t *	day,
		int32_t *	hour,
		int32_t *	minute,
		int32_t *	second
	)

int32_t mjd2tlef	(	double	mjd,
		string &	tle
	)

Convert mjd to the TLE epoch format.

                                          {
    char year_buffer[3], days_buffer[13];

    // Compute our year field.
    sprintf(year_buffer, "%2d", static_cast<int>(floor(mjd2year(mjd))) % 1000);

    // Compute our days field.
    sprintf(days_buffer, "%012.8f", mjd2doy(mjd));

    tle = string(year_buffer) + string(days_buffer);
    return 0;
}

double tt2tdb

(

double

mjd

)

double set_local_clock

(

double

utc_to

)

{
    int32_t iretn;
    double utc_from = currentmjd();
    double deltat = 86400.*(utc_to - utc_from);
//    printf("Set Local Clock %f\n", deltat);
    if (fabs(deltat) > 1.)
    {
        // Gross adjustment to system clock
#if defined(COSMOS_WIN_OS)
        SYSTEMTIME newtime;
        SetSystemTime(&newtime);
#else
        struct timeval newtime = utc2unix(utc_to);

        // TODO: check with Eric if this is the right way to set the time?
        iretn = settimeofday(&newtime, nullptr);
        if (iretn < 0)
        {
            return 0.;
        }
#endif
    }
    else
    {
        // Fine adjustment using adjtime()
        if (fabs(deltat) > .001)
        {
#if defined(COSMOS_WIN_OS)
            double newdelta;
            newdelta = deltat * 1e7;
            SetSystemTimeAdjustment(newdelta,false);
#else

            struct timeval newdelta, olddelta;
            newdelta.tv_sec = deltat;
            newdelta.tv_usec = 100000. * (deltat - newdelta.tv_sec) + .5;

            // adjust the time
            iretn = adjtime(&newdelta, &olddelta);
            return 0.;
#endif
        }

    }
    return deltat;
}