src/sct_io.c

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2007 by Aleksander Morgado Juez                         *
 *   scitime@aleksander_morgado.mm.st                                      *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU Library 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 General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU Library 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.             *
 ***************************************************************************/


#include "scitime.h"

int sct_set_jd (sct_time_ptr pElement, const double jd)
{
    SCT_ACCURACY accuracy;
    double mjd2000;
    //Correct value from JD to MJD2000
    mjd2000 = jd - SCT_JD_TO_J2000;
    //Get accuracy automatically
    accuracy = sct_get_accuracy_from_jd(jd);
    //Set MJD2000 value
    return sct_set_mjd2000_acc(pElement, mjd2000, accuracy);
}

int sct_set_jd_acc (sct_time_ptr pElement, \
    const double jd, const SCT_ACCURACY accuracy)
{
    double mjd2000;
    //Correct value from JD to MJD2000
    mjd2000 = jd - SCT_JD_TO_J2000;
    //Set MJD2000 value
    return sct_set_mjd2000_acc(pElement, mjd2000, accuracy);
}

int sct_set_mjd (sct_time_ptr pElement, const double mjd)
{
    double mjd2000;
    SCT_ACCURACY accuracy;
    //Correct value from MJD to MJD2000
    mjd2000 = mjd - SCT_MJD_TO_J2000;
    //Get accuracy automatically
    accuracy = sct_get_accuracy_from_jd(mjd);
    //Set MJD2000 value
    return sct_set_mjd2000_acc(pElement, mjd2000, accuracy);
}

int sct_set_mjd_acc (sct_time_ptr pElement, \
    const double mjd, const SCT_ACCURACY accuracy)
{
    double mjd2000;
    //Correct value from MJD to MJD2000
    mjd2000 = mjd - SCT_MJD_TO_J2000;
    //Set MJD2000 value
    return sct_set_mjd2000_acc(pElement, mjd2000, accuracy);
}

int sct_set_mjd2000 (sct_time_ptr pElement, const double mjd2000)
{
    SCT_ACCURACY accuracy;
    //Get accuracy automatically
    accuracy = sct_get_accuracy_from_jd(mjd2000);
    return sct_set_mjd2000_acc(pElement, mjd2000, accuracy);
}

int sct_set_mjd2000_acc (sct_time_ptr pElement, \
    const double mjd2000, const SCT_ACCURACY accuracy)
{
    double aux;

    //Check input pointer...
    if(pElement == NULL)
    {
        #ifdef SCT_DEBUG
            if(pElement == NULL)
            {
                fprintf(stderr, \
                    "[scitime:%s] >> Unable to get element!\n", __FUNCTION__);
            }
        #endif
        //Ko, invalid pointer!
        return SCT_RET_INVALID_PTR;
    }
    //Set integer days
    pElement->days = (long)mjd2000;
    if(mjd2000 < 0)
    {
        pElement->days--;
    }
    //Get aux double with seconds
    aux = (mjd2000-pElement->days)*86400.0;

    //Set integer seconds
    pElement->secs = (long)aux;

    //Set integer femtoseconds
    pElement->fsecs = (int64_t)((aux-pElement->secs)*SCT_FSECS_IN_SEC);

    //Set accuracy
    pElement->accuracy = accuracy;

    //Set status
    pElement->status = SCT_STATUS_OK;

    //Ok, no problem
    return SCT_RET_OK;
}


int sct_set_YMDHMSF( \
    sct_time_ptr pElement, \
    const unsigned int year, \
    const unsigned int month, \
    const unsigned int day, \
    const unsigned int hour, \
    const unsigned int minute, \
    const unsigned int second, \
    const u_int64_t femtosecond)
{
    double y;
    double m;
    double d;
    long jd;
    SCT_RET ret;

    //Check input values...
    //TODO!!!

    y = (double)year;
    m = (double)month,
    d = (double)day;

    // In the conversion from the Julian Calendar to the Gregorian 
    // Calendar the day after October 4, 1582 was October 15, 1582.

    // if the date is before October 15, 1582
    if(year < 1582 || \
        (year == 1582 && (month < 10 || (month == 10 && day < 15))))
    {
        jd = 1729777 + day + 367 * year \
            - ((long)(7 * ( y + 5001 + ((long)((m - 9) / 7))) / 4)) \
            + ((long)(275 * m / 9));
    }
    else   // after Oct 4, 1582 
    {
        jd = 1721029 + day + 367 * year \
            - ((long)(7 * (y + ((long)((m + 9) / 12))) / 4)) \
            - ((long)(3 * (((long)((y + (m - 9) / 7) / 100)) + 1) / 4)) \
            + ((long)(275 * m / 9));

        // catch century/non-400 non-leap years 
        if( (! (year % 100) && (year % 400) && month > 2 && month < 9) || 
            (!((year - 1) % 100) && ((year - 1) % 400) && month == 1) )
        {
            --jd;
        }
    }
    //Final adjustment
    jd--;

    //Set Y/M/D as a julian date epoch
    ret = sct_set_jd(pElement, ((double)(jd)+0.5)); //0.5 due to the JD offset
    if(ret != SCT_RET_OK)
    {
        return ret;
    }

    //Now, set H/M/S...
    pElement->secs = (hour * 3600) + (minute *60) + second;

    //Now, set F...
    pElement->fsecs = femtosecond;

    //Set accuracy
    pElement->accuracy = SCT_ACCURACY_FEMTOSECS;

    //Ok, no problem
    return SCT_RET_OK;
}

int sct_copy(sct_time_ptr pDest, const sct_time_ptr pSource)
{
    //Check element
    if(pDest == NULL || pSource == NULL)
    {
        //Ko, invalid pointer!
        #ifdef SCT_DEBUG
            if(pDest == NULL)
            {
                fprintf(stderr, \
                    "[scitime:%s] >>Unable to get destination element!\n",
                    __FUNCTION__);
            }
            if(pSource == NULL)
            {
                fprintf(stderr, \
                    "[scitime:%s] >> Unable to get source element!\n",
                __FUNCTION__);
            }
        #endif
        return SCT_RET_INVALID_PTR;
    }
    if(pSource->status == SCT_STATUS_NOT_INITIALISED)
    {
        #ifdef SCT_DEBUG
            fprintf(stderr, \
                "[scitime:%s] >> Source element not initialised!\n",
                __FUNCTION__);
        #endif
    }

    //Copy from source to dest...
    memcpy(pDest,pSource,sizeof(*pSource));

    //Ok, no problem
    return SCT_RET_OK;
}

int sct_set_delta_secs (sct_time_ptr pDelta, const double secs)
{
    double aux;

    //Check element
    if(pDelta == NULL)
    {
        //Ko, invalid pointer!
        #ifdef SCT_DEBUG
            if(pDelta == NULL)
            {
                fprintf(stderr, \
                    "[scitime:%s] >>Unable to get input delta element!\n",
                    __FUNCTION__);
            }
        #endif
        return SCT_RET_INVALID_PTR;
    }

    //Initialise delta element
    pDelta->status = SCT_STATUS_DELTA;
    pDelta->days = 0;
    pDelta->secs = 0;
    pDelta->fsecs = 0;

    //Find number of days...
    aux = secs;
    while(aux > SCT_SECS_IN_DAY)
    {
        pDelta->days++;
        aux -= SCT_SECS_IN_DAY;
    }

    //Find number of seconds...
    pDelta->secs = (int)aux;

    //Set number of femtoseconds...
    pDelta->fsecs = SCT_FSECS_IN_SEC*(int64_t)(aux-pDelta->secs);

    //Set accuracy
    pDelta->accuracy = sct_get_accuracy_from_secs(secs);

    //Ok, no problem
    return SCT_RET_OK;
}

int sct_clear(sct_time_ptr pElement)
{
   //Check element
    if(pElement == NULL)
    {
        //Ko, invalid pointer!
        #ifdef SCT_DEBUG
           fprintf(stderr, "[scitime:%s] >>Unable to get input element!\n",
                __FUNCTION__);
        #endif
        return SCT_RET_INVALID_PTR;
    }

    //Clear contents...
    pElement->days = 0;
    pElement->secs = 0;
    pElement->fsecs = 0;
    pElement->accuracy = SCT_ACCURACY_DAYS;
    pElement->status = SCT_STATUS_NOT_INITIALISED;

    //Ok, no problem
    return SCT_RET_OK;
}


int sct_get_jd(const sct_time_ptr pElement, double *pJd)
{
    SCT_STATUS ret;
    double mjd2000;

    //Get MJD2000
    ret = sct_get_mjd2000(pElement, &mjd2000);
    if(ret != SCT_RET_OK)
    {
        return ret;
    }
    //Convert to MJD
    *pJd = mjd2000 + SCT_JD_TO_J2000;

    //Ok, no problem
    return SCT_RET_OK;
}


int sct_get_mjd(const sct_time_ptr pElement, double *pMjd)
{
    SCT_STATUS ret;
    double mjd2000;

    //Get MJD2000
    ret = sct_get_mjd2000(pElement, &mjd2000);
    if(ret != SCT_RET_OK)
    {
        return ret;
    }
    //Convert to MJD
    *pMjd = mjd2000 + SCT_MJD_TO_J2000;

    //Ok, no problem
    return SCT_RET_OK;
}


int sct_get_mjd2000(const sct_time_ptr pElement, double *pMjd2000)
{
    double aux;

    //Check element
    if(pElement->status != SCT_STATUS_OK)
    {
        #ifdef SCT_DEBUG
            fprintf(stderr,"[scitime:%s] >> Element not initialised!\n",
                __FUNCTION__);
        #endif
        return SCT_RET_NOT_INITIALISED;
    }

    //Set seconds
    aux = pElement->secs + ((double)pElement->fsecs)*1E-15;

    //Set days + seconds
    *pMjd2000 = ((double)pElement->days)+(aux/SCT_SECS_IN_DAY);

    //Ok, no problem
    return SCT_RET_OK;
}

int sct_get_YMDHMSF ( \
    const sct_time_ptr pElement, \
    unsigned int *pYear, \
    unsigned int *pMonth, \
    unsigned int *pDay, \
    unsigned int *pHour, \
    unsigned int *pMinute, \
    unsigned int *pSecond, \
    u_int64_t    *pFemtosecond)
{
    long L;
    long M;
    long N;
    long P;
    long Q;
    long JDl;
    int64_t aux;


    //Check input pointer...
    if(pElement == NULL)
    {
        #ifdef SCT_DEBUG
            if(pElement == NULL)
            {
                fprintf(stderr, \
                    "[scitime:%s] >> Unable to get element!\n", __FUNCTION__);
            }
        #endif
        //Ko, invalid pointer!
        return SCT_RET_INVALID_PTR;
    }

    //Convert from MJD2000 to JD...
    JDl = pElement->days + SCT_JD_TO_J2000 +1;

    // In the conversion from the Julian Calendar to the Gregorian 
    // Calendar the day after October 4, 1582 was October 15, 1582.

    if(JDl > 2299160)    // after Oct 4, 1582
    {
        L = JDl + 68569;
        M = (4 * L) / 146097;
        L = L - ((146097 * M + 3) / 4);
        N = (4000 * (L + 1)) / 1461001;
        L = L - ((1461 * N) / 4) + 31;
        P = (80 * L) / 2447;
        *pDay = (int)(L - (2447 * P) / 80);
        L = P / 11;
        *pMonth = (int)(P + 2 - 12 * L);
        *pYear = (int)(100 * (M - 49) + N + L);
    }
    else 
    {
        P = JDl + 1402;
        Q = (P - 1) / 1461;
        L = P - 1461 * Q;
        M = (L - 1) / 365 - L / 1461;
        N = L - 365 * M + 30;
        P = (80 * N) / 2447;
        *pDay = (int)(N - (2447 * P) / 80);
        N = P / 11;
        *pMonth = (int)(P + 2 - 12 * N);
        *pYear = (int)(4 * Q + M + N - 4716);
        if(*pYear <= 0) 
        {
            --*pYear;
        }
    }
    //catch century/non-400 non-leap years
    if(*pYear > 1599 && 
       !(*pYear % 100) && 
       (*pYear % 400) && 
       *pMonth == 2 && 
       *pDay == 29)
    {
        *pMonth = 3;
        *pDay = 1;
    }

    //Get femtosecs
    *pFemtosecond = pElement->fsecs;

    //Get hours...
    *pHour = (int)(pElement->secs / 3600);

    //Get minutes...
    aux = pElement->secs % 3600;
    *pMinute = (int)(aux /60);

    //Get seconds...
    aux = aux % 60;
    *pSecond = (int)aux;

    //Ok, no problem
    return SCT_RET_OK;
}

int sct_get_delta_secs (const sct_time_ptr pDelta, double *pSecs)
{
    //Check element
    if(pDelta == NULL || pSecs == NULL)
    {
        //Ko, invalid pointer!
        #ifdef SCT_DEBUG
            if(pDelta == NULL)
            {
                fprintf(stderr, \
                    "[scitime:%s] >>Unable to get input delta element!\n",
                    __FUNCTION__);
            }
            if(pSecs == NULL)
            {
                fprintf(stderr, "[scitime:%s] >> Unable to get output element!"
                    "\n", __FUNCTION__);
            }
        #endif
        return SCT_RET_INVALID_PTR;
    }
    if(pDelta->status != SCT_STATUS_DELTA)
    {
        #ifdef SCT_DEBUG
            if(pDelta->status != SCT_STATUS_DELTA)
            {
                fprintf(stderr, "[scitime:%s] >> Delta element not "
                    "initialised as delta element!\n", __FUNCTION__);
            }
        #endif
        return SCT_RET_NOT_INITIALISED;
    }

    *pSecs = (SCT_SECS_IN_DAY * (double)pDelta->days)+ pDelta->secs + \
        (1E-15 * (double)pDelta->fsecs);

    //Ok, no problem
    return SCT_RET_OK;
}

int sct_print(const sct_time_ptr pElement)
{
    switch(pElement->status)
    {
        case SCT_STATUS_NOT_INITIALISED:
            printf(">>>>>>>  Not Initialised  <<<<<<<\n");
            break;
        case SCT_STATUS_OK:
            printf(">>>>>>>  Epoch: %lld/%d/%lld, Acc: %d <<<<<<<\n",
                pElement->days,
                pElement->secs,
                pElement->fsecs,
                pElement->accuracy);
            break;
        case SCT_STATUS_DELTA:
            printf(">>>>>>>  Delta: %lld/%d/%lld, Acc: %d <<<<<<<\n",
                pElement->days,
                pElement->secs,
                pElement->fsecs,
                pElement->accuracy);
            break;
    }
    return SCT_RET_OK;
}

---