CEDate.cpp

Go to the documentation of this file.

/***************************************************************************
 *  CEDate.cpp: CppEphem                                                   *
 * ----------------------------------------------------------------------- *
 *  Copyright © 2016-2019 JCardenzana                                      *
 * ----------------------------------------------------------------------- *
 *                                                                         *
 *  This program is free software: you can redistribute it and/or modify   *
 *  it under the terms of the GNU General Public License as published by   *
 *  the Free Software Foundation, either version 3 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 General Public License      *
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.  *
 *                                                                         *
 ***************************************************************************/
 
#include <cmath>
#include <exception>
#include <stdio.h>
 
#include "CEDate.h"
#include "CEException.h"
 
/**********************************************************************/
CEDate::CEDate(double date, CEDateType date_format)
{
    init_members();
    // Use the SetDate function to set the actual time
    CEDate::SetDate(date, date_format) ;
}
 
/**********************************************************************/
CEDate::CEDate(std::vector<double> date)
{
    init_members();
    // First get the gregorian date double from the vector, then set the date
    CEDate::SetDate(GregorianVect2Gregorian(date), CEDateType::GREGORIAN) ;
}
 
/**********************************************************************/
CEDate::CEDate(const CEDate& other)
{
    init_members();
    copy_members(other);
}
 
 
/**********************************************************************/
CEDate::~CEDate()
{}
 
 
/**********************************************************************/
CEDate& CEDate::operator=(const CEDate& other)
{
    if (this != &other) {
        free_members();
        init_members();
        copy_members(other);
    }
    return *this;
}
 
 
/**********************************************************************/
void CEDate::SetDate(const double&     date, 
                     const CEDateType& time_format)
{
    // Fill the internal date storage objects based on the format of the input "date"
    if (time_format == CEDateType::JD) {
        // Save information based on julian date input
        julian_date_ = date ;
        mod_julian_date_ = JD2MJD(date) ;
        gregorian_date_ = JD2Gregorian(date) ;
        gregorian_date_vect_ = JD2GregorianVect(date) ;
    } else if (time_format == CEDateType::MJD) {
        // Save information based on modified julian date input
        julian_date_ = MJD2JD(date) ;
        mod_julian_date_ = date ;
        gregorian_date_ = MJD2Gregorian(date) ;
        gregorian_date_vect_ = MJD2GregorianVect(date) ;
    } else if (time_format == CEDateType::GREGORIAN) {
        // Save information based on gregorian date input
        julian_date_ = Gregorian2JD(date) ;
        mod_julian_date_ = Gregorian2MJD(date) ;
        gregorian_date_ = date ;
        gregorian_date_vect_ = Gregorian2GregorianVect(date) ;
    } else {
        // Date type is invalid
        throw CEException::invalid_value("CEDate::SetDate()", 
                                         "Invalid date type");
    }
}
 
/**********************************************************************/
void CEDate::SetDate(std::vector<double> date)
{
    SetDate(GregorianVect2JD(date)) ;
}
 
/**********************************************************************/
double CEDate::GetDate(CEDateType time_format) const
{
    // Initialize the return date
    double date(0);
 
    // Return the julian date if requested
    if (time_format == CEDateType::JD) {
        date = JD() ;
    } else if (time_format == CEDateType::MJD) {
        date = MJD() ;
    } else if (time_format == CEDateType::GREGORIAN) {
        date = Gregorian() ;
    } else {
        throw CEException::invalid_value("CEDate::GetDate()", 
                                         "Unrecognized time format!");
    }
 
    return date;
}
 
 
/**********************************************************************/
double CEDate::JD2MJD(double jd)
{
    return jd - GetMJD2JDFactor();
}
 
/**********************************************************************/
double CEDate::JD2Gregorian(double jd)
{
    // Fill a temporary gregorian vector
    std::vector<double> temp_gregorian_vect = JD2GregorianVect(jd) ;
    return GregorianVect2Gregorian(temp_gregorian_vect) ;
}
 
/**********************************************************************/
std::vector<double> CEDate::JD2GregorianVect(double jd)
{
    std::vector<double> full_gregorian_vect(4,0.0) ;
    std::vector<int> gregorian_date(3,0.0) ;
    
    // Try to fill the gregorian_date vector
    if (iauJd2cal(jd, 0, &gregorian_date[0], &gregorian_date[1],
                   &gregorian_date[2], &full_gregorian_vect[3])) {
        std::cerr << "[WARNING] CEDate::JD2GregorianVect() :: Bad date (" << jd << ")!" << std::endl ;
        return std::vector<double>(4,0.0) ;
    } else {
        // Fill the double vector from the integer values
        full_gregorian_vect[0] = 1.0*gregorian_date[0] ;
        full_gregorian_vect[1] = 1.0*gregorian_date[1] ;
        full_gregorian_vect[2] = 1.0*gregorian_date[2] ;
    }
    
    return full_gregorian_vect ;
}
 
 
// Note that the modified julian date converters first do a conversion
// to Julian Date and then call the Julian Date converters
 
/**********************************************************************/
double CEDate::MJD2JD(double mjd)
{
    return mjd + GetMJD2JDFactor();
}
 
 
/**********************************************************************/
double CEDate::MJD2Gregorian(double mjd)
{
    // Convert the mjd to jd
    double jd = MJD2JD(mjd) ;
    // Now convert julian date to gregorian
    return JD2Gregorian(jd) ;
}
 
 
/**********************************************************************/
std::vector<double> CEDate::MJD2GregorianVect(double mjd)
{
    // Convert mjd to jd
    double jd = MJD2JD(mjd) ;
    // Now convert julian date to gregorian vector
    return JD2GregorianVect(jd) ;
}
 
 
/**********************************************************************/
double CEDate::Gregorian2JD(double gregorian)
{
    // First convert the gregorian double into a gregorian vector
    std::vector<double> gregorian_vect = Gregorian2GregorianVect(gregorian) ;
    
    return GregorianVect2JD(gregorian_vect) ;
}
 
 
/**********************************************************************/
double CEDate::GregorianVect2JD(std::vector<double> gregorian)
{
    // The following stores the two values needed to get the julian date
    double mjd_factor(0.0);
    double mjd(0.0);
    
    // Now use the sofa function for converting to julian date
    int err_code = iauCal2jd(int(gregorian[0]), int(gregorian[1]),
                             int(gregorian[2]), &mjd_factor, &mjd) ;
    if (err_code) {
        std::cerr << "[WARNING] CEDate::GregorianVect2JD() :: Bad ";
        if (err_code == -1) {
            std::cerr << "year (" << gregorian[0] << "). Make sure the year is larger than -4800." << std::endl ;
            return 0.0 ;
        } else if (err_code == -2) {
            std::cerr << "month (" << gregorian[1] << "). Make sure this number is in the range 1 -> 12." << std::endl ;
            return 0.0 ;
        } else if (err_code == -3) {
            std::cerr << "day (" << gregorian[2] << ")" << std::endl ;
            // Note that in this case, a julian date was still calculated
            // so we can go ahead and return it
        }
    }
    
    // Return the sum of the two filled date values which represents
    // the Julian date
    return mjd_factor + mjd + gregorian[3] ;
}
 
 
/**********************************************************************/
double CEDate::Gregorian2MJD(double gregorian)
{
    // First get the Julian Date
    double jd = Gregorian2JD(gregorian) ;
    // Now convert to Modified Julian Date
    return JD2MJD(jd) ;
}
 
 
/**********************************************************************/
double CEDate::GregorianVect2MJD(std::vector<double> gregorian)
{
    // First convert to JD
    double jd = GregorianVect2JD(gregorian) ;
    // Now convert to MJD
    return JD2MJD(jd) ;
}
 
 
/**********************************************************************/
void CEDate::UTC2UT1(const double& mjd,
                     double*       ut11,
                     double*       ut12)
{
    iauUtcut1(CEDate::GetMJD2JDFactor(), mjd, CppEphem::dut1(mjd), ut11, ut12);
}
 
 
/**********************************************************************/
void CEDate::UTC2TT(const double& mjd,
                    double*       tt1,
                    double*       tt2)
{
    // Convert UTC to UT1
    CEDate::UTC2UT1(mjd, tt1, tt2);
    // Convert UT1 to TT
    iauUt1tt(*tt1, *tt2, CppEphem::ttut1(mjd), tt1, tt2) ;
}
 
 
/**********************************************************************/
void CEDate::UTC2TDB(const double& mjd,
                     double*       tdb1,
                     double*       tdb2)
{
    // Convert UTC to TT
    CEDate::UTC2TT(mjd, tdb1, tdb2);
    // Convert TT to TDB
    iauTttdb(*tdb1, *tdb2, 0.0, tdb1, tdb2) ;
}
 
 
/**********************************************************************/
double CEDate::dut1(const double&     date, 
                    const CEDateType& date_type)
{
    // Create an object from the date information
    CEDate input_date(date, date_type) ;
    // Return the DUT1 value at this date
    return input_date.dut1() ;
}
 
 
/**********************************************************************/
double CEDate::dut1(void) const
{
    // return the value associated with 'UT1-UTC'
    return CppEphem::dut1(mod_julian_date_) ;
}
 
 
// /**********************************************************************//**
//  *************************************************************************/
// double CEDate::dut1Error(double date, CEDateType date_type)
// {
//     CEDate input_date(date, date_type) ;
//     return input_date.dut1Error() ;
// }
 
 
// /**********************************************************************//**
//  *************************************************************************/
// double CEDate::dut1Error()
// {
//     // Return the error on the dut1 value
//     return CppEphem::dut1Error(mod_julian_date_) ;
// }
 
 
/**********************************************************************/
double CEDate::xpolar(const double&     date, 
                      const CEDateType& date_type)
{
    CEDate input_date(date, date_type) ;
    return CppEphem::xp( input_date.MJD() ) ;
}
 
 
/**********************************************************************/
double CEDate::xpolar(void) const
{
    return CppEphem::xp( mod_julian_date_ ) ;
}
 
 
/**********************************************************************/
double CEDate::ypolar(const double&     date, 
                      const CEDateType& date_type)
{
    CEDate input_date(date, date_type) ;
    return CppEphem::yp( input_date.MJD() ) ;
}
 
 
/**********************************************************************/
double CEDate::ypolar(void) const
{
    return CppEphem::yp( mod_julian_date_ ) ;
}
 
 
/**********************************************************************/
double CEDate::GregorianVect2Gregorian(std::vector<double> gregorian)
{
    int sign = (gregorian[0] < 0) ? -1.0 : 1.0;
    double ret = std::fabs(gregorian[0]) * 10000 +
                           gregorian[1]  * 100 +
                           gregorian[2];
    if (gregorian.size() == 4) {
        ret += gregorian[3];
    }
    return sign * ret;
}
 
 
/**********************************************************************/
std::vector<double> CEDate::Gregorian2GregorianVect(double gregorian)
{
    // Create a vector to hold the information
    std::vector<double> gregorian_vect(4,0.0) ;
    double greg = std::fabs(gregorian);
 
    // Get the day fraction
    gregorian_vect[3] = greg - std::floor(greg);
    // Get the day of the month
    gregorian_vect[2] = int(std::floor(greg)) % 100 ;
    // Get the month
    gregorian_vect[1] = int(std::floor(greg - gregorian_vect[2])/100) % 100;
    // Get the year
    gregorian_vect[0] = int(std::floor(greg - gregorian_vect[2] - 100*gregorian_vect[1]) / 10000);
    gregorian_vect[0] *= (gregorian < 0.0) ? -1.0 : 1.0;
 
    return gregorian_vect;
}
 
 
/**********************************************************************/
double CEDate::GetSecondsSinceMidnight(const double& utc_offset)
{
    double mjd_offset = MJD();
    mjd_offset -= std::floor(mjd_offset);
    mjd_offset += utc_offset/24.0;
    return CETime::UTC( mjd_offset ) ;
}
 
 
/**********************************************************************/
double CEDate::GetTime(const double& utc_offset) const
{
    double mjd_offset = MJD();
    mjd_offset -= std::floor(mjd_offset);
    mjd_offset += utc_offset/24.0;
    return CETime::TimeSec2Time( CETime::UTC( mjd_offset ) ) ;
}
 
 
/**********************************************************************/
double CEDate::GetTime_UTC() const
{
    return GetTime(0.0) ;
}
 
 
/**********************************************************************/
double CEDate::CurrentJD()
{
    // Get the current date information
    time_t now ;
    time (&now) ;
    struct tm current_jd;
    gmtime_r(&now, &current_jd) ;
    
    // Put this into a vector
    std::vector<double> date_info = {current_jd.tm_year+1900.0,
                                     current_jd.tm_mon+1.0,
                                     current_jd.tm_mday*1.0,
                                     CETime::CurrentUTC()/DAYSEC} ;
    
    // Convert the Gregorian date information into a Julian date
    return GregorianVect2JD( date_info ) ;
}
 
 
/**********************************************************************/
CEDate::operator double()
{
    // Return the date formatted according to the 'return_type_' variable
    return GetDate(return_type_) ;
}
 
/**********************************************************************/
CEDate::operator double() const
{
    // Return the date formatted according to the 'return_type_' variable
    return GetDate(return_type_) ;
}
 
 
/**********************************************************************/
void CEDate::free_members(void)
{
    gregorian_date_vect_.clear();
}
 
 
/**********************************************************************/
void CEDate::copy_members(const CEDate& other)
{
    gregorian_date_vect_ = other.gregorian_date_vect_;
    julian_date_         = other.julian_date_;
    mod_julian_date_     = other.mod_julian_date_;
    gregorian_date_      = other.gregorian_date_;
    return_type_         = other.return_type_;
}
 
 
/**********************************************************************/
void CEDate::init_members(void)
{
    gregorian_date_vect_ = std::vector<double>(4, 0.0);
    julian_date_         = 0.0;
    mod_julian_date_     = 0.0;
    gregorian_date_      = 0.0;
    return_type_         = CEDateType::JD ;
}