CENamespace.cpp

Go to the documentation of this file.

/***************************************************************************
 *  CENamespace.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 <iomanip>
#include <stdio.h>
#include <sstream>
#include "CENamespace.h"
 
 
/**********************************************************************/
std::string CppEphem::NutationFile(void)
{
    return CppEphem::corrections.NutationFile();
}
 
 
/**********************************************************************/
std::string CppEphem::TtUt1HistFile(void)
{
    return CppEphem::corrections.TtUt1HistFile();
}
 
 
/**********************************************************************/
std::string CppEphem::TtUt1PredFile(void)
{
    return CppEphem::corrections.TtUt1PredFile();
}
 
 
/**********************************************************************/
void CppEphem::SetNutationFile(const std::string& filename)
{
    CppEphem::corrections.SetNutationFile(filename);
}
 
 
/**********************************************************************/
void CppEphem::SetTtUt1HistFile(const std::string& filename)
{
    CppEphem::corrections.SetTtUt1HistFile(filename);
}
 
 
/**********************************************************************/
void CppEphem::SetTtUt1PredFile(const std::string& filename)
{
    CppEphem::corrections.SetTtUt1PredFile(filename);
}
 
 
/**********************************************************************/
void CppEphem::CorrectionsInterp(bool set_interp)
{
    CppEphem::corrections.SetInterp(set_interp);
}
 
 
/**********************************************************************/
double CppEphem::dut1(const double& mjd) 
{
    double dut1(0.0);
 
    // Fill dut1 if support dir has been defined
    dut1 = CppEphem::corrections.dut1(mjd);
 
    return dut1;
}
 
/**********************************************************************/
double CppEphem::dut1Error(const double& mjd) 
{
    return 0.0;
}
 
/**********************************************************************/
double CppEphem::dut1Calc(const double& mjd)
{
    // There's a formula that could be used for calculating this value,
    // but I'm a bit lazy at the moment and since the correction is
    // very small, I'm just going to return 0 for the time being.
    return 0.0 ;
}
 
 
/**********************************************************************/
double CppEphem::xp(const double& mjd) 
{
    return corrections.xpolar(mjd) ;
}
 
 
/**********************************************************************/
double CppEphem::yp(const double& mjd) 
{
    return corrections.ypolar(mjd);
}
 
 
/**********************************************************************/
double CppEphem::deps(const double& mjd)
{
    return corrections.deps(mjd);
}
 
 
/**********************************************************************/
double CppEphem::dpsi(const double& mjd)
{
    return corrections.dpsi(mjd);
}
 
 
/**********************************************************************/
double CppEphem::ttut1(const double& mjd)
{
    return corrections.ttut1(mjd);
}
 
 
/**********************************************************************/
void CppEphem::StrOpt::split(const std::string&        s, 
                             const char&               delim, 
                             std::vector<std::string>* elems) 
{
    std::stringstream ss(s);
    std::string item=std::string();
    while (std::getline(ss, item, delim)) {
        elems->push_back(item);
    }
}
 
 
/**********************************************************************/
std::vector<std::string> CppEphem::StrOpt::split(const std::string& s, 
                                                 const char&        delim) 
{
    std::vector<std::string> elems;
    split(s, delim, &elems);
    return elems;
}
 
 
/**********************************************************************/
template <typename T>
std::string CppEphem::StrOpt::join(const std::vector<T>& values,
                                   const char&           delim)
{
    // Assemble the first value in the string
    std::ostringstream ss;
    if (values.size() > 0) {
        ss << values[0];
    }
 
    // Now append the rest
    for (int i=1; i<values.size(); i++) { 
        ss << delim << values[i];
    }
 
    return ss.str();
}
// Define the typical use cases of CppEphem::StrOpt::join
template std::string CppEphem::StrOpt::join<std::string>(
    const std::vector<std::string>&, const char&);
template std::string CppEphem::StrOpt::join<double>(
    const std::vector<double>&, const char&);
 
 
 
/**********************************************************************/
std::string CppEphem::StrOpt::join_angle(const std::vector<double>& values,
                                         const char&                delim)
{
    // Make sure there are only three values
    double sec = values[2];
    if (values.size() == 4) {
        sec += values[3];
    }
 
    // Assemble the string using the specified delimiter
    std::ostringstream ss;
    ss << std::setfill('0') << std::setw(2) << int(values[0]);
    ss << delim;
    ss << std::setfill('0') << std::setw(2) << int(values[1]);
    ss << delim;
    ss << std::setfill('0') << std::setw(11) << std::fixed 
       << std::setprecision(8) << sec;
    
    return std::string(ss.str());
}