jpleph.cpp File Reference

#include "support/configCosmos.h"
#include <stdio.h>
#include <cmath>
#include <cstring>
#include <stdlib.h>
#include "support/jpleph.h"

Include dependency graph for jpleph.cpp:

Macros
#define	TRUE   1
#define	FALSE   0
#define	KM   1
#define	SWAP_MACRO(A, B, TEMP)   { TEMP = A; A = B; B = TEMP; }

Functions
double DLL_FUNC	jpl_get_double (const void *ephem, const int value)
double DLL_FUNC	jpl_get_long (const void *ephem, const int value)
int DLL_FUNC	jpl_pleph (void *ephem, const double et, const int ntarg, const int ncent, double rrd[], const int calc_velocity)
static void	interp (struct interpolation_info *iinfo, const double coef[], const double t[2], const int ncf, const int ncm, const int na, const int ifl, double posvel[])
static void	swap_long_integer (void *ptr)
static void	swap_double (void *ptr, long count)
int DLL_FUNC	jpl_state (void *ephem, const double et, const int list[12], double pv[][6], double nut[4], const int bary)
void *DLL_FUNC	jpl_init_ephemeris (const char *ephemeris_filename, char nam[][6], double *val)
void DLL_FUNC	jpl_close_ephemeris (void *ephem)

Macro Definition Documentation

#define TRUE   1

#define FALSE   0

#define KM   1

#define SWAP_MACRO	(		A,
			B,
			TEMP
	)		{ TEMP = A; A = B; B = TEMP; }

Function Documentation

static void interp ( struct interpolation_info *  iinfo, const double  coef[], const double  t[2], const int  ncf, const int  ncm, const int  na, const int  ifl, double  posvel[]  )

static

{
    double dna, dt1, temp, tc, vfac, temp1;
    int l, i, j;

    /*  entry point. get correct sub-interval number for this set
    of coefficients and then get normalized chebyshev time
    within that subinterval.                                             */

    dna = (double)na;
    modf( t[0], &dt1);
    temp = dna * t[0];
    l = (int)(temp - dt1);

    /*  tc is the normalized chebyshev time (-1 <= tc <= 1)    */

    tc = 2.0 * (modf( temp, &temp1) + dt1) - 1.0;

    /*  check to see whether chebyshev time has changed,
    and compute new polynomial values if it has.
    (the element iinfo->pc[1] is the value of t1[tc] and hence
    contains the value of tc on the previous call.)     */

    if(tc != iinfo->pc[1])
    {
        iinfo->np = 2;
        iinfo->nv = 3;
        iinfo->pc[1] = tc;
        iinfo->twot = tc+tc;
    }

    /*  be sure that at least 'ncf' polynomials have been evaluated
    and are stored in the array 'iinfo->pc'.    */

    if(iinfo->np < ncf)
    {
        double *pc_ptr = iinfo->pc + iinfo->np;

        for(i=ncf - iinfo->np; i; i--, pc_ptr++)
        {
            if (i<0 || i>ncf)
            {
                i = 0;
                break;
            }
            *pc_ptr = iinfo->twot * pc_ptr[-1] - pc_ptr[-2];
        }
        iinfo->np=ncf;
    }

    /*  interpolate to get position for each component  */

    for( i = 0; i < ncm; ++i)        /* ncm is a number of coordinates */
    {
        const double *coeff_ptr = coef + ncf * (i + l * ncm + 1);
        const double *pc_ptr = iinfo->pc + ncf;

        posvel[i]=0.0;
        for( j = ncf; j; j--)
            posvel[i] += (*--pc_ptr) * (*--coeff_ptr);
    }

    if(ifl <= 1) return;

    /*  if velocity interpolation is wanted, be sure enough
    derivative polynomials have been generated and stored.    */

    vfac=(dna+dna)/t[1];
    iinfo->vc[2] = iinfo->twot + iinfo->twot;
    if( iinfo->nv < ncf)
    {
        double *vc_ptr = iinfo->vc + iinfo->nv;
        const double *pc_ptr = iinfo->pc + iinfo->nv - 1;

        for( i = ncf - iinfo->nv; i; i--, vc_ptr++, pc_ptr++)
        {
            if (i<0 || i>ncf)
            {
                i = 0;
                break;
            }
            *vc_ptr = iinfo->twot * vc_ptr[-1] + *pc_ptr + *pc_ptr - vc_ptr[-2];
        }
        iinfo->nv = ncf;
    }

    /*  interpolate to get velocity for each component    */

    for( i = 0; i < ncm; ++i)
    {
        double tval = 0.;
        const double *coeff_ptr = coef + ncf * (i + l * ncm + 1);
        const double *vc_ptr = iinfo->vc + ncf;

        for( j = ncf; j; j--)
            tval += (*--vc_ptr) * (*--coeff_ptr);
        posvel[ i + ncm] = tval * vfac;
    }
    return;
}

static void swap_long_integer ( void *  ptr )

static

{
    char *tptr = (char *)ptr, tchar;

    SWAP_MACRO( tptr[0], tptr[3], tchar);
    SWAP_MACRO( tptr[1], tptr[2], tchar);
}

static void swap_double ( void *  ptr, long  count  )

static

{
    char *tptr = (char *)ptr, tchar;

    while( count--)
    {
        SWAP_MACRO( tptr[0], tptr[7], tchar);
        SWAP_MACRO( tptr[1], tptr[6], tchar);
        SWAP_MACRO( tptr[2], tptr[5], tchar);
        SWAP_MACRO( tptr[3], tptr[4], tchar);
        tptr += 8;
    }
}