/* | | Subroutines for reading JPL ephemerides. | derived from testeph.f as contained in DE403 distribution July 1995. | works with DE200, DE102, DE403, DE404, DE405, DE406, DE431 | (attention, these ephemerides do not have exactly the same reference frame) Authors: Dieter Koch and Alois Treindl, Astrodienst Zurich ************************************************************/ /* Copyright (C) 1997 - 2021 Astrodienst AG, Switzerland. All rights reserved. License conditions ------------------ This file is part of Swiss Ephemeris. Swiss Ephemeris is distributed with NO WARRANTY OF ANY KIND. No author or distributor accepts any responsibility for the consequences of using it, or for whether it serves any particular purpose or works at all, unless he or she says so in writing. Swiss Ephemeris is made available by its authors under a dual licensing system. The software developer, who uses any part of Swiss Ephemeris in his or her software, must choose between one of the two license models, which are a) GNU Affero General Public License (AGPL) b) Swiss Ephemeris Professional License The choice must be made before the software developer distributes software containing parts of Swiss Ephemeris to others, and before any public service using the developed software is activated. If the developer choses the AGPL software license, he or she must fulfill the conditions of that license, which includes the obligation to place his or her whole software project under the AGPL or a compatible license. See https://www.gnu.org/licenses/agpl-3.0.html If the developer choses the Swiss Ephemeris Professional license, he must follow the instructions as found in http://www.astro.com/swisseph/ and purchase the Swiss Ephemeris Professional Edition from Astrodienst and sign the corresponding license contract. The License grants you the right to use, copy, modify and redistribute Swiss Ephemeris, but only under certain conditions described in the License. Among other things, the License requires that the copyright notices and this notice be preserved on all copies. Authors of the Swiss Ephemeris: Dieter Koch and Alois Treindl The authors of Swiss Ephemeris have no control or influence over any of the derived works, i.e. over software or services created by other programmers which use Swiss Ephemeris functions. The names of the authors or of the copyright holder (Astrodienst) must not be used for promoting any software, product or service which uses or contains the Swiss Ephemeris. This copyright notice is the ONLY place where the names of the authors can legally appear, except in cases where they have given special permission in writing. The trademarks 'Swiss Ephemeris' and 'Swiss Ephemeris inside' may be used for promoting such software, products or services. */ #if MSDOS #else #define _FILE_OFFSET_BITS 64 #endif #include #include "swephexp.h" #include "sweph.h" #include "swejpl.h" #if MSDOS typedef __int64 off_t64; #define FSEEK _fseeki64 #define FTELL _ftelli64 #else typedef off_t off_t64; #define FSEEK fseeko #define FTELL ftello // #ifdef __ANDROID_API__ // #undef FSEEK // #undef FTELL // #define FSEEK fseek // #define FTELL ftell // #endif #endif #define DEBUG_DO_SHOW FALSE /* * local globals */ struct jpl_save { char *jplfname; char *jplfpath; FILE *jplfptr; short do_reorder; double eh_cval[400]; double eh_ss[3], eh_au, eh_emrat; int32 eh_denum, eh_ncon, eh_ipt[39]; char ch_cnam[6*400]; double pv[78]; double pvsun[6]; double buf[1500]; double pc[18], vc[18], ac[18], jc[18]; short do_km; }; static TLS struct jpl_save *js; static int state (double et, int32 *list, int do_bary, double *pv, double *pvsun, double *nut, char *serr); static int interp(double *buf, double t, double intv, int32 ncfin, int32 ncmin, int32 nain, int32 ifl, double *pv); static int32 fsizer(char *serr); static void reorder(char *x, int size, int number); static int read_const_jpl(double *ss, char *serr); /* information about eh_ipt[] and buf[] DE200 DE102 DE403 3 3 ipt[0] 3 body 0 (mercury) starts at buf[2] 12 15 ipt[1] 14 body 0, ncf = coefficients per component 4 2 ipt[2] 4 na = nintervals, tot 14*4*3=168 147 93 ipt[3] 171 body 1 (venus) starts at buf[170] 12 15 ipt[4] 10 ncf = coefficients per component 1 1 ipt[5] 2 total 10*2*3=60 183 138 ipt[6] 231 body 2 (earth) starts at buf[230] 15 15 ipt[7] 13 ncf = coefficients per component 2 2 ipt[8] 2 total 13*2*3=78 273 228 ipt[9] 309 body 3 (mars) starts at buf[308] 10 10 ipt[10] 11 ncf = coefficients per component 1 1 ipt[11] 1 total 11*1*3=33 303 258 ipt[12] 342 body 4 (jupiter) at buf[341] 9 9 ipt[13] 8 total 8 * 1 * 3 = 24 1 1 ipt[14] 1 330 285 ipt[15] 366 body 5 (saturn) at buf[365] 8 8 ipt[16] 7 total 7 * 1 * 3 = 21 1 1 ipt[17] 1 354 309 ipt[18] 387 body 6 (uranus) at buf[386] 8 8 ipt[19] 6 total 6 * 1 * 3 = 18 1 1 ipt[20] 1 378 333 ipt[21] 405 body 7 (neptune) at buf[404] 6 6 ipt[22] 6 total 18 1 1 ipt[23] 1 396 351 ipt[24] 423 body 8 (pluto) at buf[422] 6 6 ipt[25] 6 total 18 1 1 ipt[26] 1 414 369 ipt[27] 441 body 9 (moon) at buf[440] 12 15 ipt[28] 13 total 13 * 8 * 3 = 312 8 8 ipt[29] 8 702 729 ipt[30] 753 SBARY SUN, starts at buf[752] 15 15 ipt[31] 11 SBARY SUN, ncf = coeff per component 1 1 ipt[32] 2 total 11*2*3=66 747 774 ipt[33] 819 nutations, starts at buf[818] 10 0 ipt[34] 10 total 10 * 4 * 2 = 80 4 0 ipt[35] 4 (nutation only two coordinates) 0 0 ipt[36] 899 librations, start at buf[898] 0 0 ipt[37] 10 total 10 * 4 * 3 = 120 0 0 ipt[38] 4 last element of buf[1017] buf[0] contains start jd and buf[1] end jd of segment; each segment is 32 days in de403, 64 days in DE102, 32 days in DE200 Length of blocks: DE406 = 1456*4=5824 bytes = 728 double DE405 = 2036*4=8144 bytes = 1018 double DE404 = 1456*4=5824 bytes = 728 double DE403 = 2036*4=8144 bytes = 1018 double DE200 = 1652*4=6608 bytes = 826 double DE102 = 1546*4=6184 bytes = 773 double each DE102 record has 53*8=424 fill bytes so that the records have the same length as DE200. */ /* * This subroutine opens the file jplfname, with a phony record length, * reads the first record, and uses the info to compute ksize, * the number of single precision words in a record. * RETURN: ksize (record size of ephemeris data) * jplfptr is opened on return. * note 26-aug-2008: now record size is computed by fsizer(), not * set to a fixed value depending as in previous releases. The caller of * fsizer() will verify by data comparison whether it computed correctly. */ static int32 fsizer(char *serr) { /* Local variables */ int32 ncon; double emrat; int32 numde; double au, ss[3]; int i, kmx, khi, nd; int32 ksize, lpt[3]; char ttl[6*14*3]; size_t nrd; /* unused, removes compile warnings */ if ((js->jplfptr = swi_fopen(SEI_FILE_PLANET, js->jplfname, js->jplfpath, serr)) == NULL) { return NOT_AVAILABLE; } /* ttl = ephemeris title, e.g. * "JPL Planetary Ephemeris DE404/LE404 * Start Epoch: JED= 625296.5-3001 DEC 21 00:00:00 * Final Epoch: JED= 2817168.5 3001 JAN 17 00:00:00c */ nrd = fread((void *) &ttl[0], 1, 252, js->jplfptr); if (nrd != 252) return NOT_AVAILABLE; /* cnam = names of constants */ nrd = fread((void *) js->ch_cnam, 1, 6*400, js->jplfptr); if (nrd != 6*400) return NOT_AVAILABLE; /* ss[0] = start epoch of ephemeris * ss[1] = end epoch * ss[2] = segment size in days */ nrd = fread((void *) &ss[0], sizeof(double), 3, js->jplfptr); if (nrd != 3) return NOT_AVAILABLE; /* reorder ? */ if (ss[2] < 1 || ss[2] > 200) js->do_reorder = TRUE; else js->do_reorder = 0; for (i = 0; i < 3; i++) js->eh_ss[i] = ss[i]; if (js->do_reorder) reorder((char *) &js->eh_ss[0], sizeof(double), 3); /* plausibility test of these constants. Start and end date must be * between -20000 and +20000, segment size >= 1 and <= 200 */ if (js->eh_ss[0] < -5583942 || js->eh_ss[1] > 9025909 || js->eh_ss[2] < 1 || js->eh_ss[2] > 200) { if (serr != NULL) { strcpy(serr, "alleged ephemeris file has invalid format."); if (strlen(serr) + strlen(js->jplfname) + 3 < AS_MAXCH) { sprintf(serr, "alleged ephemeris file (%s) has invalid format.", js->jplfname); } } return(NOT_AVAILABLE); } /* ncon = number of constants */ nrd = fread((void *) &ncon, sizeof(int32), 1, js->jplfptr); if (nrd != 1) return NOT_AVAILABLE; if (js->do_reorder) reorder((char *) &ncon, sizeof(int32), 1); /* au = astronomical unit */ nrd = fread((void *) &au, sizeof(double), 1, js->jplfptr); if (nrd != 1) return NOT_AVAILABLE; if (js->do_reorder) reorder((char *) &au, sizeof(double), 1); /* emrat = earth moon mass ratio */ nrd = fread((void *) &emrat, sizeof(double), 1, js->jplfptr); if (nrd != 1) return NOT_AVAILABLE; if (js->do_reorder) reorder((char *) &emrat, sizeof(double), 1); /* ipt[i+0]: coefficients of planet i start at buf[ipt[i+0]-1] * ipt[i+1]: number of coefficients (interpolation order - 1) * ipt[i+2]: number of intervals in segment */ nrd = fread((void *) &js->eh_ipt[0], sizeof(int32), 36, js->jplfptr); if (nrd != 36) return NOT_AVAILABLE; if (js->do_reorder) reorder((char *) &js->eh_ipt[0], sizeof(int32), 36); /* numde = number of jpl ephemeris "404" with de404 */ nrd = fread((void *) &numde, sizeof(int32), 1, js->jplfptr); if (nrd != 1) return NOT_AVAILABLE; if (js->do_reorder) reorder((char *) &numde, sizeof(int32), 1); /* read librations */ nrd = fread(&lpt[0], sizeof(int32), 3, js->jplfptr); if (nrd != 3) return NOT_AVAILABLE; if (js->do_reorder) reorder((char *) &lpt[0], sizeof(int32), 3); /* fill librations into eh_ipt[36]..[38] */ for (i = 0; i < 3; ++i) js->eh_ipt[i + 36] = lpt[i]; rewind(js->jplfptr); /* find the number of ephemeris coefficients from the pointers */ /* re-activated this code on 26-aug-2008 */ kmx = 0; khi = 0; for (i = 0; i < 13; i++) { if (js->eh_ipt[i * 3] > kmx) { kmx = js->eh_ipt[i * 3]; khi = i + 1; } } if (khi == 12) nd = 2; else nd = 3; ksize = (js->eh_ipt[khi * 3 - 3] + nd * js->eh_ipt[khi * 3 - 2] * js->eh_ipt[khi * 3 - 1] - 1L) * 2L; /* * de102 files give wrong ksize, because they contain 424 empty bytes * per record. Fixed by hand! */ if (ksize == 1546) ksize = 1652; #if 0 /* we prefer to compute ksize to be comaptible with new DE releases */ switch (numde) { case 403: case 405: case 410: case 413: case 414: case 418: case 421: ksize = 2036; break; case 404: case 406: ksize = 1456; break; case 200: ksize = 1652; break; case 102: ksize = 1652; /* de102 is filled with blanks to length of de200 */ break; default: if (serr != NULL) sprintf(serr,"unknown numde value %d;", numde); return ERR; } #endif if (ksize < 1000 || ksize > 5000) { if (serr != NULL) sprintf(serr, "JPL ephemeris file does not provide valid ksize (%d)", ksize);/**/ return NOT_AVAILABLE; } return ksize; } /* * This subroutine reads the jpl planetary ephemeris * and gives the position and velocity of the point 'ntarg' * with respect to 'ncent'. * calling sequence parameters: * et = d.p. julian ephemeris date at which interpolation * is wanted. * ** note the entry dpleph for a doubly-dimensioned time ** * the reason for this option is discussed in the * subroutine state * ntarg = integer number of 'target' point. * ncent = integer number of center point. * the numbering convention for 'ntarg' and 'ncent' is: * 0 = mercury 7 = neptune * 1 = venus 8 = pluto * 2 = earth 9 = moon * 3 = mars 10 = sun * 4 = jupiter 11 = solar-system barycenter * 5 = saturn 12 = earth-moon barycenter * 6 = uranus 13 = nutations (longitude and obliq) * 14 = librations, if on eph file * (if nutations are wanted, set ntarg = 13. for librations, * set ntarg = 14. set ncent=0.) * rrd = output 6-word d.p. array containing position and velocity * of point 'ntarg' relative to 'ncent'. the units are au and * au/day. for librations the units are radians and radians * per day. in the case of nutations the first four words of * rrd will be set to nutations and rates, having units of * radians and radians/day. * The option is available to have the units in km and km/sec. * For this, set do_km=TRUE (default FALSE). */ int swi_pleph(double et, int ntarg, int ncent, double *rrd, char *serr) { int i, retc; int32 list[12]; double *pv = js->pv; double *pvsun = js->pvsun; for (i = 0; i < 6; ++i) rrd[i] = 0.0; if (ntarg == ncent) return 0; for (i = 0; i < 12; ++i) list[i] = 0; /* check for nutation call */ if (ntarg == J_NUT) { if (js->eh_ipt[34] > 0) { list[10] = 2; return(state(et, list, FALSE, pv, pvsun, rrd, serr)); } else { if (serr != NULL) sprintf(serr,"No nutations on the JPL ephemeris file;"); return (NOT_AVAILABLE); } } if (ntarg == J_LIB) { if (js->eh_ipt[37] > 0) { list[11] = 2; if ((retc = state(et, list, FALSE, pv, pvsun, rrd, serr)) != OK) return (retc); for (i = 0; i < 6; ++i) rrd[i] = pv[i + 60]; return 0; } else { if (serr != NULL) sprintf(serr,"No librations on the ephemeris file;"); return (NOT_AVAILABLE); } } /* set up proper entries in 'list' array for state call */ if (ntarg < J_SUN) list[ntarg] = 2; if (ntarg == J_MOON) /* Mooon needs Earth */ list[J_EARTH] = 2; if (ntarg == J_EARTH) /* Earth needs Moon */ list[J_MOON] = 2; if (ntarg == J_EMB) /* EMB needs Earth */ list[J_EARTH] = 2; if (ncent < J_SUN) list[ncent] = 2; if (ncent == J_MOON) /* Mooon needs Earth */ list[J_EARTH] = 2; if (ncent == J_EARTH) /* Earth needs Moon */ list[J_MOON] = 2; if (ncent == J_EMB) /* EMB needs Earth */ list[J_EARTH] = 2; if ((retc = state(et, list, TRUE, pv, pvsun, rrd, serr)) != OK) return (retc); if (ntarg == J_SUN || ncent == J_SUN) { for (i = 0; i < 6; ++i) pv[i + 6*J_SUN] = pvsun[i]; } if (ntarg == J_SBARY || ncent == J_SBARY) { for (i = 0; i < 6; ++i) { pv[i + 6*J_SBARY] = 0.; } } if (ntarg == J_EMB || ncent == J_EMB) { for (i = 0; i < 6; ++i) pv[i + 6*J_EMB] = pv[i + 6*J_EARTH]; } if ((ntarg==J_EARTH && ncent==J_MOON) || (ntarg == J_MOON && ncent==J_EARTH)){ for (i = 0; i < 6; ++i) pv[i + 6*J_EARTH] = 0.; } else { if (list[J_EARTH] == 2) { for (i = 0; i < 6; ++i) pv[i + 6*J_EARTH] -= pv[i + 6*J_MOON] / (js->eh_emrat + 1.); } if (list[J_MOON] == 2) { for (i = 0; i < 6; ++i) { pv[i + 6*J_MOON] += pv[i + 6*J_EARTH]; } } } for (i = 0; i < 6; ++i) rrd[i] = pv[i + ntarg * 6] - pv[i + ncent * 6]; return OK; } /* * This subroutine differentiates and interpolates a * set of chebyshev coefficients to give pos, vel, acc, and jerk * calling sequence parameters: * input: * buf 1st location of array of d.p. chebyshev coefficients of position * t is dp fractional time in interval covered by * coefficients at which interpolation is wanted, 0 <= t <= 1 * intv is dp length of whole interval in input time units. * ncf number of coefficients per component * ncm number of components per set of coefficients * na number of sets of coefficients in full array * (i.e., number of sub-intervals in full interval) * ifl int flag: =1 for positions only * =2 for pos and vel * =3 for pos, vel, and acc * =4 for pos, vel, acc, and jerk * output: * pv d.p. interpolated quantities requested. * assumed dimension is pv(ncm,fl). */ static int interp(double *buf, double t, double intv, int32 ncfin, int32 ncmin, int32 nain, int32 ifl, double *pv) { /* Initialized data */ static TLS int np, nv; static TLS int nac; static TLS int njk; static TLS double twot = 0.; double *pc = js->pc; double *vc = js->vc; double *ac = js->ac; double *jc = js->jc; int ncf = (int) ncfin; int ncm = (int) ncmin; int na = (int) nain; /* Local variables */ double temp; int i, j, ni; double tc; double dt1, bma; double bma2, bma3; /* | get correct sub-interval number for this set of coefficients and then | get normalized chebyshev time within that subinterval. */ if (t >= 0) dt1 = floor(t); else dt1 = -floor(-t); temp = na * t; ni = (int) (temp - dt1); /* tc is the normalized chebyshev time (-1 <= tc <= 1) */ tc = (fmod(temp, 1.0) + dt1) * 2. - 1.; /* * check to see whether chebyshev time has changed, * and compute new polynomial values if it has. * (the element pc(2) is the value of t1(tc) and hence * contains the value of tc on the previous call.) */ if (tc != pc[1]) { np = 2; nv = 3; nac = 4; njk = 5; pc[1] = tc; twot = tc + tc; } /* * be sure that at least 'ncf' polynomials have been evaluated * and are stored in the array 'pc'. */ if (np < ncf) { for (i = np; i < ncf; ++i) pc[i] = twot * pc[i - 1] - pc[i - 2]; np = ncf; } /* interpolate to get position for each component */ for (i = 0; i < ncm; ++i) { pv[i] = 0.; for (j = ncf-1; j >= 0; --j) pv[i] += pc[j] * buf[j + (i + ni * ncm) * ncf]; } if (ifl <= 1) return 0; /* * if velocity interpolation is wanted, be sure enough * derivative polynomials have been generated and stored. */ bma = (na + na) / intv; vc[2] = twot + twot; if (nv < ncf) { for (i = nv; i < ncf; ++i) vc[i] = twot * vc[i - 1] + pc[i - 1] + pc[i - 1] - vc[i - 2]; nv = ncf; } /* interpolate to get velocity for each component */ for (i = 0; i < ncm; ++i) { pv[i + ncm] = 0.; for (j = ncf-1; j >= 1; --j) pv[i + ncm] += vc[j] * buf[j + (i + ni * ncm) * ncf]; pv[i + ncm] *= bma; } if (ifl == 2) return 0; /* check acceleration polynomial values, and */ /* re-do if necessary */ bma2 = bma * bma; ac[3] = pc[1] * 24.; if (nac < ncf) { nac = ncf; for (i = nac; i < ncf; ++i) ac[i] = twot * ac[i - 1] + vc[i - 1] * 4. - ac[i - 2]; } /* get acceleration for each component */ for (i = 0; i < ncm; ++i) { pv[i + ncm * 2] = 0.; for (j = ncf-1; j >= 2; --j) pv[i + ncm * 2] += ac[j] * buf[j + (i + ni * ncm) * ncf]; pv[i + ncm * 2] *= bma2; } if (ifl == 3) return 0; /* check jerk polynomial values, and */ /* re-do if necessary */ bma3 = bma * bma2; jc[4] = pc[1] * 192.; if (njk < ncf) { njk = ncf; for (i = njk; i < ncf; ++i) jc[i] = twot * jc[i - 1] + ac[i - 1] * 6. - jc[i - 2]; } /* get jerk for each component */ for (i = 0; i < ncm; ++i) { pv[i + ncm * 3] = 0.; for (j = ncf-1; j >= 3; --j) pv[i + ncm * 3] += jc[j] * buf[j + (i + ni * ncm) * ncf]; pv[i + ncm * 3] *= bma3; } return 0; } /* | ********** state ******************** | this subroutine reads and interpolates the jpl planetary ephemeris file | calling sequence parameters: | input: | et dp julian ephemeris epoch at which interpolation is wanted. | list 12-word integer array specifying what interpolation | is wanted for each of the bodies on the file. | list(i)=0, no interpolation for body i | =1, position only | =2, position and velocity | the designation of the astronomical bodies by i is: | i = 0: mercury | = 1: venus | = 2: earth-moon barycenter, NOT earth! | = 3: mars | = 4: jupiter | = 5: saturn | = 6: uranus | = 7: neptune | = 8: pluto | = 9: geocentric moon | =10: nutations in longitude and obliquity | =11: lunar librations (if on file) | If called with list = NULL, only the header records are read and | stored in the global areas. | do_bary short, if true, barycentric, if false, heliocentric. | only the 9 planets 0..8 are affected by it. | output: | pv dp 6 x 11 array that will contain requested interpolated | quantities. the body specified by list(i) will have its | state in the array starting at pv(1,i). (on any given | call, only those words in 'pv' which are affected by the | first 10 'list' entries (and by list(11) if librations are | on the file) are set. the rest of the 'pv' array | is untouched.) the order of components starting in | pv is: x,y,z,dx,dy,dz. | all output vectors are referenced to the earth mean | equator and equinox of epoch. the moon state is always | geocentric; the other nine states are either heliocentric | or solar-system barycentric, depending on the setting of | common flags (see below). | lunar librations, if on file, are put into pv(k,10) if | list(11) is 1 or 2. | pvsun dp 6-word array containing the barycentric position and | velocity of the sun. | nut dp 4-word array that will contain nutations and rates, | depending on the setting of list(10). the order of | quantities in nut is: | d psi (nutation in longitude) | d epsilon (nutation in obliquity) | d psi dot | d epsilon dot | globals used: | do_km logical flag defining physical units of the output states. | TRUE = return km and km/sec, FALSE = return au and au/day | default value = FALSE (km determines time unit | for nutations and librations. angle unit is always radians.) */ static int state(double et, int32 *list, int do_bary, double *pv, double *pvsun, double *nut, char *serr) { int i, j, k; int32 nseg; off_t64 flen, nb; double *buf = js->buf; double aufac, s, t, intv, ts[4]; int32 nrecl, ksize; int32 nr; double et_mn, et_fr; int32 *ipt = js->eh_ipt; char ch_ttl[252]; static TLS int32 irecsz; static TLS int32 nrl, lpt[3], ncoeffs; size_t nrd; /* unused, removes compile warnings */ if (js->jplfptr == NULL) { ksize = fsizer(serr); /* the number of single precision words in a record */ nrecl = 4; if (ksize == NOT_AVAILABLE) return NOT_AVAILABLE; irecsz = nrecl * ksize; /* record size in bytes */ ncoeffs = ksize / 2; /* # of coefficients, doubles */ /* ttl = ephemeris title, e.g. * "JPL Planetary Ephemeris DE404/LE404 * Start Epoch: JED= 625296.5-3001 DEC 21 00:00:00 * Final Epoch: JED= 2817168.5 3001 JAN 17 00:00:00c */ nrd = fread((void *) ch_ttl, 1, 252, js->jplfptr); if (nrd != 252) return NOT_AVAILABLE; /* cnam = names of constants */ nrd = fread((void *) js->ch_cnam, 1, 2400, js->jplfptr); if (nrd != 2400) return NOT_AVAILABLE; /* ss[0] = start epoch of ephemeris * ss[1] = end epoch * ss[2] = segment size in days */ nrd = fread((void *) &js->eh_ss[0], sizeof(double), 3, js->jplfptr); if (nrd != 3) return NOT_AVAILABLE; if (js->do_reorder) reorder((char *) &js->eh_ss[0], sizeof(double), 3); /* ncon = number of constants */ nrd = fread((void *) &js->eh_ncon, sizeof(int32), 1, js->jplfptr); if (nrd != 1) return NOT_AVAILABLE; if (js->do_reorder) reorder((char *) &js->eh_ncon, sizeof(int32), 1); /* au = astronomical unit */ nrd = fread((void *) &js->eh_au, sizeof(double), 1, js->jplfptr); if (nrd != 1) return NOT_AVAILABLE; if (js->do_reorder) reorder((char *) &js->eh_au, sizeof(double), 1); /* emrat = earth moon mass ratio */ nrd = fread((void *) &js->eh_emrat, sizeof(double), 1, js->jplfptr); if (nrd != 1) return NOT_AVAILABLE; if (js->do_reorder) reorder((char *) &js->eh_emrat, sizeof(double), 1); /* ipt[i+0]: coefficients of planet i start at buf[ipt[i+0]-1] * ipt[i+1]: number of coefficients (interpolation order - 1) * ipt[i+2]: number of intervals in segment */ nrd = fread((void *) &ipt[0], sizeof(int32), 36, js->jplfptr); if (nrd != 36) return NOT_AVAILABLE; if (js->do_reorder) reorder((char *) &ipt[0], sizeof(int32), 36); /* numde = number of jpl ephemeris "404" with de404 */ nrd = fread((void *) &js->eh_denum, sizeof(int32), 1, js->jplfptr); if (nrd != 1) return NOT_AVAILABLE; if (js->do_reorder) reorder((char *) &js->eh_denum, sizeof(int32), 1); nrd = fread((void *) &lpt[0], sizeof(int32), 3, js->jplfptr); if (nrd != 3) return NOT_AVAILABLE; if (js->do_reorder) reorder((char *) &lpt[0], sizeof(int32), 3); /* cval[]: other constants in next record */ FSEEK(js->jplfptr, (off_t64) (1L * irecsz), 0); nrd = fread((void *) &js->eh_cval[0], sizeof(double), 400, js->jplfptr); if (nrd != 400) return NOT_AVAILABLE; if (js->do_reorder) reorder((char *) &js->eh_cval[0], sizeof(double), 400); /* new 26-aug-2008: verify correct block size */ for (i = 0; i < 3; ++i) ipt[i + 36] = lpt[i]; nrl = 0; /* is file length correct? */ /* file length */ FSEEK(js->jplfptr, (off_t64) 0L, SEEK_END); flen = FTELL(js->jplfptr); /* # of segments in file */ nseg = (int32) ((js->eh_ss[1] - js->eh_ss[0]) / js->eh_ss[2]); /* sum of all cheby coeffs of all planets and segments */ for(i = 0, nb = 0; i < 13; i++) { k = 3; if (i == 11) k = 2; nb += (ipt[i*3+1] * ipt[i*3+2]) * k * nseg; } /* add start and end epochs of segments */ nb += 2 * nseg; /* doubles to bytes */ nb *= 8; /* add size of header and constants section */ nb += 2 * ksize * nrecl; if (flen != nb /* some of our files are one record too long */ && flen - nb != ksize * nrecl ) { if (serr != NULL) { sprintf(serr, "JPL ephemeris file is mutilated; length = %d instead of %d.", (unsigned int) flen, (unsigned int) nb); if (strlen(serr) + strlen(js->jplfname) < AS_MAXCH - 1) { sprintf(serr, "JPL ephemeris file %s is mutilated; length = %d instead of %d.", js->jplfname, (unsigned int) flen, (unsigned int) nb); } } return(NOT_AVAILABLE); } /* check if start and end dates in segments are the same as in * file header */ FSEEK(js->jplfptr, (off_t64) (2L * irecsz), 0); nrd = fread((void *) &ts[0], sizeof(double), 2, js->jplfptr); if (nrd != 2) return NOT_AVAILABLE; if (js->do_reorder) reorder((char *) &ts[0], sizeof(double), 2); FSEEK(js->jplfptr, (off_t64) ((nseg + 2 - 1) * ((off_t64) irecsz)), 0); nrd = fread((void *) &ts[2], sizeof(double), 2, js->jplfptr); if (nrd != 2) return NOT_AVAILABLE; if (js->do_reorder) reorder((char *) &ts[2], sizeof(double), 2); if (ts[0] != js->eh_ss[0] || ts[3] != js->eh_ss[1]) { if (serr != NULL) sprintf(serr, "JPL ephemeris file is corrupt; start/end date check failed. %.1f != %.1f || %.1f != %.1f", ts[0],js->eh_ss[0],ts[3],js->eh_ss[1]); return NOT_AVAILABLE; } } if (list == NULL) return 0; s = et - .5; et_mn = floor(s); et_fr = s - et_mn; /* fraction of days since previous midnight */ et_mn += .5; /* midnight before epoch */ /* error return for epoch out of range */ if (et < js->eh_ss[0] || et > js->eh_ss[1]) { if (serr != NULL) sprintf(serr,"jd %f outside JPL eph. range %.2f .. %.2f;", et, js->eh_ss[0], js->eh_ss[1]); return BEYOND_EPH_LIMITS; } /* calculate record # and relative time in interval */ nr = (int32) ((et_mn - js->eh_ss[0]) / js->eh_ss[2]) + 2; if (et_mn == js->eh_ss[1]) --nr; /* end point of ephemeris, use last record */ t = (et_mn - ((nr - 2) * js->eh_ss[2] + js->eh_ss[0]) + et_fr) / js->eh_ss[2]; /* read correct record if not in core */ if (nr != nrl) { nrl = nr; if (FSEEK(js->jplfptr, (off_t64) (nr * ((off_t64) irecsz)), 0) != 0) { if (serr != NULL) sprintf(serr, "Read error in JPL eph. at %f\n", et); return NOT_AVAILABLE; } for (k = 1; k <= ncoeffs; ++k) { if ( fread((void *) &buf[k - 1], sizeof(double), 1, js->jplfptr) != 1) { if (serr != NULL) sprintf(serr, "Read error in JPL eph. at %f\n", et); return NOT_AVAILABLE; } if (js->do_reorder) reorder((char *) &buf[k-1], sizeof(double), 1); } } if (js->do_km) { intv = js->eh_ss[2] * 86400.; aufac = 1.; } else { intv = js->eh_ss[2]; aufac = 1. / js->eh_au; } /* interpolate ssbary sun */ interp(&buf[(int) ipt[30] - 1], t, intv, ipt[31], 3L, ipt[32], 2L, pvsun); for (i = 0; i < 6; ++i) { pvsun[i] *= aufac; } /* check and interpolate whichever bodies are requested */ for (i = 0; i < 10; ++i) { if (list[i] > 0) { interp(&buf[(int) ipt[i * 3] - 1], t, intv, ipt[i * 3 + 1], 3L, ipt[i * 3 + 2], list[i], &pv[i * 6]); for (j = 0; j < 6; ++j) { if (i < 9 && ! do_bary) { pv[j + i * 6] = pv[j + i * 6] * aufac - pvsun[j]; } else { pv[j + i * 6] *= aufac; } } } } /* do nutations if requested (and if on file) */ if (list[10] > 0 && ipt[34] > 0) { interp(&buf[(int) ipt[33] - 1], t, intv, ipt[34], 2L, ipt[35], list[10], nut); } /* get librations if requested (and if on file) */ if (list[11] > 0 && ipt[37] > 0) { interp(&buf[(int) ipt[36] - 1], t, intv, ipt[37], 3L, ipt[38], list[1], &pv[60]); } return OK; } /* * this entry obtains the constants from the ephemeris file * call state to initialize the ephemeris and read in the constants */ static int read_const_jpl(double *ss, char *serr) { int i, retc; retc = state(0.0, NULL, FALSE, NULL, NULL, NULL, serr); if (retc != OK) return (retc); for (i = 0; i < 3; i++) ss[i] = js->eh_ss[i]; #if DEBUG_DO_SHOW { static const char *bname[] = { "Mercury", "Venus", "EMB", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune", "Pluto", "Moon", "SunBary", "Nut", "Libr"}; int j, k; int32 nb, nc; printf(" JPL TEST-EPHEMERIS program. Version October 1995.\n"); for (i = 0; i < 13; i++) { j = i * 3; k = 3; if (i == 11) k = 2; nb = js->eh_ipt[j+1] * js->eh_ipt[j+2] * k; nc = (int32) (nb * 36525L / js->eh_ss[2] * 8L); printf("%s\t%d\tipt[%d]\t%3ld %2ld %2ld,\t", bname[i], i, j, js->eh_ipt[j], js->eh_ipt[j+1], js->eh_ipt[j+2]); printf("%3ld double, bytes per century = %6ld\n", nb, nc); fflush(stdout); } printf("%16.2f %16.2f %16.2f\n", js->eh_ss[0], js->eh_ss[1], js->eh_ss[2]); for (i = 0; i < js->eh_ncon; ++i) printf("%.6s\t%24.16f\n", js->ch_cnam + i * 6, js->eh_cval[i]); fflush(stdout); } #endif return OK; } static void reorder(char *x, int size, int number) { int i, j; char s[8]; char *sp1 = x; char *sp2 = &s[0]; for (i = 0; i < number; i++) { for (j = 0; j < size; j++) *(sp2 + j) = *(sp1 + size - j - 1); for (j = 0; j < size; j++) *(sp1 + j) = *(sp2 + j); sp1 += size; } } void swi_close_jpl_file(void) { if (js != NULL) { if (js->jplfptr != NULL) fclose(js->jplfptr); if (js->jplfname != NULL) FREE((void *) js->jplfname); if (js->jplfpath != NULL) FREE((void *) js->jplfpath); FREE((void *) js); js = NULL; } } int swi_open_jpl_file(double *ss, char *fname, char *fpath, char *serr) { int retc = OK; /* if open, return */ if (js != NULL && js->jplfptr != NULL) return OK; if ((js = (struct jpl_save *) CALLOC(1, sizeof(struct jpl_save))) == NULL || (js->jplfname = (char *) MALLOC(strlen(fname)+1)) == NULL || (js->jplfpath = (char *) MALLOC(strlen(fpath)+1)) == NULL ) { if (serr != NULL) strcpy(serr, "error in malloc() with JPL ephemeris."); return ERR; } strcpy(js->jplfname, fname); strcpy(js->jplfpath, fpath); retc = read_const_jpl(ss, serr); if (retc != OK) swi_close_jpl_file(); else { /* intializations for function interpol() */ js->pc[0] = 1; js->pc[1] = 2; js->vc[1] = 1; js->ac[2] = 4; js->jc[3] = 24; } return retc; } int32 swi_get_jpl_denum(void) { return js->eh_denum; }