/* $Procedure LS ( Return L_s, planetocentric longitude of the sun ) */
doublereal ls_(integer *body, doublereal *et, char *corr, ftnlen corr_len)
{
/* System generated locals */
integer i__1, i__2;
doublereal ret_val;
/* Builtin functions */
integer s_rnge(char *, integer, char *, integer);
/* Local variables */
doublereal tipm[9] /* was [3][3] */;
extern /* Subroutine */ int vequ_(doublereal *, doublereal *);
integer i__;
doublereal x[3], y[3], z__[3];
extern /* Subroutine */ int chkin_(char *, ftnlen);
doublereal uavel[3], npole[3], state[6], trans[9] /* was [3][3] */;
extern /* Subroutine */ int spkez_(integer *, doublereal *, char *, char *
, integer *, doublereal *, doublereal *, ftnlen, ftnlen), ucrss_(
doublereal *, doublereal *, doublereal *);
doublereal lt;
extern /* Subroutine */ int reclat_(doublereal *, doublereal *,
doublereal *, doublereal *), tipbod_(char *, integer *,
doublereal *, doublereal *, ftnlen);
doublereal radius;
extern /* Subroutine */ int chkout_(char *, ftnlen);
extern logical return_(void);
doublereal lat, pos[3];
extern /* Subroutine */ int mxv_(doublereal *, doublereal *, doublereal *)
;
/* $ Abstract */
/* Compute L_s, the planetocentric longitude of the sun, as seen */
/* from a specified body. */
/* $ Disclaimer */
/* THIS SOFTWARE AND ANY RELATED MATERIALS WERE CREATED BY THE */
/* CALIFORNIA INSTITUTE OF TECHNOLOGY (CALTECH) UNDER A U.S. */
/* GOVERNMENT CONTRACT WITH THE NATIONAL AERONAUTICS AND SPACE */
/* ADMINISTRATION (NASA). THE SOFTWARE IS TECHNOLOGY AND SOFTWARE */
/* PUBLICLY AVAILABLE UNDER U.S. EXPORT LAWS AND IS PROVIDED "AS-IS" */
/* TO THE RECIPIENT WITHOUT WARRANTY OF ANY KIND, INCLUDING ANY */
/* WARRANTIES OF PERFORMANCE OR MERCHANTABILITY OR FITNESS FOR A */
/* PARTICULAR USE OR PURPOSE (AS SET FORTH IN UNITED STATES UCC */
/* SECTIONS 2312-2313) OR FOR ANY PURPOSE WHATSOEVER, FOR THE */
/* SOFTWARE AND RELATED MATERIALS, HOWEVER USED. */
/* IN NO EVENT SHALL CALTECH, ITS JET PROPULSION LABORATORY, OR NASA */
/* BE LIABLE FOR ANY DAMAGES AND/OR COSTS, INCLUDING, BUT NOT */
/* LIMITED TO, INCIDENTAL OR CONSEQUENTIAL DAMAGES OF ANY KIND, */
/* INCLUDING ECONOMIC DAMAGE OR INJURY TO PROPERTY AND LOST PROFITS, */
/* REGARDLESS OF WHETHER CALTECH, JPL, OR NASA BE ADVISED, HAVE */
/* REASON TO KNOW, OR, IN FACT, SHALL KNOW OF THE POSSIBILITY. */
/* RECIPIENT BEARS ALL RISK RELATING TO QUALITY AND PERFORMANCE OF */
/* THE SOFTWARE AND ANY RELATED MATERIALS, AND AGREES TO INDEMNIFY */
/* CALTECH AND NASA FOR ALL THIRD-PARTY CLAIMS RESULTING FROM THE */
/* ACTIONS OF RECIPIENT IN THE USE OF THE SOFTWARE. */
/* $ Required_Reading */
/* None. */
/* $ Keywords */
/* GEOMETRY */
/* $ Declarations */
/* $ Brief_I/O */
/* Variable I/O Description */
/* -------- --- -------------------------------------------------- */
/* BODY I NAIF integer code of central body. */
/* ET I Epoch in ephemeris seconds past J2000. */
/* CORR I Aberration correction. */
/* The function returns the value of L_s for the specified body */
/* at the specified time. */
/* $ Detailed_Input */
/* BODY is the NAIF integer code of the central body, */
/* typically a planet. */
/* ET is the epoch in ephemeris seconds past J2000 at which */
/* the longitude of the sun (L_s) is to be computed. */
/* CORR indicates the aberration corrections to be applied */
/* when computing the longitude of the sun. CORR */
/* may be any of the following. */
/* 'NONE' Apply no correction. */
/* 'LT' Correct the position of the sun, */
/* relative to the central body, for */
/* planetary (light time) aberration. */
/* 'LT+S' Correct the position of the sun, */
/* relative to the central body, for */
/* planetary and stellar aberrations. */
/* $ Detailed_Output */
/* The function returns the value of L_s for the specified body */
/* at the specified time. This is the longitude of the Sun, */
/* relative to the central body, in a right-handed frame whose */
/* basis vectors are defined as follows: */
/* - The positive Z direction is given by the instantaneous */
/* angular velocity vector of the orbit of the body about */
/* the sun. */
/* - The positive X direction is that of the cross product of the */
/* instantaneous north spin axis of the body with the positive */
/* Z direction. */
/* - The positive Y direction is Z x X. */
/* Units are radians; the range is -pi to pi. Longitudes are */
/* positive east. */
/* $ Parameters */
/* None. */
/* $ Exceptions */
/* 1) If no SPK (ephemeris) file has been loaded prior to calling */
/* this routine, or if the SPK data has insufficient coverage, an */
/* error will be diagnosed and signaled by a routine in the call */
/* tree of this routine. */
/* 2) If a PCK file containing rotational elements for the central */
/* body has not been loaded prior to calling this routine, an */
/* error will be diagnosed and signaled by a routine called by a */
/* routine in the call tree of this routine. */
/* 3) If the instantaneous angular velocity and spin axis of BODY */
/* are parallel, the return value is unspecified. */
/* $ Files */
/* 1) An SPK file (or file) containing ephemeris data sufficient to */
/* compute the geometric state of the central body relative to */
/* the sun at ET must be loaded before this routine is called. If */
/* light time correction is used, data must be available that */
/* enable computation of the state the sun relative to the solar */
/* system barycenter at the light-time corrected epoch. If */
/* stellar aberration correction is used, data must be available */
/* that enable computation of the state the central body relative */
/* to the solar system barycenter at ET. */
/* 2) A PCK file containing rotational elements for the central body */
/* must be loaded before this routine is called. */
/* $ Particulars */
/* The direction of the vernal equinox for the central body is */
/* determined from the instantaneous equatorial and orbital planes */
/* of the central body. This equinox definition is specified in */
/* reference [1]. The "instantaneous orbital plane" is interpreted */
/* in this routine as the plane normal to the cross product of the */
/* position and velocity of the central body relative to the sun. */
/* A geometric state is used for this normal vector computation. */
/* The "instantaneous equatorial plane" is that normal to the */
/* central body's north pole at the requested epoch. The pole */
/* direction is determined from rotational elements loaded via */
/* a PCK file. */
/* The result returned by this routine will depend on the */
/* ephemeris data and rotational elements used. The result may */
/* differ from that given in any particular version of the */
/* Astronomical Almanac, due to differences in these input data, */
/* and due to differences in precision of the computations. */
/* $ Examples */
/* 1) A simple program that computes L_s for Mars. The geometric */
/* state of the sun is used. */
/* PROGRAM MARS_LS */
/* IMPLICIT NONE */
/* DOUBLE PRECISION DPR */
/* INTEGER FILSIZ */
/* PARAMETER ( FILSIZ = 255 ) */
/* CHARACTER*(FILSIZ) PCK */
/* CHARACTER*(FILSIZ) SPK */
/* CHARACTER*(FILSIZ) LEAP */
/* CHARACTER*(30) UTC */
/* CHARACTER*(15) CORR */
/* DOUBLE PRECISION ET */
/* DOUBLE PRECISION LONG */
/* DOUBLE PRECISION LS */
/* INTEGER BODY */
/* INTEGER HANDLE */
/* DATA BODY / 499 / */
/* DATA CORR / 'NONE' / */
/* CALL PROMPT ( 'Enter name of leapseconds kernel > ', LEAP ) */
/* CALL PROMPT ( 'Enter name of PCK file > ', PCK ) */
/* CALL PROMPT ( 'Enter name of SPK file > ', SPK ) */
/* CALL FURNSH ( LEAP ) */
/* CALL FURNSH ( PCK ) */
/* CALL FURNSH ( SPK ) */
/* WRITE (*,*) ' ' */
/* WRITE (*,*) 'Kernels have been loaded.' */
/* WRITE (*,*) ' ' */
/* DO WHILE ( .TRUE. ) */
/* CALL PROMPT ( 'Enter UTC time > ', UTC ) */
/* CALL UTC2ET ( UTC, ET ) */
/* C */
/* C Convert longitude to degrees and move it into the range */
/* C [0, 360). */
/* C */
/* LONG = DPR() * LS ( BODY, ET, CORR ) */
/* IF ( LONG .LT. 0.D0 ) THEN */
/* LONG = LONG + 360.D0 */
/* END IF */
/* WRITE (*,*) ' ' */
/* WRITE (*,*) 'Mars L_s (deg.) = ', LONG */
/* WRITE (*,*) ' ' */
/* END DO */
/* END */
/* $ Restrictions */
/* None. */
/* $ Literature_References */
/* [1] "The Astronomical Almanac for the Year 2005." U.S. Government */
/* Printing Office, Washington, D.C., 1984, page L9. */
/* $ Author_and_Institution */
/* N.J. Bachman (JPL) */
/* $ Version */
/* - Chronos Version 1.1.2, 02-OCT-2006 (BVS) */
/* Replaced LDPOOL and SPKELF with FURNSH in the Examples */
/* section. */
/* - Chronos Version 1.1.1, 07-JAN-2005 (NJB) */
/* Description of reference frame in Detailed_Output header */
/* section was corrected. Miscellaneous other header updates */
/* were made. */
/* - Beta Version 1.1.0, 14-DEC-1996 (NJB) */
/* -& */
/* SPICELIB functions */
/* Local parameters */
/* Local variables */
/* Standard SPICE error handling. */
if (return_()) {
ret_val = 0.;
return ret_val;
} else {
chkin_("LS", (ftnlen)2);
}
/* Look up the direction of the North pole of the central body. */
tipbod_("J2000", body, et, tipm, (ftnlen)5);
for (i__ = 1; i__ <= 3; ++i__) {
npole[(i__1 = i__ - 1) < 3 && 0 <= i__1 ? i__1 : s_rnge("npole", i__1,
"ls_", (ftnlen)302)] = tipm[(i__2 = i__ * 3 - 1) < 9 && 0 <=
i__2 ? i__2 : s_rnge("tipm", i__2, "ls_", (ftnlen)302)];
}
/* Get the geometric state of the body relative to the sun. */
spkez_(body, et, "J2000", "NONE", &c__10, state, <, (ftnlen)5, (ftnlen)
4);
/* Get the unit direction vector parallel to the angular velocity */
/* vector of the orbit. This is just the unitized cross product of */
/* position and velocity. */
ucrss_(state, &state[3], uavel);
/* We want to form a transformation matrix that maps vectors from */
/* basis REF to the following frame: */
/* Z = UAVEL */
/* X = NPOLE x UAVEL */
/* Y = Z x X */
/* We'll find the position of the Sun relative to this frame. In */
/* our computations, we want our basis vectors to have unit length. */
vequ_(uavel, z__);
ucrss_(npole, z__, x);
ucrss_(z__, x, y);
for (i__ = 1; i__ <= 3; ++i__) {
trans[(i__1 = i__ * 3 - 3) < 9 && 0 <= i__1 ? i__1 : s_rnge("trans",
i__1, "ls_", (ftnlen)335)] = x[(i__2 = i__ - 1) < 3 && 0 <=
i__2 ? i__2 : s_rnge("x", i__2, "ls_", (ftnlen)335)];
trans[(i__1 = i__ * 3 - 2) < 9 && 0 <= i__1 ? i__1 : s_rnge("trans",
i__1, "ls_", (ftnlen)336)] = y[(i__2 = i__ - 1) < 3 && 0 <=
i__2 ? i__2 : s_rnge("y", i__2, "ls_", (ftnlen)336)];
trans[(i__1 = i__ * 3 - 1) < 9 && 0 <= i__1 ? i__1 : s_rnge("trans",
i__1, "ls_", (ftnlen)337)] = z__[(i__2 = i__ - 1) < 3 && 0 <=
i__2 ? i__2 : s_rnge("z", i__2, "ls_", (ftnlen)337)];
}
/* Get the state of the sun in frame REF. Since we may be using */
/* aberration corrections, this is not necessarily the negative of */
/* the state we've just found. */
spkez_(&c__10, et, "J2000", corr, body, state, <, (ftnlen)5, corr_len);
/* Now transform the position of the Sun into the "equator and */
/* equinox" frame. */
mxv_(trans, state, pos);
/* Let RECLAT find the longitude LS for us. */
reclat_(pos, &radius, &ret_val, &lat);
chkout_("LS", (ftnlen)2);
return ret_val;
} /* ls_ */
/* $Procedure ILLUM ( Illumination angles ) */
/* Subroutine */ int illum_(char *target, doublereal *et, char *abcorr, char *
obsrvr, doublereal *spoint, doublereal *phase, doublereal *solar,
doublereal *emissn, ftnlen target_len, ftnlen abcorr_len, ftnlen
obsrvr_len)
{
/* Initialized data */
static logical first = TRUE_;
extern /* Subroutine */ int zzbods2c_(integer *, char *, integer *,
logical *, char *, integer *, logical *, ftnlen, ftnlen);
extern doublereal vsep_(doublereal *, doublereal *);
extern /* Subroutine */ int vsub_(doublereal *, doublereal *, doublereal *
), vequ_(doublereal *, doublereal *), zzctruin_(integer *);
integer n;
doublereal radii[3];
extern /* Subroutine */ int chkin_(char *, ftnlen), errch_(char *, char *,
ftnlen, ftnlen);
logical found;
extern /* Subroutine */ int spkez_(integer *, doublereal *, char *, char *
, integer *, doublereal *, doublereal *, ftnlen, ftnlen);
extern logical eqstr_(char *, char *, ftnlen, ftnlen);
static logical svfnd1, svfnd2;
static integer svctr1[2], svctr2[2];
integer obscde;
doublereal lt;
extern /* Subroutine */ int bodvcd_(integer *, char *, integer *, integer
*, doublereal *, ftnlen);
integer frcode;
extern /* Subroutine */ int cidfrm_(integer *, integer *, char *, logical
*, ftnlen);
char frname[80];
integer trgcde;
doublereal offobs[3], obsvec[3], tepoch, normal[3];
static integer svtcde;
extern /* Subroutine */ int sigerr_(char *, ftnlen), chkout_(char *,
ftnlen);
static integer svobsc;
doublereal offsun[3];
extern /* Subroutine */ int setmsg_(char *, ftnlen);
doublereal sstate[6], sunvec[3], tstate[6];
static char svtarg[36];
extern /* Subroutine */ int surfnm_(doublereal *, doublereal *,
doublereal *, doublereal *, doublereal *);
extern logical return_(void);
static char svobsr[36];
extern /* Subroutine */ int vminus_(doublereal *, doublereal *);
doublereal lts;
/* $ Abstract */
/* Deprecated: This routine has been superseded by the SPICELIB */
/* routine ILUMIN. This routine is supported for purposes of */
/* backward compatibility only. */
/* Find the illumination angles at a specified surface point of a */
/* target body. */
/* $ Disclaimer */
/* THIS SOFTWARE AND ANY RELATED MATERIALS WERE CREATED BY THE */
/* CALIFORNIA INSTITUTE OF TECHNOLOGY (CALTECH) UNDER A U.S. */
/* GOVERNMENT CONTRACT WITH THE NATIONAL AERONAUTICS AND SPACE */
/* ADMINISTRATION (NASA). THE SOFTWARE IS TECHNOLOGY AND SOFTWARE */
/* PUBLICLY AVAILABLE UNDER U.S. EXPORT LAWS AND IS PROVIDED "AS-IS" */
/* TO THE RECIPIENT WITHOUT WARRANTY OF ANY KIND, INCLUDING ANY */
/* WARRANTIES OF PERFORMANCE OR MERCHANTABILITY OR FITNESS FOR A */
/* PARTICULAR USE OR PURPOSE (AS SET FORTH IN UNITED STATES UCC */
/* SECTIONS 2312-2313) OR FOR ANY PURPOSE WHATSOEVER, FOR THE */
/* SOFTWARE AND RELATED MATERIALS, HOWEVER USED. */
/* IN NO EVENT SHALL CALTECH, ITS JET PROPULSION LABORATORY, OR NASA */
/* BE LIABLE FOR ANY DAMAGES AND/OR COSTS, INCLUDING, BUT NOT */
/* LIMITED TO, INCIDENTAL OR CONSEQUENTIAL DAMAGES OF ANY KIND, */
/* INCLUDING ECONOMIC DAMAGE OR INJURY TO PROPERTY AND LOST PROFITS, */
/* REGARDLESS OF WHETHER CALTECH, JPL, OR NASA BE ADVISED, HAVE */
/* REASON TO KNOW, OR, IN FACT, SHALL KNOW OF THE POSSIBILITY. */
/* RECIPIENT BEARS ALL RISK RELATING TO QUALITY AND PERFORMANCE OF */
/* THE SOFTWARE AND ANY RELATED MATERIALS, AND AGREES TO INDEMNIFY */
/* CALTECH AND NASA FOR ALL THIRD-PARTY CLAIMS RESULTING FROM THE */
/* ACTIONS OF RECIPIENT IN THE USE OF THE SOFTWARE. */
/* $ Required_Reading */
/* KERNEL */
/* NAIF_IDS */
/* SPK */
/* TIME */
/* $ Keywords */
/* GEOMETRY */
/* MOSPICE */
/* $ Declarations */
/* $ Abstract */
/* This include file defines the dimension of the counter */
/* array used by various SPICE subsystems to uniquely identify */
/* changes in their states. */
/* $ Disclaimer */
/* THIS SOFTWARE AND ANY RELATED MATERIALS WERE CREATED BY THE */
/* CALIFORNIA INSTITUTE OF TECHNOLOGY (CALTECH) UNDER A U.S. */
/* GOVERNMENT CONTRACT WITH THE NATIONAL AERONAUTICS AND SPACE */
/* ADMINISTRATION (NASA). THE SOFTWARE IS TECHNOLOGY AND SOFTWARE */
/* PUBLICLY AVAILABLE UNDER U.S. EXPORT LAWS AND IS PROVIDED "AS-IS" */
/* TO THE RECIPIENT WITHOUT WARRANTY OF ANY KIND, INCLUDING ANY */
/* WARRANTIES OF PERFORMANCE OR MERCHANTABILITY OR FITNESS FOR A */
/* PARTICULAR USE OR PURPOSE (AS SET FORTH IN UNITED STATES UCC */
/* SECTIONS 2312-2313) OR FOR ANY PURPOSE WHATSOEVER, FOR THE */
/* SOFTWARE AND RELATED MATERIALS, HOWEVER USED. */
/* IN NO EVENT SHALL CALTECH, ITS JET PROPULSION LABORATORY, OR NASA */
/* BE LIABLE FOR ANY DAMAGES AND/OR COSTS, INCLUDING, BUT NOT */
/* LIMITED TO, INCIDENTAL OR CONSEQUENTIAL DAMAGES OF ANY KIND, */
/* INCLUDING ECONOMIC DAMAGE OR INJURY TO PROPERTY AND LOST PROFITS, */
/* REGARDLESS OF WHETHER CALTECH, JPL, OR NASA BE ADVISED, HAVE */
/* REASON TO KNOW, OR, IN FACT, SHALL KNOW OF THE POSSIBILITY. */
/* RECIPIENT BEARS ALL RISK RELATING TO QUALITY AND PERFORMANCE OF */
/* THE SOFTWARE AND ANY RELATED MATERIALS, AND AGREES TO INDEMNIFY */
/* CALTECH AND NASA FOR ALL THIRD-PARTY CLAIMS RESULTING FROM THE */
/* ACTIONS OF RECIPIENT IN THE USE OF THE SOFTWARE. */
/* $ Parameters */
/* CTRSIZ is the dimension of the counter array used by */
/* various SPICE subsystems to uniquely identify */
/* changes in their states. */
/* $ Author_and_Institution */
/* B.V. Semenov (JPL) */
/* $ Literature_References */
/* None. */
/* $ Version */
/* - SPICELIB Version 1.0.0, 29-JUL-2013 (BVS) */
/* -& */
/* End of include file. */
/* $ Brief_I/O */
/* Variable I/O Description */
/* -------- --- -------------------------------------------------- */
/* TARGET I Name of target body. */
/* ET I Epoch in ephemeris seconds past J2000. */
/* ABCORR I Desired aberration correction. */
/* OBSRVR I Name of observing body. */
/* SPOINT I Body-fixed coordinates of a target surface point. */
/* PHASE O Phase angle at the surface point. */
/* SOLAR O Solar incidence angle at the surface point. */
/* EMISSN O Emission angle at the surface point. */
/* $ Detailed_Input */
/* TARGET is the name of the target body. TARGET is */
/* case-insensitive, and leading and trailing blanks */
/* in TARGET are not significant. Optionally, you may */
/* supply a string containing the integer ID code for */
/* the object. For example both 'MOON' and '301' are */
/* legitimate strings that indicate the moon is the */
/* target body. */
/* ET is the epoch, specified in ephemeris seconds past */
/* J2000, at which the apparent illumination angles at */
/* the specified surface point on the target body, as */
/* seen from the observing body, are to be computed. */
/* ABCORR is the aberration correction to be used in */
/* computing the location and orientation of the */
/* target body and the location of the Sun. Possible */
/* values are: */
/* 'NONE' No aberration correction. */
/* 'LT' Correct the position and */
/* orientation of target body for */
/* light time, and correct the */
/* position of the Sun for light */
/* time. */
/* 'LT+S' Correct the observer-target vector */
/* for light time and stellar */
/* aberration, correct the */
/* orientation of the target body */
/* for light time, and correct the */
/* target-Sun vector for light time */
/* and stellar aberration. */
/* 'CN' Converged Newtonian light time */
/* correction. In solving the light */
/* time equation, the 'CN' */
/* correction iterates until the */
/* solution converges (three */
/* iterations on all supported */
/* platforms). Whether the 'CN+S' */
/* solution is substantially more */
/* accurate than the 'LT' solution */
/* depends on the geometry of the */
/* participating objects and on the */
/* accuracy of the input data. In */
/* all cases this routine will */
/* execute more slowly when a */
/* converged solution is computed. */
/* See the Particulars section of */
/* SPKEZR for a discussion of */
/* precision of light time */
/* corrections. */
/* Both the state and rotation of */
/* the target body are corrected for */
/* light time. */
/* 'CN+S' Converged Newtonian light time */
/* correction and stellar aberration */
/* correction. */
/* Both the state and rotation of */
/* the target body are corrected for */
/* light time. */
/* OBSRVR is the name of the observing body, typically a */
/* spacecraft, the earth, or a surface point on the */
/* earth. OBSRVR is case-insensitive, and leading */
/* and trailing blanks in OBSRVR are not significant. */
/* Optionally, you may supply a string containing the */
/* integer ID code for the object. For example both */
/* 'EARTH' and '399' are legitimate strings that */
/* indicate the earth is the observer. */
/* OBSRVR may be not be identical to TARGET. */
/* SPOINT is a surface point on the target body, expressed */
/* in rectangular body-fixed (body equator and prime */
/* meridian) coordinates. SPOINT need not be visible */
/* from the observer's location at time ET. */
/* $ Detailed_Output */
/* PHASE is the phase angle at SPOINT, as seen from OBSRVR */
/* at time ET. This is the angle between the */
/* SPOINT-OBSRVR vector and the SPOINT-Sun vector. */
/* Units are radians. The range of PHASE is [0, pi]. */
/* See Particulars below for a detailed discussion of */
/* the definition. */
/* SOLAR is the solar incidence angle at SPOINT, as seen */
/* from OBSRVR at time ET. This is the angle */
/* between the surface normal vector at SPOINT and the */
/* SPOINT-Sun vector. Units are radians. The range */
/* of SOLAR is [0, pi]. See Particulars below for a */
/* detailed discussion of the definition. */
/* EMISSN is the emission angle at SPOINT, as seen from */
/* OBSRVR at time ET. This is the angle between the */
/* surface normal vector at SPOINT and the */
/* SPOINT-observer vector. Units are radians. The */
/* range of EMISSN is [0, pi]. See Particulars below */
/* for a detailed discussion of the definition. */
/* $ Parameters */
/* None. */
/* $ Exceptions */
/* 1) If TARGET and OBSRVR are not distinct, the error */
/* SPICE(BODIESNOTDISTINCT) will be signaled. */
/* 2) If no SPK (ephemeris) data are available for the observer, */
/* target, and Sun at the time specified by ET, the error will */
/* be diagnosed by routines called by this routine. If light */
/* time corrections are used, SPK data for the target body must */
/* be available at the time ET - LT, where LT is the one-way */
/* light time from the target to the observer at ET. */
/* Additionally, SPK data must be available for the Sun at the */
/* time ET - LT - LT2, where LT2 is the light time from the Sun */
/* to the target body at time ET - LT. */
/* 3) If PCK data defining the orientation or shape of the target */
/* body are unavailable, the error will be diagnosed by routines */
/* called by this routine. */
/* 4) If no body-fixed frame is associated with the target body, */
/* the error SPICE(NOFRAME) is signaled. */
/* 5) If name of target or observer cannot be translated to its */
/* NAIF ID code, the error SPICE(IDCODENOTFOUND) is signaled. */
/* $ Files */
/* No files are input to this routine. However, ILLUM expects */
/* that the appropriate SPK and PCK files have been loaded via */
/* FURNSH. */
/* $ Particulars */
/* The term "illumination angles" refers to following set of */
/* angles: */
/* solar incidence angle Angle between the surface normal at */
/* the specified surface point and the */
/* vector from the surface point to the */
/* Sun. */
/* emission angle Angle between the surface normal at */
/* the specified surface point and the */
/* vector from the surface point to the */
/* observer. */
/* phase angle Angle between the vectors from the */
/* surface point to the observing body's */
/* location and from the surface point */
/* to the Sun. */
/* The diagram below illustrates the geometrical relationships */
/* defining these angles. The labels for the solar incidence, */
/* emission, and phase angles are "s.i.", "e.", and "phase". */
/* * */
/* Sun */
/* surface normal vector */
/* ._ _. */
/* |\ /| Sun vector */
/* \ phase / */
/* \ . . / */
/* . . */
/* \ ___ / */
/* . \/ \/ */
/* _\ s.i./ */
/* . / \ / */
/* . | e. \ / */
/* * <--------------- * surface point on */
/* viewing vector target body */
/* location to viewing */
/* (observer) location */
/* Note that if the target-observer vector, the target normal vector */
/* at the surface point, and the target-sun vector are coplanar, */
/* then phase is the sum of incidence and emission. This is rarely */
/* true; usually */
/* phase angle < solar incidence angle + emission angle */
/* All of the above angles can be computed using light time */
/* corrections, light time and stellar aberration corrections, or */
/* no aberration corrections. The way aberration corrections */
/* are used is described below. */
/* Care must be used in computing light time corrections. The */
/* guiding principle used here is "describe what appears in */
/* an image." We ignore differential light time; the light times */
/* from all points on the target to the observer are presumed to be */
/* equal. */
/* Observer-target body vector */
/* --------------------------- */
/* Let ET be the epoch at which an observation or remote */
/* sensing measurement is made, and let ET - LT ("LT" stands */
/* for "light time") be the epoch at which the photons received */
/* at ET were emitted from the body (we use the term "emitted" */
/* loosely here). */
/* The correct observer-target vector points from the observer's */
/* location at ET to the target body's location at ET - LT. */
/* The target-observer vector points in the opposite direction. */
/* Since light time corrections are not symmetric, the correct */
/* target-observer vector CANNOT be found by computing the light */
/* time corrected position of the observer as seen from the */
/* target body. */
/* Target body's orientation */
/* ------------------------- */
/* Using the definitions of ET and LT above, the target */
/* body's orientation at ET - LT is used. The surface */
/* normal is dependent on the target body's orientation, so */
/* the body's orientation model must be evaluated for the correct */
/* epoch. */
/* Target body -- Sun vector */
/* ------------------------- */
/* All surface features on the target body will appear in */
/* a measurement made at ET as they were at ET-LT. In */
/* particular, lighting on the target body is dependent on */
/* the apparent location of the Sun as seen from the target */
/* body at ET-LT. So, a second light time correction is used */
/* in finding the apparent location of the Sun. */
/* Stellar aberration corrections, when used, are applied as follows: */
/* Observer-target body vector */
/* --------------------------- */
/* In addition to light time correction, stellar aberration is */
/* used in computing the apparent target body position as seen */
/* from the observer's location at time ET. This apparent */
/* position defines the observer-target body vector. */
/* Target body-Sun vector */
/* ---------------------- */
/* The target body-Sun vector is the apparent position of the Sun, */
/* corrected for light time and stellar aberration, as seen from */
/* the target body at time ET-LT. Note that the target body's */
/* position is not affected by the stellar aberration correction */
/* applied in finding its apparent position as seen by the */
/* observer. */
/* Once all of the vectors, as well as the target body's */
/* orientation, have been computed with the proper aberration */
/* corrections, the element of time is eliminated from the */
/* computation. The problem becomes a purely geometrical one, */
/* and is described by the diagram above. */
/* $ Examples */
/* The numerical results shown for this example may differ across */
/* platforms. The results depend on the SPICE kernels used as */
/* input, the compiler and supporting libraries, and the machine */
/* specific arithmetic implementation. */
/* In the following example program, the file */
/* spk_m_031103-040201_030502.bsp */
/* is a binary SPK file containing data for Mars Global Surveyor, */
/* Mars, and the Sun for a time interval bracketing the date */
/* 2004 JAN 1 12:00:00 UTC. */
/* pck00007.tpc is a planetary constants kernel file containing */
/* radii and rotation model constants. naif0007.tls is a */
/* leapseconds kernel. */
/* Find the phase, solar incidence, and emission angles at the */
/* sub-solar and sub-spacecraft points on Mars as seen from the */
/* Mars Global Surveyor spacecraft at a specified UTC time. */
/* Use light time and stellar aberration corrections. */
/* PROGRAM ANGLES */
/* IMPLICIT NONE */
/* C */
/* C SPICELIB functions */
/* C */
/* DOUBLE PRECISION DPR */
/* C */
/* C Local parameters */
/* C */
/* INTEGER NAMLEN */
/* PARAMETER ( NAMLEN = 32 ) */
/* INTEGER TIMLEN */
/* PARAMETER ( TIMLEN = 25 ) */
/* C */
/* C Local variables */
/* C */
/* CHARACTER*(NAMLEN) OBSRVR */
/* CHARACTER*(NAMLEN) TARGET */
/* CHARACTER*(TIMLEN) UTC */
/* DOUBLE PRECISION ALT */
/* DOUBLE PRECISION ET */
/* DOUBLE PRECISION SSCEMI */
/* DOUBLE PRECISION SSCPHS */
/* DOUBLE PRECISION SSCSOL */
/* DOUBLE PRECISION SSLEMI */
/* DOUBLE PRECISION SSLPHS */
/* DOUBLE PRECISION SSLSOL */
/* DOUBLE PRECISION SSOLPT ( 3 ) */
/* DOUBLE PRECISION SSCPT ( 3 ) */
/* C */
/* C Load kernel files. */
/* C */
/* CALL FURNSH ( 'naif0007.tls' ) */
/* CALL FURNSH ( 'pck00007.tpc' ) */
/* CALL FURNSH ( 'spk_m_031103-040201_030502.bsp' ) */
/* C */
/* C Convert our UTC time to ephemeris seconds past J2000. */
/* C */
/* UTC = '2004 JAN 1 12:00:00' */
/* CALL UTC2ET ( UTC, ET ) */
/* C */
/* C Assign observer and target names. The acronym MGS */
/* C indicates Mars Global Surveyor. See NAIF_IDS for a */
/* C list of names recognized by SPICE. */
/* C */
/* TARGET = 'Mars' */
/* OBSRVR = 'MGS' */
/* C */
/* C Find the sub-solar point on the Earth as seen from */
/* C the MGS spacecraft at ET. Use the "surface intercept" */
/* C style of sub-point definition. This makes it easy */
/* C to verify the solar incidence angle. */
/* C */
/* CALL SUBSOL ( 'Near point', TARGET, ET, */
/* . 'LT+S', OBSRVR, SSOLPT ) */
/* C */
/* C Now find the sub-spacecraft point. Use the */
/* C "nearest point" definition of the sub-point */
/* C here---this makes it easy to verify the emission angle. */
/* C */
/* CALL SUBPT ( 'Near point', TARGET, ET, */
/* . 'LT+S', OBSRVR, SSCPT, ALT ) */
/* C */
/* C Find the phase, solar incidence, and emission */
/* C angles at the sub-solar point on the Earth as seen */
/* C from Mars Observer at time ET. */
/* C */
/* CALL ILLUM ( TARGET, ET, 'LT+S', OBSRVR, */
/* . SSOLPT, SSLPHS, SSLSOL, SSLEMI ) */
/* C */
/* C Do the same for the sub-spacecraft point. */
/* C */
/* CALL ILLUM ( TARGET, ET, 'LT+S', OBSRVR, */
/* . SSCPT, SSCPHS, SSCSOL, SSCEMI ) */
/* C */
/* C Convert the angles to degrees and write them out. */
/* C */
/* SSLPHS = DPR() * SSLPHS */
/* SSLSOL = DPR() * SSLSOL */
/* SSLEMI = DPR() * SSLEMI */
/* SSCPHS = DPR() * SSCPHS */
/* SSCSOL = DPR() * SSCSOL */
/* SSCEMI = DPR() * SSCEMI */
/* WRITE (*,*) ' ' */
/* WRITE (*,*) 'UTC epoch is ', UTC */
/* WRITE (*,*) ' ' */
/* WRITE (*,*) 'Illumination angles at the sub-solar point:' */
/* WRITE (*,*) ' ' */
/* WRITE (*,*) 'Phase angle (deg.): ', SSLPHS */
/* WRITE (*,*) 'Solar incidence angle (deg.): ', SSLSOL */
/* WRITE (*,*) 'Emission angle (deg.): ', SSLEMI */
/* WRITE (*,*) ' ' */
/* WRITE (*,*) 'The solar incidence angle should be 0.' */
/* WRITE (*,*) 'The emission and phase angles should be equal.' */
/* WRITE (*,*) ' ' */
/* WRITE (*,*) 'Illumination angles at the sub-s/c point:' */
/* WRITE (*,*) ' ' */
/* WRITE (*,*) 'Phase angle (deg.): ', SSCPHS */
/* WRITE (*,*) 'Solar incidence angle (deg.): ', SSCSOL */
/* WRITE (*,*) 'Emission angle (deg.): ', SSCEMI */
/* WRITE (*,*) ' ' */
/* WRITE (*,*) 'The emission angle should be 0.' */
/* WRITE (*,*) 'The solar incidence and phase angles should '// */
/* . 'be equal.' */
/* END */
/* When this program is executed, the output will be: */
/* UTC epoch is 2004 JAN 1 12:00:00 */
/* Illumination angles at the sub-solar point: */
/* Phase angle (deg.): 150.210714 */
/* Solar incidence angle (deg.): 6.3735213E-15 */
/* Emission angle (deg.): 150.210714 */
/* The solar incidence angle should be 0. */
/* The emission and phase angles should be equal. */
/* Illumination angles at the sub-s/c point: */
/* Phase angle (deg.): 123.398202 */
/* Solar incidence angle (deg.): 123.398202 */
/* Emission angle (deg.): 6.36110936E-15 */
/* The emission angle should be 0. */
/* The solar incidence and phase angles should be equal. */
/* $ Restrictions */
/* None. */
/* $ Literature_References */
/* None. */
/* $ Author_and_Institution */
/* C.H. Acton (JPL) */
/* B.V. Semenov (JPL) */
/* N.J. Bachman (JPL) */
/* $ Version */
/* - SPICELIB Version 1.3.0, 04-JUL-2014 (NJB) (BVS) */
/* Discussion of light time corrections was updated. Assertions */
/* that converged light time corrections are unlikely to be */
/* useful were removed. */
/* Last update was 19-SEP-2013 (BVS) */
/* Updated to save the input body names and ZZBODTRN state */
/* counters and to do name-ID conversions only if the counters */
/* have changed. */
/* - SPICELIB Version 1.2.2, 18-MAY-2010 (BVS) */
/* Index lines now state that this routine is deprecated. */
/* - SPICELIB Version 1.2.1, 07-FEB-2008 (NJB) */
/* Abstract now states that this routine is deprecated. */
/* - SPICELIB Version 1.2.0, 23-OCT-2005 (NJB) */
/* Updated to remove non-standard use of duplicate arguments */
/* in VSUB calls. Replaced call to BODVAR with call to BODVCD. */
/* - SPICELIB Version 1.1.0, 22-JUL-2004 (NJB) */
/* Updated to support representations of integers in the input */
/* arguments TARGET and OBSRVR. */
/* - SPICELIB Version 1.0.2, 27-JUL-2003 (NJB) (CHA) */
/* Various header corrections were made. The example program */
/* was upgraded to use real kernels, and the program's output is */
/* shown. */
/* - SPICELIB Version 1.0.1, 10-JUL-2002 (NJB) */
/* Updated Index_Entries header section. */
/* - SPICELIB Version 1.0.0, 21-MAR-1999 (NJB) */
/* Adapted from the MGSSPICE version dated 10-MAR-1992. */
/* -& */
/* $ Index_Entries */
/* DEPRECATED illumination angles */
/* DEPRECATED lighting angles */
/* DEPRECATED phase angle */
/* DEPRECATED solar incidence angle */
/* DEPRECATED emission angle */
/* -& */
/* $ Revisions */
/* - SPICELIB Version 1.2.0, 23-OCT-2005 (NJB) */
/* Updated to remove non-standard use of duplicate arguments */
/* in VSUB calls. Replaced call to BODVAR with call to BODVCD. */
/* - SPICELIB Version 1.1.0, 22-JUL-2004 (NJB) */
/* Updated to support representations of integers in the */
/* input arguments TARGET and OBSRVR: calls to BODN2C */
/* were replaced by calls to BODS2C. */
/* -& */
/* SPICELIB functions */
/* Local parameters */
/* Saved body name length. */
/* Local variables */
/* Saved name/ID item declarations. */
/* Saved name/ID items. */
/* Initial values. */
/* Standard SPICE error handling. */
if (return_()) {
return 0;
} else {
chkin_("ILLUM", (ftnlen)5);
}
/* Initialization. */
if (first) {
/* Initialize counters. */
zzctruin_(svctr1);
zzctruin_(svctr2);
first = FALSE_;
}
/* Obtain integer codes for the target and observer. */
zzbods2c_(svctr1, svtarg, &svtcde, &svfnd1, target, &trgcde, &found, (
ftnlen)36, target_len);
if (! found) {
setmsg_("The target, '#', is not a recognized name for an ephemeris "
"object. The cause of this problem may be that you need an up"
"dated version of the SPICE Toolkit. ", (ftnlen)155);
errch_("#", target, (ftnlen)1, target_len);
sigerr_("SPICE(IDCODENOTFOUND)", (ftnlen)21);
chkout_("ILLUM", (ftnlen)5);
return 0;
}
zzbods2c_(svctr2, svobsr, &svobsc, &svfnd2, obsrvr, &obscde, &found, (
ftnlen)36, obsrvr_len);
if (! found) {
setmsg_("The observer, '#', is not a recognized name for an ephemeri"
"s object. The cause of this problem may be that you need an "
"updated version of the SPICE Toolkit. ", (ftnlen)157);
errch_("#", obsrvr, (ftnlen)1, obsrvr_len);
sigerr_("SPICE(IDCODENOTFOUND)", (ftnlen)21);
chkout_("ILLUM", (ftnlen)5);
return 0;
}
/* The observer and target must be distinct. */
if (trgcde == obscde) {
setmsg_("Target is #; observer is #.", (ftnlen)27);
errch_("#", target, (ftnlen)1, target_len);
errch_("#", obsrvr, (ftnlen)1, obsrvr_len);
sigerr_("SPICE(BODIESNOTDISTINCT)", (ftnlen)24);
chkout_("ILLUM", (ftnlen)5);
return 0;
}
/* Find the name of the body-fixed frame associated with the */
/* target body. We'll want the state of the target relative to */
/* the observer in this body-fixed frame. */
cidfrm_(&trgcde, &frcode, frname, &found, (ftnlen)80);
if (! found) {
setmsg_("No body-fixed frame is associated with target body #; a fra"
"me kernel must be loaded to make this association. Consult "
"the FRAMES Required Reading for details.", (ftnlen)159);
errch_("#", target, (ftnlen)1, target_len);
sigerr_("SPICE(NOFRAME)", (ftnlen)14);
chkout_("ILLUM", (ftnlen)5);
return 0;
}
/* Find the body-fixed state of the target as seen from the observer */
/* at ET. The appropriate aberration corrections will be used in */
/* evaluating this state. */
spkez_(&trgcde, et, frname, abcorr, &obscde, tstate, <, (ftnlen)80,
abcorr_len);
/* Determine the epoch to be used in computing the target-Sun vector. */
if (eqstr_(abcorr, "NONE", abcorr_len, (ftnlen)4)) {
tepoch = *et;
} else {
tepoch = *et - lt;
}
/* Find the body-fixed state of the Sun as seen from the target at */
/* TEPOCH. */
spkez_(&c__10, &tepoch, frname, abcorr, &trgcde, sstate, <s, (ftnlen)80,
abcorr_len);
/* Grab the position portions of the states (the first three */
/* elements of each state). Negate the observer-target vector, */
/* since the vector required for the illumination angle */
/* computation is the target-observer vector. The vectors we've */
/* found point from the target body center to the observer and */
/* Sun, and already take light time corrections into account. */
vminus_(tstate, obsvec);
vequ_(sstate, sunvec);
/* Now we'll modify target-observer and target-Sun vectors to */
/* take into account the offset between the target center and the */
/* surface point of interest; we want the vectors to point from */
/* the surface point to the observer and Sun respectively. */
vsub_(obsvec, spoint, offobs);
vsub_(sunvec, spoint, offsun);
/* Find the surface normal at SPOINT. We'll need the radii of the */
/* target body. */
bodvcd_(&trgcde, "RADII", &c__3, &n, radii, (ftnlen)5);
surfnm_(radii, &radii[1], &radii[2], spoint, normal);
/* Find the illumination angles. VSEP will give us angular */
/* separation in radians. */
*phase = vsep_(offsun, offobs);
*solar = vsep_(normal, offsun);
*emissn = vsep_(normal, offobs);
chkout_("ILLUM", (ftnlen)5);
return 0;
} /* illum_ */
/* $Procedure SPKEZR ( S/P Kernel, easier reader ) */
/* Subroutine */ int spkezr_(char *targ, doublereal *et, char *ref, char *
abcorr, char *obs, doublereal *starg, doublereal *lt, ftnlen targ_len,
ftnlen ref_len, ftnlen abcorr_len, ftnlen obs_len)
{
/* Initialized data */
static logical first = TRUE_;
extern /* Subroutine */ int zzbods2c_(integer *, char *, integer *,
logical *, char *, integer *, logical *, ftnlen, ftnlen),
zzctruin_(integer *), chkin_(char *, ftnlen);
integer obsid;
extern /* Subroutine */ int errch_(char *, char *, ftnlen, ftnlen);
logical found;
extern /* Subroutine */ int spkez_(integer *, doublereal *, char *, char *
, integer *, doublereal *, doublereal *, ftnlen, ftnlen);
static logical svfnd1, svfnd2;
static integer svctr1[2], svctr2[2];
integer targid;
extern /* Subroutine */ int sigerr_(char *, ftnlen), chkout_(char *,
ftnlen);
static integer svtgid;
extern /* Subroutine */ int setmsg_(char *, ftnlen);
static integer svobsi;
static char svtarg[36], svobsn[36];
extern logical return_(void);
/* $ Abstract */
/* Return the state (position and velocity) of a target body */
/* relative to an observing body, optionally corrected for light */
/* time (planetary aberration) and stellar aberration. */
/* $ Disclaimer */
/* THIS SOFTWARE AND ANY RELATED MATERIALS WERE CREATED BY THE */
/* CALIFORNIA INSTITUTE OF TECHNOLOGY (CALTECH) UNDER A U.S. */
/* GOVERNMENT CONTRACT WITH THE NATIONAL AERONAUTICS AND SPACE */
/* ADMINISTRATION (NASA). THE SOFTWARE IS TECHNOLOGY AND SOFTWARE */
/* PUBLICLY AVAILABLE UNDER U.S. EXPORT LAWS AND IS PROVIDED "AS-IS" */
/* TO THE RECIPIENT WITHOUT WARRANTY OF ANY KIND, INCLUDING ANY */
/* WARRANTIES OF PERFORMANCE OR MERCHANTABILITY OR FITNESS FOR A */
/* PARTICULAR USE OR PURPOSE (AS SET FORTH IN UNITED STATES UCC */
/* SECTIONS 2312-2313) OR FOR ANY PURPOSE WHATSOEVER, FOR THE */
/* SOFTWARE AND RELATED MATERIALS, HOWEVER USED. */
/* IN NO EVENT SHALL CALTECH, ITS JET PROPULSION LABORATORY, OR NASA */
/* BE LIABLE FOR ANY DAMAGES AND/OR COSTS, INCLUDING, BUT NOT */
/* LIMITED TO, INCIDENTAL OR CONSEQUENTIAL DAMAGES OF ANY KIND, */
/* INCLUDING ECONOMIC DAMAGE OR INJURY TO PROPERTY AND LOST PROFITS, */
/* REGARDLESS OF WHETHER CALTECH, JPL, OR NASA BE ADVISED, HAVE */
/* REASON TO KNOW, OR, IN FACT, SHALL KNOW OF THE POSSIBILITY. */
/* RECIPIENT BEARS ALL RISK RELATING TO QUALITY AND PERFORMANCE OF */
/* THE SOFTWARE AND ANY RELATED MATERIALS, AND AGREES TO INDEMNIFY */
/* CALTECH AND NASA FOR ALL THIRD-PARTY CLAIMS RESULTING FROM THE */
/* ACTIONS OF RECIPIENT IN THE USE OF THE SOFTWARE. */
/* $ Required_Reading */
/* SPK */
/* NAIF_IDS */
/* FRAMES */
/* TIME */
/* $ Keywords */
/* EPHEMERIS */
/* $ Declarations */
/* $ Abstract */
/* The parameters below form an enumerated list of the recognized */
/* frame types. They are: INERTL, PCK, CK, TK, DYN. The meanings */
/* are outlined below. */
/* $ Disclaimer */
/* THIS SOFTWARE AND ANY RELATED MATERIALS WERE CREATED BY THE */
/* CALIFORNIA INSTITUTE OF TECHNOLOGY (CALTECH) UNDER A U.S. */
/* GOVERNMENT CONTRACT WITH THE NATIONAL AERONAUTICS AND SPACE */
/* ADMINISTRATION (NASA). THE SOFTWARE IS TECHNOLOGY AND SOFTWARE */
/* PUBLICLY AVAILABLE UNDER U.S. EXPORT LAWS AND IS PROVIDED "AS-IS" */
/* TO THE RECIPIENT WITHOUT WARRANTY OF ANY KIND, INCLUDING ANY */
/* WARRANTIES OF PERFORMANCE OR MERCHANTABILITY OR FITNESS FOR A */
/* PARTICULAR USE OR PURPOSE (AS SET FORTH IN UNITED STATES UCC */
/* SECTIONS 2312-2313) OR FOR ANY PURPOSE WHATSOEVER, FOR THE */
/* SOFTWARE AND RELATED MATERIALS, HOWEVER USED. */
/* IN NO EVENT SHALL CALTECH, ITS JET PROPULSION LABORATORY, OR NASA */
/* BE LIABLE FOR ANY DAMAGES AND/OR COSTS, INCLUDING, BUT NOT */
/* LIMITED TO, INCIDENTAL OR CONSEQUENTIAL DAMAGES OF ANY KIND, */
/* INCLUDING ECONOMIC DAMAGE OR INJURY TO PROPERTY AND LOST PROFITS, */
/* REGARDLESS OF WHETHER CALTECH, JPL, OR NASA BE ADVISED, HAVE */
/* REASON TO KNOW, OR, IN FACT, SHALL KNOW OF THE POSSIBILITY. */
/* RECIPIENT BEARS ALL RISK RELATING TO QUALITY AND PERFORMANCE OF */
/* THE SOFTWARE AND ANY RELATED MATERIALS, AND AGREES TO INDEMNIFY */
/* CALTECH AND NASA FOR ALL THIRD-PARTY CLAIMS RESULTING FROM THE */
/* ACTIONS OF RECIPIENT IN THE USE OF THE SOFTWARE. */
/* $ Parameters */
/* INERTL an inertial frame that is listed in the routine */
/* CHGIRF and that requires no external file to */
/* compute the transformation from or to any other */
/* inertial frame. */
/* PCK is a frame that is specified relative to some */
/* INERTL frame and that has an IAU model that */
/* may be retrieved from the PCK system via a call */
/* to the routine TISBOD. */
/* CK is a frame defined by a C-kernel. */
/* TK is a "text kernel" frame. These frames are offset */
/* from their associated "relative" frames by a */
/* constant rotation. */
/* DYN is a "dynamic" frame. These currently are */
/* parameterized, built-in frames where the full frame */
/* definition depends on parameters supplied via a */
/* frame kernel. */
/* ALL indicates any of the above classes. This parameter */
/* is used in APIs that fetch information about frames */
/* of a specified class. */
/* $ Author_and_Institution */
/* N.J. Bachman (JPL) */
/* W.L. Taber (JPL) */
/* $ Literature_References */
/* None. */
/* $ Version */
/* - SPICELIB Version 4.0.0, 08-MAY-2012 (NJB) */
/* The parameter ALL was added to support frame fetch APIs. */
/* - SPICELIB Version 3.0.0, 28-MAY-2004 (NJB) */
/* The parameter DYN was added to support the dynamic frame class. */
/* - SPICELIB Version 2.0.0, 12-DEC-1996 (WLT) */
/* Various unused frames types were removed and the */
/* frame time TK was added. */
/* - SPICELIB Version 1.0.0, 10-DEC-1995 (WLT) */
/* -& */
/* End of INCLUDE file frmtyp.inc */
/* $ Abstract */
/* This include file defines the dimension of the counter */
/* array used by various SPICE subsystems to uniquely identify */
/* changes in their states. */
/* $ Disclaimer */
/* THIS SOFTWARE AND ANY RELATED MATERIALS WERE CREATED BY THE */
/* CALIFORNIA INSTITUTE OF TECHNOLOGY (CALTECH) UNDER A U.S. */
/* GOVERNMENT CONTRACT WITH THE NATIONAL AERONAUTICS AND SPACE */
/* ADMINISTRATION (NASA). THE SOFTWARE IS TECHNOLOGY AND SOFTWARE */
/* PUBLICLY AVAILABLE UNDER U.S. EXPORT LAWS AND IS PROVIDED "AS-IS" */
/* TO THE RECIPIENT WITHOUT WARRANTY OF ANY KIND, INCLUDING ANY */
/* WARRANTIES OF PERFORMANCE OR MERCHANTABILITY OR FITNESS FOR A */
/* PARTICULAR USE OR PURPOSE (AS SET FORTH IN UNITED STATES UCC */
/* SECTIONS 2312-2313) OR FOR ANY PURPOSE WHATSOEVER, FOR THE */
/* SOFTWARE AND RELATED MATERIALS, HOWEVER USED. */
/* IN NO EVENT SHALL CALTECH, ITS JET PROPULSION LABORATORY, OR NASA */
/* BE LIABLE FOR ANY DAMAGES AND/OR COSTS, INCLUDING, BUT NOT */
/* LIMITED TO, INCIDENTAL OR CONSEQUENTIAL DAMAGES OF ANY KIND, */
/* INCLUDING ECONOMIC DAMAGE OR INJURY TO PROPERTY AND LOST PROFITS, */
/* REGARDLESS OF WHETHER CALTECH, JPL, OR NASA BE ADVISED, HAVE */
/* REASON TO KNOW, OR, IN FACT, SHALL KNOW OF THE POSSIBILITY. */
/* RECIPIENT BEARS ALL RISK RELATING TO QUALITY AND PERFORMANCE OF */
/* THE SOFTWARE AND ANY RELATED MATERIALS, AND AGREES TO INDEMNIFY */
/* CALTECH AND NASA FOR ALL THIRD-PARTY CLAIMS RESULTING FROM THE */
/* ACTIONS OF RECIPIENT IN THE USE OF THE SOFTWARE. */
/* $ Parameters */
/* CTRSIZ is the dimension of the counter array used by */
/* various SPICE subsystems to uniquely identify */
/* changes in their states. */
/* $ Author_and_Institution */
/* B.V. Semenov (JPL) */
/* $ Literature_References */
/* None. */
/* $ Version */
/* - SPICELIB Version 1.0.0, 29-JUL-2013 (BVS) */
/* -& */
/* End of include file. */
/* $ Brief_I/O */
/* Variable I/O Description */
/* -------- --- -------------------------------------------------- */
/* TARG I Target body name. */
/* ET I Observer epoch. */
/* REF I Reference frame of output state vector. */
/* ABCORR I Aberration correction flag. */
/* OBS I Observing body name. */
/* STARG O State of target. */
/* LT O One way light time between observer and target. */
/* $ Detailed_Input */
/* TARG is the name of a target body. Optionally, you may */
/* supply the integer ID code for the object as */
/* an integer string. For example both 'MOON' and */
/* '301' are legitimate strings that indicate the */
/* moon is the target body. */
/* The target and observer define a state vector whose */
/* position component points from the observer to the */
/* target. */
/* ET is the ephemeris time, expressed as seconds past J2000 */
/* TDB, at which the state of the target body relative to */
/* the observer is to be computed. ET refers to time at */
/* the observer's location. */
/* REF is the name of the reference frame relative to which */
/* the output state vector should be expressed. This may */
/* be any frame supported by the SPICE system, including */
/* built-in frames (documented in the Frames Required */
/* Reading) and frames defined by a loaded frame kernel */
/* (FK). */
/* When REF designates a non-inertial frame, the */
/* orientation of the frame is evaluated at an epoch */
/* dependent on the selected aberration correction. */
/* See the description of the output state vector STARG */
/* for details. */
/* ABCORR indicates the aberration corrections to be applied */
/* to the state of the target body to account for one-way */
/* light time and stellar aberration. See the discussion */
/* in the Particulars section for recommendations on */
/* how to choose aberration corrections. */
/* ABCORR may be any of the following: */
/* 'NONE' Apply no correction. Return the */
/* geometric state of the target body */
/* relative to the observer. */
/* The following values of ABCORR apply to the */
/* "reception" case in which photons depart from the */
/* target's location at the light-time corrected epoch */
/* ET-LT and *arrive* at the observer's location at ET: */
/* 'LT' Correct for one-way light time (also */
/* called "planetary aberration") using a */
/* Newtonian formulation. This correction */
/* yields the state of the target at the */
/* moment it emitted photons arriving at */
/* the observer at ET. */
/* The light time correction uses an */
/* iterative solution of the light time */
/* equation (see Particulars for details). */
/* The solution invoked by the 'LT' option */
/* uses one iteration. */
/* 'LT+S' Correct for one-way light time and */
/* stellar aberration using a Newtonian */
/* formulation. This option modifies the */
/* state obtained with the 'LT' option to */
/* account for the observer's velocity */
/* relative to the solar system */
/* barycenter. The result is the apparent */
/* state of the target---the position and */
/* velocity of the target as seen by the */
/* observer. */
/* 'CN' Converged Newtonian light time */
/* correction. In solving the light time */
/* equation, the 'CN' correction iterates */
/* until the solution converges (three */
/* iterations on all supported platforms). */
/* Whether the 'CN+S' solution is */
/* substantially more accurate than the */
/* 'LT' solution depends on the geometry */
/* of the participating objects and on the */
/* accuracy of the input data. In all */
/* cases this routine will execute more */
/* slowly when a converged solution is */
/* computed. See the Particulars section */
/* below for a discussion of precision of */
/* light time corrections. */
/* 'CN+S' Converged Newtonian light time */
/* correction and stellar aberration */
/* correction. */
/* The following values of ABCORR apply to the */
/* "transmission" case in which photons *depart* from */
/* the observer's location at ET and arrive at the */
/* target's location at the light-time corrected epoch */
/* ET+LT: */
/* 'XLT' "Transmission" case: correct for */
/* one-way light time using a Newtonian */
/* formulation. This correction yields the */
/* state of the target at the moment it */
/* receives photons emitted from the */
/* observer's location at ET. */
/* 'XLT+S' "Transmission" case: correct for */
/* one-way light time and stellar */
/* aberration using a Newtonian */
/* formulation This option modifies the */
/* state obtained with the 'XLT' option to */
/* account for the observer's velocity */
/* relative to the solar system */
/* barycenter. The position component of */
/* the computed target state indicates the */
/* direction that photons emitted from the */
/* observer's location must be "aimed" to */
/* hit the target. */
/* 'XCN' "Transmission" case: converged */
/* Newtonian light time correction. */
/* 'XCN+S' "Transmission" case: converged */
/* Newtonian light time correction and */
/* stellar aberration correction. */
/* Neither special nor general relativistic effects are */
/* accounted for in the aberration corrections applied */
/* by this routine. */
/* Case and blanks are not significant in the string */
/* ABCORR. */
/* OBS is the name of an observing body. Optionally, you */
/* may supply the ID code of the object as an integer */
/* string. For example, both 'EARTH' and '399' are */
/* legitimate strings to supply to indicate the */
/* observer is Earth. */
/* $ Detailed_Output */
/* STARG is a Cartesian state vector representing the position */
/* and velocity of the target body relative to the */
/* specified observer. STARG is corrected for the */
/* specified aberrations, and is expressed with respect */
/* to the reference frame specified by REF. The first */
/* three components of STARG represent the x-, y- and */
/* z-components of the target's position; the last three */
/* components form the corresponding velocity vector. */
/* The position component of STARG points from the */
/* observer's location at ET to the aberration-corrected */
/* location of the target. Note that the sense of the */
/* position vector is independent of the direction of */
/* radiation travel implied by the aberration */
/* correction. */
/* The velocity component of STARG is the derivative */
/* with respect to time of the position component of */
/* STARG. */
/* Units are always km and km/sec. */
/* Non-inertial frames are treated as follows: letting */
/* LTCENT be the one-way light time between the observer */
/* and the central body associated with the frame, the */
/* orientation of the frame is evaluated at ET-LTCENT, */
/* ET+LTCENT, or ET depending on whether the requested */
/* aberration correction is, respectively, for received */
/* radiation, transmitted radiation, or is omitted. */
/* LTCENT is computed using the method indicated by */
/* ABCORR. */
/* LT is the one-way light time between the observer and */
/* target in seconds. If the target state is corrected */
/* for aberrations, then LT is the one-way light time */
/* between the observer and the light time corrected */
/* target location. */
/* $ Parameters */
/* None. */
/* $ Exceptions */
/* 1) If name of target or observer cannot be translated to its */
/* NAIF ID code, the error SPICE(IDCODENOTFOUND) is signaled. */
/* 2) If the reference frame REF is not a recognized reference */
/* frame the error 'SPICE(UNKNOWNFRAME)' is signaled. */
/* 3) If the loaded kernels provide insufficient data to */
/* compute the requested state vector, the deficiency will */
/* be diagnosed by a routine in the call tree of this routine. */
/* 4) If an error occurs while reading an SPK or other kernel file, */
/* the error will be diagnosed by a routine in the call tree */
/* of this routine. */
/* $ Files */
/* This routine computes states using SPK files that have been */
/* loaded into the SPICE system, normally via the kernel loading */
/* interface routine FURNSH. See the routine FURNSH and the SPK */
/* and KERNEL Required Reading for further information on loading */
/* (and unloading) kernels. */
/* If the output state STARG is to be expressed relative to a */
/* non-inertial frame, or if any of the ephemeris data used to */
/* compute STARG are expressed relative to a non-inertial frame in */
/* the SPK files providing those data, additional kernels may be */
/* needed to enable the reference frame transformations required to */
/* compute the state. Normally these additional kernels are PCK */
/* files or frame kernels. Any such kernels must already be loaded */
/* at the time this routine is called. */
/* $ Particulars */
/* This routine is part of the user interface to the SPICE ephemeris */
/* system. It allows you to retrieve state information for any */
/* ephemeris object relative to any other in a reference frame that */
/* is convenient for further computations. */
/* This routine is identical in function to the routine SPKEZ except */
/* that it allows you to refer to ephemeris objects by name (via a */
/* character string). */
/* Aberration corrections */
/* ====================== */
/* In space science or engineering applications one frequently */
/* wishes to know where to point a remote sensing instrument, such */
/* as an optical camera or radio antenna, in order to observe or */
/* otherwise receive radiation from a target. This pointing problem */
/* is complicated by the finite speed of light: one needs to point */
/* to where the target appears to be as opposed to where it actually */
/* is at the epoch of observation. We use the adjectives */
/* "geometric," "uncorrected," or "true" to refer to an actual */
/* position or state of a target at a specified epoch. When a */
/* geometric position or state vector is modified to reflect how it */
/* appears to an observer, we describe that vector by any of the */
/* terms "apparent," "corrected," "aberration corrected," or "light */
/* time and stellar aberration corrected." The SPICE Toolkit can */
/* correct for two phenomena affecting the apparent location of an */
/* object: one-way light time (also called "planetary aberration") */
/* and stellar aberration. */
/* One-way light time */
/* ------------------ */
/* Correcting for one-way light time is done by computing, given an */
/* observer and observation epoch, where a target was when the */
/* observed photons departed the target's location. The vector from */
/* the observer to this computed target location is called a "light */
/* time corrected" vector. The light time correction depends on the */
/* motion of the target relative to the solar system barycenter, but */
/* it is independent of the velocity of the observer relative to the */
/* solar system barycenter. Relativistic effects such as light */
/* bending and gravitational delay are not accounted for in the */
/* light time correction performed by this routine. */
/* Stellar aberration */
/* ------------------ */
/* The velocity of the observer also affects the apparent location */
/* of a target: photons arriving at the observer are subject to a */
/* "raindrop effect" whereby their velocity relative to the observer */
/* is, using a Newtonian approximation, the photons' velocity */
/* relative to the solar system barycenter minus the velocity of the */
/* observer relative to the solar system barycenter. This effect is */
/* called "stellar aberration." Stellar aberration is independent */
/* of the velocity of the target. The stellar aberration formula */
/* used by this routine does not include (the much smaller) */
/* relativistic effects. */
/* Stellar aberration corrections are applied after light time */
/* corrections: the light time corrected target position vector is */
/* used as an input to the stellar aberration correction. */
/* When light time and stellar aberration corrections are both */
/* applied to a geometric position vector, the resulting position */
/* vector indicates where the target "appears to be" from the */
/* observer's location. */
/* As opposed to computing the apparent position of a target, one */
/* may wish to compute the pointing direction required for */
/* transmission of photons to the target. This also requires */
/* correction of the geometric target position for the effects of */
/* light time and stellar aberration, but in this case the */
/* corrections are computed for radiation traveling *from* the */
/* observer to the target. */
/* The "transmission" light time correction yields the target's */
/* location as it will be when photons emitted from the observer's */
/* location at ET arrive at the target. The transmission stellar */
/* aberration correction is the inverse of the traditional stellar */
/* aberration correction: it indicates the direction in which */
/* radiation should be emitted so that, using a Newtonian */
/* approximation, the sum of the velocity of the radiation relative */
/* to the observer and of the observer's velocity, relative to the */
/* solar system barycenter, yields a velocity vector that points in */
/* the direction of the light time corrected position of the target. */
/* One may object to using the term "observer" in the transmission */
/* case, in which radiation is emitted from the observer's location. */
/* The terminology was retained for consistency with earlier */
/* documentation. */
/* Below, we indicate the aberration corrections to use for some */
/* common applications: */
/* 1) Find the apparent direction of a target for a remote-sensing */
/* observation. */
/* Use 'LT+S' or 'CN+S: apply both light time and stellar */
/* aberration corrections. */
/* Note that using light time corrections alone ('LT' or 'CN') */
/* is generally not a good way to obtain an approximation to */
/* an apparent target vector: since light time and stellar */
/* aberration corrections often partially cancel each other, */
/* it may be more accurate to use no correction at all than to */
/* use light time alone. */
/* 2) Find the corrected pointing direction to radiate a signal */
/* to a target. This computation is often applicable for */
/* implementing communications sessions. */
/* Use 'XLT+S' or 'XCN+S: apply both light time and stellar */
/* aberration corrections for transmission. */
/* 3) Compute the apparent position of a target body relative */
/* to a star or other distant object. */
/* Use 'LT', 'CN', 'LT+S', or 'CN+S' as needed to match the */
/* correction applied to the position of the distant */
/* object. For example, if a star position is obtained from */
/* a catalog, the position vector may not be corrected for */
/* stellar aberration. In this case, to find the angular */
/* separation of the star and the limb of a planet, the */
/* vector from the observer to the planet should be */
/* corrected for light time but not stellar aberration. */
/* 4) Obtain an uncorrected state vector derived directly from */
/* data in an SPK file. */
/* Use 'NONE'. */
/* 5) Use a geometric state vector as a low-accuracy estimate */
/* of the apparent state for an application where execution */
/* speed is critical. */
/* Use 'NONE'. */
/* 6) While this routine cannot perform the relativistic */
/* aberration corrections required to compute states */
/* with the highest possible accuracy, it can supply the */
/* geometric states required as inputs to these computations. */
/* Use 'NONE', then apply relativistic aberration */
/* corrections (not available in the SPICE Toolkit). */
/* Below, we discuss in more detail how the aberration corrections */
/* applied by this routine are computed. */
/* Geometric case */
/* ============== */
/* SPKEZR begins by computing the geometric position T(ET) of the */
/* target body relative to the solar system barycenter (SSB). */
/* Subtracting the geometric position of the observer O(ET) gives */
/* the geometric position of the target body relative to the */
/* observer. The one-way light time, LT, is given by */
/* | T(ET) - O(ET) | */
/* LT = ------------------- */
/* c */
/* The geometric relationship between the observer, target, and */
/* solar system barycenter is as shown: */
/* SSB ---> O(ET) */
/* | / */
/* | / */
/* | / */
/* | / T(ET) - O(ET) */
/* V V */
/* T(ET) */
/* The returned state consists of the position vector */
/* T(ET) - O(ET) */
/* and a velocity obtained by taking the difference of the */
/* corresponding velocities. In the geometric case, the */
/* returned velocity is actually the time derivative of the */
/* position. */
/* Reception case */
/* ============== */
/* When any of the options 'LT', 'CN', 'LT+S', 'CN+S' is selected */
/* for ABCORR, SPKEZR computes the position of the target body at */
/* epoch ET-LT, where LT is the one-way light time. Let T(t) and */
/* O(t) represent the positions of the target and observer */
/* relative to the solar system barycenter at time t; then LT is */
/* the solution of the light-time equation */
/* | T(ET-LT) - O(ET) | */
/* LT = ------------------------ (1) */
/* c */
/* The ratio */
/* | T(ET) - O(ET) | */
/* --------------------- (2) */
/* c */
/* is used as a first approximation to LT; inserting (2) into the */
/* right hand side of the light-time equation (1) yields the */
/* "one-iteration" estimate of the one-way light time ("LT"). */
/* Repeating the process until the estimates of LT converge */
/* yields the "converged Newtonian" light time estimate ("CN"). */
/* Subtracting the geometric position of the observer O(ET) gives */
/* the position of the target body relative to the observer: */
/* T(ET-LT) - O(ET). */
/* SSB ---> O(ET) */
/* | \ | */
/* | \ | */
/* | \ | T(ET-LT) - O(ET) */
/* | \ | */
/* V V V */
/* T(ET) T(ET-LT) */
/* The position component of the light time corrected state */
/* is the vector */
/* T(ET-LT) - O(ET) */
/* The velocity component of the light time corrected state */
/* is the difference */
/* T_vel(ET-LT)*(1-dLT/dET) - O_vel(ET) */
/* where T_vel and O_vel are, respectively, the velocities of the */
/* target and observer relative to the solar system barycenter at */
/* the epochs ET-LT and ET. */
/* If correction for stellar aberration is requested, the target */
/* position is rotated toward the solar system barycenter- */
/* relative velocity vector of the observer. The rotation is */
/* computed as follows: */
/* Let r be the light time corrected vector from the observer */
/* to the object, and v be the velocity of the observer with */
/* respect to the solar system barycenter. Let w be the angle */
/* between them. The aberration angle phi is given by */
/* sin(phi) = v sin(w) / c */
/* Let h be the vector given by the cross product */
/* h = r X v */
/* Rotate r by phi radians about h to obtain the apparent */
/* position of the object. */
/* When stellar aberration corrections are used, the rate of */
/* change of the stellar aberration correction is accounted for */
/* in the computation of the output velocity. */
/* Transmission case */
/* ================== */
/* When any of the options 'XLT', 'XCN', 'XLT+S', 'XCN+S' is */
/* selected, SPKEZR computes the position of the target body T at */
/* epoch ET+LT, where LT is the one-way light time. LT is the */
/* solution of the light-time equation */
/* | T(ET+LT) - O(ET) | */
/* LT = ------------------------ (3) */
/* c */
/* Subtracting the geometric position of the observer, O(ET), */
/* gives the position of the target body relative to the */
/* observer: T(ET-LT) - O(ET). */
/* SSB --> O(ET) */
/* / | * */
/* / | * T(ET+LT) - O(ET) */
/* / |* */
/* / *| */
/* V V V */
/* T(ET+LT) T(ET) */
/* The position component of the light-time corrected state */
/* is the vector */
/* T(ET+LT) - O(ET) */
/* The velocity component of the light-time corrected state */
/* consists of the difference */
/* T_vel(ET+LT)*(1+dLT/dET) - O_vel(ET) */
/* where T_vel and O_vel are, respectively, the velocities of the */
/* target and observer relative to the solar system barycenter at */
/* the epochs ET+LT and ET. */
/* If correction for stellar aberration is requested, the target */
/* position is rotated away from the solar system barycenter- */
/* relative velocity vector of the observer. The rotation is */
/* computed as in the reception case, but the sign of the */
/* rotation angle is negated. Velocities are adjusted to account */
/* for the rate of change of the stellar aberration correction. */
/* Precision of light time corrections */
/* =================================== */
/* Corrections using one iteration of the light time solution */
/* ---------------------------------------------------------- */
/* When the requested aberration correction is 'LT', 'LT+S', */
/* 'XLT', or 'XLT+S', only one iteration is performed in the */
/* algorithm used to compute LT. */
/* The relative error in this computation */
/* | LT_ACTUAL - LT_COMPUTED | / LT_ACTUAL */
/* is at most */
/* (V/C)**2 */
/* ---------- */
/* 1 - (V/C) */
/* which is well approximated by (V/C)**2, where V is the */
/* velocity of the target relative to an inertial frame and C is */
/* the speed of light. */
/* For nearly all objects in the solar system V is less than 60 */
/* km/sec. The value of C is ~300000 km/sec. Thus the */
/* one-iteration solution for LT has a potential relative error */
/* of not more than 4e-8. This is a potential light time error of */
/* approximately 2e-5 seconds per astronomical unit of distance */
/* separating the observer and target. Given the bound on V cited */
/* above: */
/* As long as the observer and target are separated by less */
/* than 50 astronomical units, the error in the light time */
/* returned using the one-iteration light time corrections is */
/* less than 1 millisecond. */
/* The magnitude of the corresponding position error, given */
/* the above assumptions, may be as large as (V/C)**2 * the */
/* distance between the observer and the uncorrected target */
/* position: 300 km or equivalently 6 km/AU. */
/* In practice, the difference between positions obtained using */
/* one-iteration and converged light time is usually much smaller */
/* than the value computed above and can be insignificant. For */
/* example, for the spacecraft Mars Reconnaissance Orbiter and */
/* Mars Express, the position error for the one-iteration light */
/* time correction, applied to the spacecraft-to-Mars center */
/* vector, is at the 1 cm level. */
/* Comparison of results obtained using the one-iteration and */
/* converged light time solutions is recommended when adequacy of */
/* the one-iteration solution is in doubt. */
/* Converged corrections */
/* --------------------- */
/* When the requested aberration correction is 'CN', 'CN+S', */
/* 'XCN', or 'XCN+S', as many iterations as are required for */
/* convergence are performed in the computation of LT. Usually */
/* the solution is found after three iterations. The relative */
/* error present in this case is at most */
/* (V/C)**4 */
/* ---------- */
/* 1 - (V/C) */
/* which is well approximated by (V/C)**4. */
/* The precision of this computation (ignoring round-off */
/* error) is better than 4e-11 seconds for any pair of objects */
/* less than 50 AU apart, and having speed relative to the */
/* solar system barycenter less than 60 km/s. */
/* The magnitude of the corresponding position error, given */
/* the above assumptions, may be as large as (V/C)**4 * the */
/* distance between the observer and the uncorrected target */
/* position: 1.2 cm at 50 AU or equivalently 0.24 mm/AU. */
/* However, to very accurately model the light time between */
/* target and observer one must take into account effects due to */
/* general relativity. These may be as high as a few hundredths */
/* of a millisecond for some objects. */
/* Relativistic Corrections */
/* ========================= */
/* This routine does not attempt to perform either general or */
/* special relativistic corrections in computing the various */
/* aberration corrections. For many applications relativistic */
/* corrections are not worth the expense of added computation */
/* cycles. If however, your application requires these additional */
/* corrections we suggest you consult the astronomical almanac (page */
/* B36) for a discussion of how to carry out these corrections. */
/* $ Examples */
/* 1) Load a planetary ephemeris SPK, then look up a series of */
/* geometric states of the moon relative to the earth, */
/* referenced to the J2000 frame. */
/* IMPLICIT NONE */
/* C */
/* C Local constants */
/* C */
/* CHARACTER*(*) FRAME */
/* PARAMETER ( FRAME = 'J2000' ) */
/* CHARACTER*(*) ABCORR */
/* PARAMETER ( ABCORR = 'NONE' ) */
/* C */
/* C The name of the SPK file shown here is fictitious; */
/* C you must supply the name of an SPK file available */
/* C on your own computer system. */
/* C */
/* CHARACTER*(*) SPK */
/* PARAMETER ( SPK = 'planet.bsp' ) */
/* C */
/* C ET0 represents the date 2000 Jan 1 12:00:00 TDB. */
/* C */
/* DOUBLE PRECISION ET0 */
/* PARAMETER ( ET0 = 0.0D0 ) */
/* C */
/* C Use a time step of 1 hour; look up 100 states. */
/* C */
/* DOUBLE PRECISION STEP */
/* PARAMETER ( STEP = 3600.0D0 ) */
/* INTEGER MAXITR */
/* PARAMETER ( MAXITR = 100 ) */
/* CHARACTER*(*) OBSRVR */
/* PARAMETER ( OBSRVR = 'Earth' ) */
/* CHARACTER*(*) TARGET */
/* PARAMETER ( TARGET = 'Moon' ) */
/* C */
/* C Local variables */
/* C */
/* DOUBLE PRECISION ET */
/* DOUBLE PRECISION LT */
/* DOUBLE PRECISION STATE ( 6 ) */
/* INTEGER I */
/* C */
/* C Load the SPK file. */
/* C */
/* CALL FURNSH ( SPK ) */
/* C */
/* C Step through a series of epochs, looking up a */
/* C state vector at each one. */
/* C */
/* DO I = 1, MAXITR */
/* ET = ET0 + (I-1)*STEP */
/* CALL SPKEZR ( TARGET, ET, FRAME, ABCORR, OBSRVR, */
/* . STATE, LT ) */
/* WRITE (*,*) 'ET = ', ET */
/* WRITE (*,*) 'J2000 x-position (km): ', STATE(1) */
/* WRITE (*,*) 'J2000 y-position (km): ', STATE(2) */
/* WRITE (*,*) 'J2000 z-position (km): ', STATE(3) */
/* WRITE (*,*) 'J2000 x-velocity (km/s): ', STATE(4) */
/* WRITE (*,*) 'J2000 y-velocity (km/s): ', STATE(5) */
/* WRITE (*,*) 'J2000 z-velocity (km/s): ', STATE(6) */
/* WRITE (*,*) ' ' */
/* END DO */
/* END */
/* $ Restrictions */
/* None. */
/* $ Literature_References */
/* SPK Required Reading. */
/* $ Author_and_Institution */
/* C.H. Acton (JPL) */
/* B.V. Semenov (JPL) */
/* N.J. Bachman (JPL) */
/* $ Version */
/* - SPICELIB Version 4.1.0, 03-JUL-2014 (NJB) (BVS) */
/* Discussion of light time corrections was updated. Assertions */
/* that converged light time corrections are unlikely to be */
/* useful were removed. */
/* Last update was 19-SEP-2013 (BVS) */
/* Updated to save the input body names and ZZBODTRN state */
/* counters and to do name-ID conversions only if the counters */
/* have changed. */
/* - SPICELIB Version 4.0.0, 27-DEC-2007 (NJB) */
/* This routine was upgraded to more accurately compute */
/* aberration-corrected velocity, and in particular, make it */
/* more consistent with observer-target positions. */
/* When light time corrections are used, the derivative of light */
/* time with respect to time is now accounted for in the */
/* computation of observer-target velocities. When the reference */
/* frame associated with the output state is time-dependent, the */
/* derivative of light time with respect to time is now accounted */
/* for in the computation of the rate of change of orientation of */
/* the reference frame. */
/* When stellar aberration corrections are used, velocities */
/* now reflect the rate of range of the stellar aberration */
/* correction. */
/* - SPICELIB Version 3.0.2, 20-OCT-2003 (EDW) */
/* Added mention that LT returns in seconds. */
/* - SPICELIB Version 3.0.1, 29-JUL-2003 (NJB) (CHA) */
/* Various minor header changes were made to improve clarity. */
/* - SPICELIB Version 3.0.0, 31-DEC-2001 (NJB) */
/* Updated to handle aberration corrections for transmission */
/* of radiation. Formerly, only the reception case was */
/* supported. The header was revised and expanded to explain */
/* the functionality of this routine in more detail. */
/* - Spicelib Version 2.0.0, 21-FEB-1997 (WLT) */
/* Extended the functionality of the routine. Users may */
/* now entered the id code of an object as an ascii string */
/* and the string will be converted to the corresponding */
/* integer representation. */
/* - Spicelib Version 1.1.0, 09-JUL-1996 (WLT) */
/* Corrected the description of LT in the Detailed Output */
/* section of the header. */
/* - SPICELIB Version 1.0.0, 25-SEP-1995 (BVS) */
/* -& */
/* $ Index_Entries */
/* using body names get target state relative to an observer */
/* get state relative to observer corrected for aberrations */
/* read ephemeris data */
/* read trajectory data */
/* -& */
/* $ Revisions */
/* None. */
/* -& */
/* SPICELIB functions */
/* Saved body name length. */
/* Local variables */
/* Saved name/ID item declarations. */
/* Saved name/ID items. */
/* Initial values. */
/* Standard SPICE error handling. */
if (return_()) {
return 0;
} else {
chkin_("SPKEZR", (ftnlen)6);
}
/* Initialization. */
if (first) {
/* Initialize counters. */
zzctruin_(svctr1);
zzctruin_(svctr2);
first = FALSE_;
}
/* Starting from translation of target name to its code */
zzbods2c_(svctr1, svtarg, &svtgid, &svfnd1, targ, &targid, &found, (
ftnlen)36, targ_len);
if (! found) {
setmsg_("The target, '#', is not a recognized name for an ephemeris "
"object. The cause of this problem may be that you need an up"
"dated version of the SPICE Toolkit. Alternatively you may ca"
"ll SPKEZ directly if you know the SPICE ID codes for both '#"
"' and '#' ", (ftnlen)249);
errch_("#", targ, (ftnlen)1, targ_len);
errch_("#", targ, (ftnlen)1, targ_len);
errch_("#", obs, (ftnlen)1, obs_len);
sigerr_("SPICE(IDCODENOTFOUND)", (ftnlen)21);
chkout_("SPKEZR", (ftnlen)6);
return 0;
}
/* Now do the same for observer */
zzbods2c_(svctr2, svobsn, &svobsi, &svfnd2, obs, &obsid, &found, (ftnlen)
36, obs_len);
if (! found) {
setmsg_("The observer, '#', is not a recognized name for an ephemeri"
"s object. The cause of this problem may be that you need an "
"updated version of the SPICE toolkit. Alternatively you may "
"call SPKEZ directly if you know the SPICE ID codes for both "
"'#' and '#' ", (ftnlen)251);
errch_("#", obs, (ftnlen)1, obs_len);
errch_("#", targ, (ftnlen)1, targ_len);
errch_("#", obs, (ftnlen)1, obs_len);
sigerr_("SPICE(IDCODENOTFOUND)", (ftnlen)21);
chkout_("SPKEZR", (ftnlen)6);
return 0;
}
/* After all translations are done we can call SPKEZ. */
spkez_(&targid, et, ref, abcorr, &obsid, starg, lt, ref_len, abcorr_len);
chkout_("SPKEZR", (ftnlen)6);
return 0;
} /* spkezr_ */
/* $Procedure ET2LST ( ET to Local Solar Time ) */
/* Subroutine */ int et2lst_(doublereal *et, integer *body, doublereal *
long__, char *type__, integer *hr, integer *mn, integer *sc, char *
time, char *ampm, ftnlen type_len, ftnlen time_len, ftnlen ampm_len)
{
/* System generated locals */
address a__1[5], a__2[7];
integer i__1[5], i__2[7];
doublereal d__1;
/* Builtin functions */
integer s_cmp(char *, char *, ftnlen, ftnlen);
/* Subroutine */ int s_copy(char *, char *, ftnlen, ftnlen), s_cat(char *,
char **, integer *, integer *, ftnlen);
/* Local variables */
doublereal rate, slat, mins;
char h__[2], m[2];
integer n;
doublereal q;
char s[2];
doublereal angle;
char frame[32];
doublereal range;
extern /* Subroutine */ int chkin_(char *, ftnlen), ucase_(char *, char *,
ftnlen, ftnlen), errch_(char *, char *, ftnlen, ftnlen), dpfmt_(
doublereal *, char *, char *, ftnlen, ftnlen);
logical found;
extern /* Subroutine */ int repmi_(char *, char *, integer *, char *,
ftnlen, ftnlen, ftnlen);
doublereal state[6], slong;
extern /* Subroutine */ int spkez_(integer *, doublereal *, char *, char *
, integer *, doublereal *, doublereal *, ftnlen, ftnlen);
doublereal hours;
extern /* Subroutine */ int ljust_(char *, char *, ftnlen, ftnlen);
extern doublereal twopi_(void);
extern /* Subroutine */ int bodc2n_(integer *, char *, logical *, ftnlen);
extern doublereal pi_(void);
char bodnam[36];
doublereal lt;
integer frcode;
extern /* Subroutine */ int cidfrm_(integer *, integer *, char *, logical
*, ftnlen);
extern doublereal brcktd_(doublereal *, doublereal *, doublereal *);
extern /* Subroutine */ int reclat_(doublereal *, doublereal *,
doublereal *, doublereal *), rmaind_(doublereal *, doublereal *,
doublereal *, doublereal *);
doublereal secnds;
extern /* Subroutine */ int pgrrec_(char *, doublereal *, doublereal *,
doublereal *, doublereal *, doublereal *, doublereal *, ftnlen);
char bpmkwd[32];
integer hrampm;
doublereal tmpang;
extern /* Subroutine */ int gdpool_(char *, integer *, integer *, integer
*, doublereal *, logical *, ftnlen);
char amorpm[4];
doublereal tmpsec;
extern /* Subroutine */ int sigerr_(char *, ftnlen), chkout_(char *,
ftnlen), dtpool_(char *, logical *, integer *, char *, ftnlen,
ftnlen), setmsg_(char *, ftnlen), errint_(char *, integer *,
ftnlen);
doublereal mylong, spoint[3];
extern logical return_(void);
char kwtype[1];
extern /* Subroutine */ int intstr_(integer *, char *, ftnlen);
char mytype[32];
doublereal lat;
/* $ Abstract */
/* Given an ephemeris epoch ET, compute the local solar time for */
/* an object on the surface of a body at a specified longitude. */
/* $ Disclaimer */
/* THIS SOFTWARE AND ANY RELATED MATERIALS WERE CREATED BY THE */
/* CALIFORNIA INSTITUTE OF TECHNOLOGY (CALTECH) UNDER A U.S. */
/* GOVERNMENT CONTRACT WITH THE NATIONAL AERONAUTICS AND SPACE */
/* ADMINISTRATION (NASA). THE SOFTWARE IS TECHNOLOGY AND SOFTWARE */
/* PUBLICLY AVAILABLE UNDER U.S. EXPORT LAWS AND IS PROVIDED "AS-IS" */
/* TO THE RECIPIENT WITHOUT WARRANTY OF ANY KIND, INCLUDING ANY */
/* WARRANTIES OF PERFORMANCE OR MERCHANTABILITY OR FITNESS FOR A */
/* PARTICULAR USE OR PURPOSE (AS SET FORTH IN UNITED STATES UCC */
/* SECTIONS 2312-2313) OR FOR ANY PURPOSE WHATSOEVER, FOR THE */
/* SOFTWARE AND RELATED MATERIALS, HOWEVER USED. */
/* IN NO EVENT SHALL CALTECH, ITS JET PROPULSION LABORATORY, OR NASA */
/* BE LIABLE FOR ANY DAMAGES AND/OR COSTS, INCLUDING, BUT NOT */
/* LIMITED TO, INCIDENTAL OR CONSEQUENTIAL DAMAGES OF ANY KIND, */
/* INCLUDING ECONOMIC DAMAGE OR INJURY TO PROPERTY AND LOST PROFITS, */
/* REGARDLESS OF WHETHER CALTECH, JPL, OR NASA BE ADVISED, HAVE */
/* REASON TO KNOW, OR, IN FACT, SHALL KNOW OF THE POSSIBILITY. */
/* RECIPIENT BEARS ALL RISK RELATING TO QUALITY AND PERFORMANCE OF */
/* THE SOFTWARE AND ANY RELATED MATERIALS, AND AGREES TO INDEMNIFY */
/* CALTECH AND NASA FOR ALL THIRD-PARTY CLAIMS RESULTING FROM THE */
/* ACTIONS OF RECIPIENT IN THE USE OF THE SOFTWARE. */
/* $ Required_Reading */
/* TIME */
/* $ Keywords */
/* TIME */
/* $ Declarations */
/* $ Brief_I/O */
/* VARIABLE I/O DESCRIPTION */
/* -------- --- -------------------------------------------------- */
/* ET I Epoch in seconds past J2000 epoch */
/* BODY I ID-code of the body of interest */
/* LONG I Longitude of surface point (RADIANS) */
/* TYPE I Type of longitude 'PLANETOCENTRIC', etc. */
/* HR O Local hour on a "24 hour" clock */
/* MN O Minutes past the hour */
/* SC O Seconds past the minute */
/* TIME O String giving local time on 24 hour clock */
/* AMPM O String giving time on A.M./ P.M. scale */
/* $ Detailed_Input */
/* ET is the epoch expressed in TDB seconds past */
/* the J2000 epoch at which a local time is desired. */
/* BODY is the NAIF ID-code of a body on which local */
/* time is to be measured. */
/* LONG is the longitude (either planetocentric or */
/* planetographic) in radians of the site on the */
/* surface of body for which local time should be */
/* computed. */
/* TYPE is the form of longitude supplied by the variable */
/* LONG. Allowed values are 'PLANETOCENTRIC' and */
/* 'PLANETOGRAPHIC'. Note the case of the letters */
/* in TYPE is insignificant. Both 'PLANETOCENTRIC' */
/* and 'planetocentric' are recognized. */
/* $ Detailed_Output */
/* HR is the local "hour" of the site specified at the */
/* epoch ET. Note that an "hour" of local time does not */
/* have the same duration as an hour measured by */
/* conventional clocks. It is simply a representation */
/* of an angle. See the "Particulars" section for a more */
/* complete discussion of the meaning of local time. */
/* MN is the number of "minutes" past the hour of the */
/* local time of the site at the epoch ET. Again note */
/* that a "local minute" is not the same as a minute */
/* you would measure with conventional clocks. */
/* SC is the number of "seconds" past the minute of the */
/* local time of the site at the epoch ET. Again note */
/* that a "local second" is not the same as a second */
/* you would measure with conventional clocks. */
/* TIME is a string expressing the local time */
/* on a "24 hour" local clock. */
/* AMPM is a string expressing the local time on a "12 hour" */
/* local clock together with the traditional AM/PM */
/* label to indicate whether the sun has crossed */
/* the local zenith meridian. */
/* $ Parameters */
/* None. */
/* $ Exceptions */
/* 1) This routine defines local solar time for any point on the */
/* surface of the Sun to be 12:00:00 noon. */
/* 2) If the TYPE of the coordinates is not recognized, the */
/* error 'SPICE(UNKNOWNSYSTEM)' will be signaled. */
/* 3) If the body-fixed frame to associate with BODY cannot be */
/* determined, the error 'SPICE(CANTFINDFRAME)' is signaled. */
/* 4) If insufficient data is available to compute the */
/* location of the sun in body-fixed coordinates, the */
/* error will be diagnosed by a routine called by this one. */
/* 5) If the BODY#_PM keyword required to determine the body */
/* rotation sense is not found in the POOL or if it is found but */
/* is not a numeric keyword with at least two elements, the error */
/* 'SPICE(CANTGETROTATIONTYPE)' is signaled. */
/* $ Files */
/* Suitable SPK and PCK files must be loaded prior to calling this */
/* routine so that the body-fixed position of the sun relative to */
/* BODY can be computed. The PCK files must contain the standard */
/* BODY#_PM keyword need by this routine to determine the body */
/* rotation sense. */
/* When the input longitude is planetographic, the default */
/* interpretation of this value can be overridden using the optional */
/* kernel variable */
/* BODY<body ID>_PGR_POSITIVE_LON */
/* which is normally defined via loading a text kernel. */
/* $ Particulars */
/* This routine returns the local solar time at a user */
/* specified location on a user specified body. */
/* Let SUNLNG be the planetocentric longitude (in degrees) of */
/* the sun as viewed from the center of the body of interest. */
/* Let SITLNG be the planetocentric longitude (in degrees) of */
/* the site for which local time is desired. */
/* We define local time to be 12 + (SITLNG - SUNLNG)/15 */
/* (where appropriate care is taken to map ( SITLNG - SUNLNG ) */
/* into the range from -180 to 180). */
/* Using this definition, we see that from the point of view */
/* of this routine, local solar time is simply a measure of angles */
/* between meridians on the surface of a body. Consequently, */
/* this routine is not appropriate for computing "local times" */
/* in the sense of Pacific Standard Time. For computing times */
/* relative to standard time zones on earth, see the routines */
/* TIMOUT and STR2ET. */
/* Regarding planetographic longitude */
/* ---------------------------------- */
/* In the planetographic coordinate system, longitude is defined */
/* using the spin sense of the body. Longitude is positive to the */
/* west if the spin is prograde and positive to the east if the spin */
/* is retrograde. The spin sense is given by the sign of the first */
/* degree term of the time-dependent polynomial for the body's prime */
/* meridian Euler angle "W": the spin is retrograde if this term is */
/* negative and prograde otherwise. For the sun, planets, most */
/* natural satellites, and selected asteroids, the polynomial */
/* expression for W may be found in a SPICE PCK kernel. */
/* The earth, moon, and sun are exceptions: planetographic longitude */
/* is measured positive east for these bodies. */
/* If you wish to override the default sense of positive */
/* planetographic longitude for a particular body, you can do so by */
/* defining the kernel variable */
/* BODY<body ID>_PGR_POSITIVE_LON */
/* where <body ID> represents the NAIF ID code of the body. This */
/* variable may be assigned either of the values */
/* 'WEST' */
/* 'EAST' */
/* For example, you can have this routine treat the longitude */
/* of the earth as increasing to the west using the kernel */
/* variable assignment */
/* BODY399_PGR_POSITIVE_LON = 'WEST' */
/* Normally such assignments are made by placing them in a text */
/* kernel and loading that kernel via FURNSH. */
/* $ Examples */
/* The following code fragment illustrates how you */
/* could print the local time at a site on Mars with */
/* planetographic longitude 326.17 deg E at epoch ET. */
/* (This example assumes all required SPK and PCK files have */
/* been loaded). */
/* Convert the longitude to radians, set the type of the longitude */
/* and make up a mnemonic for Mars' ID-code. */
/* LONG = 326.17 * RPD() */
/* TYPE = 'PLANETOGRAPHIC' */
/* MARS = 499 */
/* CALL ET2LST ( ET, MARS, LONG, TYPE, HR, MN, SC, TIME, AMPM ) */
/* WRITE (*,*) 'The local time at Mars 326.17 degrees E ' */
/* WRITE (*,*) 'planetographic longitude is: ', AMPM */
/* $ Restrictions */
/* This routine relies on being able to determine the name */
/* of the body-fixed frame associated with BODY through the */
/* frames subsystem. If the BODY specified is NOT one of the */
/* nine planets or their satellites, you will need to load */
/* an appropriate frame definition kernel that contains */
/* the relationship between the body id and the body-fixed frame */
/* name. See the FRAMES required reading for more details */
/* on specifying this relationship. */
/* The routine determines the body rotation sense using the PCK */
/* keyword BODY#_PM. Therefore, you will need to a text PCK file */
/* defining the complete set of the standard PCK body rotation */
/* keywords for the body of interest. The text PCK file must be */
/* loaded independently of whether a binary PCK file providing */
/* rotation data for the same body is loaded or not. */
/* Although it is not currently the case for any of the Solar System */
/* bodies, it is possible that the retrograde rotation rate of a */
/* body would be slower than the orbital rate of the body rotation */
/* around the Sun. The routine does not account for such cases; for */
/* them it will compute incorrect the local time progressing */
/* backwards. */
/* $ Literature_References */
/* None. */
/* $ Author_and_Institution */
/* W.L. Taber (JPL) */
/* $ Version */
/* - SPICELIB Version 3.0.2, 18-APR-2014 (BVS) */
/* Minor edits to long error messages. */
/* - SPICELIB Version 3.0.1, 09-SEP-2009 (EDW) */
/* Header edits: deleted a spurious C$ marker from the */
/* "Detailed_Output" section. The existence of the marker */
/* caused a failure in the HTML documentation creation script. */
/* Deleted the "Revisions" section as it contained several */
/* identical entries from the "Version" section. */
/* Corrected order of header sections. */
/* - SPICELIB Version 3.0.0, 28-OCT-2006 (BVS) */
/* Bug fix: incorrect computation of the local time for the */
/* bodies with the retrograde rotation causing the local time to */
/* flow backwards has been fixed. The local time for all types of */
/* bodies now progresses as expected -- midnight, increasing AM */
/* hours, noon, increasing PM hours, next midnight, and so on. */
/* - SPICELIB Version 2.0.0, 03-NOV-2005 (NJB) */
/* Bug fix: treatment of planetographic longitude has been */
/* updated to be consistent with the SPICE planetographic/ */
/* rectangular coordinate conversion routines. The effect of */
/* this change is that the default sense of positive longitude */
/* for the moon is now east; also, the default sense of positive */
/* planetographic longitude now may be overridden for any body */
/* (see Particulars above). */
/* Updated to remove non-standard use of duplicate arguments */
/* in RMAIND calls. */
/* - SPICELIB Version 1.1.0, 24-MAR-1998 (WLT) */
/* The integer variable SUN was never initialized in the */
/* previous version of the routine. Now it is set to */
/* the proper value of 10. */
/* - SPICELIB Version 1.0.0, 9-JUL-1997 (WLT) */
/* -& */
/* $ Index_Entries */
/* Compute the local time for a point on a body. */
/* -& */
/* SPICELIB Functions */
/* Local parameters */
/* Local Variables */
/* Standard SPICE error handling. */
if (return_()) {
return 0;
}
chkin_("ET2LST", (ftnlen)6);
ljust_(type__, mytype, type_len, (ftnlen)32);
ucase_(mytype, mytype, (ftnlen)32, (ftnlen)32);
if (s_cmp(mytype, "PLANETOGRAPHIC", (ftnlen)32, (ftnlen)14) == 0) {
/* Find planetocentric longitude corresponding to the input */
/* longitude. We first represent in rectangular coordinates */
/* a surface point having zero latitude, zero altitude, and */
/* the input planetographic longitude. We then find the */
/* planetocentric longitude of this point. */
/* Since PGRREC accepts a body name, map the input code to */
/* a name, if possible. Otherwise, just convert the input code */
/* to a string. */
bodc2n_(body, bodnam, &found, (ftnlen)36);
if (! found) {
intstr_(body, bodnam, (ftnlen)36);
}
/* Convert planetographic coordinates to rectangular coordinates. */
/* All we care about here is longitude. Set the other inputs */
/* as follows: */
/* Latitude = 0 */
/* Altitude = 0 */
/* Equatorial radius = 1 */
/* Flattening factor = 0 */
pgrrec_(bodnam, long__, &c_b4, &c_b4, &c_b6, &c_b4, spoint, (ftnlen)
36);
/* The output MYLONG is planetocentric longitude. The other */
/* outputs are not used. Note that the variable RANGE appears */
/* later in another RECLAT call; it's not used after that. */
reclat_(spoint, &range, &mylong, &lat);
} else if (s_cmp(mytype, "PLANETOCENTRIC", (ftnlen)32, (ftnlen)14) == 0) {
mylong = *long__;
} else {
setmsg_("The coordinate system '#' is not a recognized system of lon"
"gitude. The recognized systems are 'PLANETOCENTRIC' and 'PL"
"ANETOGRAPHIC'. ", (ftnlen)134);
errch_("#", type__, (ftnlen)1, type_len);
sigerr_("SPICE(UNKNOWNSYSTEM)", (ftnlen)20);
chkout_("ET2LST", (ftnlen)6);
return 0;
}
/* It's always noon on the surface of the sun. */
if (*body == 10) {
*hr = 12;
*mn = 0;
*sc = 0;
s_copy(time, "12:00:00", time_len, (ftnlen)8);
s_copy(ampm, "12:00:00 P.M.", ampm_len, (ftnlen)13);
chkout_("ET2LST", (ftnlen)6);
return 0;
}
/* Get the body-fixed position of the sun. */
cidfrm_(body, &frcode, frame, &found, (ftnlen)32);
if (! found) {
setmsg_("The body-fixed frame associated with body # could not be de"
"termined. This information needs to be \"loaded\" via a fra"
"mes definition kernel. See frames.req for more details. ", (
ftnlen)174);
errint_("#", body, (ftnlen)1);
sigerr_("SPICE(CANTFINDFRAME)", (ftnlen)20);
chkout_("ET2LST", (ftnlen)6);
return 0;
}
spkez_(&c__10, et, frame, "LT+S", body, state, <, (ftnlen)32, (ftnlen)4)
;
reclat_(state, &range, &slong, &slat);
angle = mylong - slong;
/* Force the angle into the region from -PI to PI */
d__1 = twopi_();
rmaind_(&angle, &d__1, &q, &tmpang);
angle = tmpang;
if (angle > pi_()) {
angle -= twopi_();
}
/* Get the rotation sense of the body and invert the angle if the */
/* rotation sense is retrograde. Use the BODY#_PM PCK keyword to */
/* determine the sense of the body rotation. */
s_copy(bpmkwd, "BODY#_PM", (ftnlen)32, (ftnlen)8);
repmi_(bpmkwd, "#", body, bpmkwd, (ftnlen)32, (ftnlen)1, (ftnlen)32);
dtpool_(bpmkwd, &found, &n, kwtype, (ftnlen)32, (ftnlen)1);
if (! found || *(unsigned char *)kwtype != 'N' || n < 2) {
setmsg_("The rotation type for the body # could not be determined be"
"cause the # keyword was either not found in the POOL or or i"
"t was not of the expected type and/or dimension. This keywor"
"d is usually provided via a planetary constants kernel. See "
"pck.req for more details. ", (ftnlen)265);
errint_("#", body, (ftnlen)1);
errch_("#", bpmkwd, (ftnlen)1, (ftnlen)32);
sigerr_("SPICE(CANTGETROTATIONTYPE)", (ftnlen)26);
chkout_("ET2LST", (ftnlen)6);
return 0;
} else {
/* If the rotation rate is negative, invert the angle. */
gdpool_(bpmkwd, &c__2, &c__1, &n, &rate, &found, (ftnlen)32);
if (rate < 0.) {
angle = -angle;
}
}
/* Convert the angle to "angle seconds" before or after local noon. */
secnds = angle * 86400. / twopi_();
secnds = brcktd_(&secnds, &c_b32, &c_b33);
/* Get the hour, and minutes components of the local time. */
rmaind_(&secnds, &c_b34, &hours, &tmpsec);
rmaind_(&tmpsec, &c_b35, &mins, &secnds);
/* Construct the integer components of the local time. */
*hr = (integer) hours + 12;
*mn = (integer) mins;
*sc = (integer) secnds;
/* Set the A.M./P.M. components of local time. */
if (*hr == 24) {
*hr = 0;
hrampm = 12;
s_copy(amorpm, "A.M.", (ftnlen)4, (ftnlen)4);
} else if (*hr > 12) {
hrampm = *hr - 12;
s_copy(amorpm, "P.M.", (ftnlen)4, (ftnlen)4);
} else if (*hr == 12) {
hrampm = 12;
s_copy(amorpm, "P.M.", (ftnlen)4, (ftnlen)4);
} else if (*hr == 0) {
hrampm = 12;
s_copy(amorpm, "A.M.", (ftnlen)4, (ftnlen)4);
} else {
hrampm = *hr;
s_copy(amorpm, "A.M.", (ftnlen)4, (ftnlen)4);
}
/* Now construct the two strings we need. */
hours = (doublereal) (*hr);
mins = (doublereal) (*mn);
secnds = (doublereal) (*sc);
dpfmt_(&hours, "0x", h__, (ftnlen)2, (ftnlen)2);
dpfmt_(&mins, "0x", m, (ftnlen)2, (ftnlen)2);
dpfmt_(&secnds, "0x", s, (ftnlen)2, (ftnlen)2);
/* Writing concatenation */
i__1[0] = 2, a__1[0] = h__;
i__1[1] = 1, a__1[1] = ":";
i__1[2] = 2, a__1[2] = m;
i__1[3] = 1, a__1[3] = ":";
i__1[4] = 2, a__1[4] = s;
s_cat(time, a__1, i__1, &c__5, time_len);
hours = (doublereal) hrampm;
dpfmt_(&hours, "0x", h__, (ftnlen)2, (ftnlen)2);
/* Writing concatenation */
i__2[0] = 2, a__2[0] = h__;
i__2[1] = 1, a__2[1] = ":";
i__2[2] = 2, a__2[2] = m;
i__2[3] = 1, a__2[3] = ":";
i__2[4] = 2, a__2[4] = s;
i__2[5] = 1, a__2[5] = " ";
i__2[6] = 4, a__2[6] = amorpm;
s_cat(ampm, a__2, i__2, &c__7, ampm_len);
chkout_("ET2LST", (ftnlen)6);
return 0;
} /* et2lst_ */
/* $Procedure SUBPT ( Sub-observer point ) */
/* Subroutine */ int subpt_(char *method, char *target, doublereal *et, char *
abcorr, char *obsrvr, doublereal *spoint, doublereal *alt, ftnlen
method_len, ftnlen target_len, ftnlen abcorr_len, ftnlen obsrvr_len)
{
/* Initialized data */
static doublereal origin[3] = { 0.,0.,0. };
doublereal radii[3];
extern /* Subroutine */ int chkin_(char *, ftnlen), errch_(char *, char *,
ftnlen, ftnlen);
logical found;
extern doublereal vdist_(doublereal *, doublereal *);
extern /* Subroutine */ int spkez_(integer *, doublereal *, char *, char *
, integer *, doublereal *, doublereal *, ftnlen, ftnlen);
extern logical eqstr_(char *, char *, ftnlen, ftnlen);
extern /* Subroutine */ int bods2c_(char *, integer *, logical *, ftnlen);
integer obscde;
doublereal lt;
extern /* Subroutine */ int bodvcd_(integer *, char *, integer *, integer
*, doublereal *, ftnlen);
integer frcode;
extern /* Subroutine */ int cidfrm_(integer *, integer *, char *, logical
*, ftnlen);
integer nradii;
char frname[80];
integer trgcde;
extern /* Subroutine */ int nearpt_(doublereal *, doublereal *,
doublereal *, doublereal *, doublereal *, doublereal *), sigerr_(
char *, ftnlen), chkout_(char *, ftnlen), setmsg_(char *, ftnlen);
doublereal tstate[6];
extern logical return_(void);
extern /* Subroutine */ int vminus_(doublereal *, doublereal *), surfpt_(
doublereal *, doublereal *, doublereal *, doublereal *,
doublereal *, doublereal *, logical *);
doublereal pos[3];
/* $ Abstract */
/* Deprecated: This routine has been superseded by the SPICELIB */
/* routine SUBPNT. This routine is supported for purposes of */
/* backward compatibility only. */
/* Compute the rectangular coordinates of the sub-observer point on */
/* a target body at a particular epoch, optionally corrected for */
/* planetary (light time) and stellar aberration. Return these */
/* coordinates expressed in the body-fixed frame associated with the */
/* target body. Also, return the observer's altitude above the */
/* target body. */
/* $ Disclaimer */
/* THIS SOFTWARE AND ANY RELATED MATERIALS WERE CREATED BY THE */
/* CALIFORNIA INSTITUTE OF TECHNOLOGY (CALTECH) UNDER A U.S. */
/* GOVERNMENT CONTRACT WITH THE NATIONAL AERONAUTICS AND SPACE */
/* ADMINISTRATION (NASA). THE SOFTWARE IS TECHNOLOGY AND SOFTWARE */
/* PUBLICLY AVAILABLE UNDER U.S. EXPORT LAWS AND IS PROVIDED "AS-IS" */
/* TO THE RECIPIENT WITHOUT WARRANTY OF ANY KIND, INCLUDING ANY */
/* WARRANTIES OF PERFORMANCE OR MERCHANTABILITY OR FITNESS FOR A */
/* PARTICULAR USE OR PURPOSE (AS SET FORTH IN UNITED STATES UCC */
/* SECTIONS 2312-2313) OR FOR ANY PURPOSE WHATSOEVER, FOR THE */
/* SOFTWARE AND RELATED MATERIALS, HOWEVER USED. */
/* IN NO EVENT SHALL CALTECH, ITS JET PROPULSION LABORATORY, OR NASA */
/* BE LIABLE FOR ANY DAMAGES AND/OR COSTS, INCLUDING, BUT NOT */
/* LIMITED TO, INCIDENTAL OR CONSEQUENTIAL DAMAGES OF ANY KIND, */
/* INCLUDING ECONOMIC DAMAGE OR INJURY TO PROPERTY AND LOST PROFITS, */
/* REGARDLESS OF WHETHER CALTECH, JPL, OR NASA BE ADVISED, HAVE */
/* REASON TO KNOW, OR, IN FACT, SHALL KNOW OF THE POSSIBILITY. */
/* RECIPIENT BEARS ALL RISK RELATING TO QUALITY AND PERFORMANCE OF */
/* THE SOFTWARE AND ANY RELATED MATERIALS, AND AGREES TO INDEMNIFY */
/* CALTECH AND NASA FOR ALL THIRD-PARTY CLAIMS RESULTING FROM THE */
/* ACTIONS OF RECIPIENT IN THE USE OF THE SOFTWARE. */
/* $ Required_Reading */
/* FRAMES */
/* PCK */
/* SPK */
/* TIME */
/* $ Keywords */
/* GEOMETRY */
/* $ Declarations */
/* $ Brief_I/O */
/* Variable I/O Description */
/* -------- --- -------------------------------------------------- */
/* METHOD I Computation method. */
/* TARGET I Name of target body. */
/* ET I Epoch in ephemeris seconds past J2000 TDB. */
/* ABCORR I Aberration correction. */
/* OBSRVR I Name of observing body. */
/* SPOINT O Sub-observer point on the target body. */
/* ALT O Altitude of the observer above the target body. */
/* $ Detailed_Input */
/* METHOD is a short string specifying the computation method */
/* to be used. The choices are: */
/* 'Near point' The sub-observer point is */
/* defined as the nearest point on */
/* the target relative to the */
/* observer. */
/* 'Intercept' The sub-observer point is */
/* defined as the target surface */
/* intercept of the line */
/* containing the observer and the */
/* target's center. */
/* In both cases, the intercept computation treats the */
/* surface of the target body as a triaxial ellipsoid. */
/* The ellipsoid's radii must be available in the kernel */
/* pool. */
/* Neither case nor white space are significant in */
/* METHOD. For example, the string ' NEARPOINT' is */
/* valid. */
/* TARGET is the name of a target body. Optionally, you may */
/* supply the integer ID code for the object as */
/* an integer string. For example both 'MOON' and */
/* '301' are legitimate strings that indicate the */
/* moon is the target body. This routine assumes */
/* that this body is modeled by a tri-axial ellipsoid, */
/* and that a PCK file containing its radii has been */
/* loaded into the kernel pool via FURNSH. */
/* ET is the epoch in ephemeris seconds past J2000 at which */
/* the sub-observer point on the target body is to be */
/* computed. */
/* ABCORR indicates the aberration corrections to be applied */
/* when computing the observer-target state. ABCORR */
/* may be any of the following. */
/* 'NONE' Apply no correction. Return the */
/* geometric sub-observer point on the */
/* target body. */
/* 'LT' Correct for planetary (light time) */
/* aberration. Both the state and rotation */
/* of the target body are corrected for */
/* light time. */
/* 'LT+S' Correct for planetary (light time) and */
/* stellar aberrations. Both the state and */
/* rotation of the target body are */
/* corrected for light time. */
/* 'CN' Converged Newtonian light time */
/* corrections. This is the same as LT */
/* corrections but with further iterations */
/* to a converged Newtonian light time */
/* solution. Given that relativistic */
/* effects may be as large as the higher */
/* accuracy achieved by this computation, */
/* this is correction is seldom worth the */
/* additional computations required unless */
/* the user incorporates additional */
/* relativistic corrections. Both the */
/* state and rotation of the target body */
/* are corrected for light time. */
/* 'CN+S' Converged Newtonian light time */
/* corrections and stellar aberration. */
/* Both the state and rotation of the */
/* target body are corrected for light */
/* time. */
/* OBSRVR is the name of the observing body. This is typically */
/* a spacecraft, the earth, or a surface point on the */
/* earth. Optionally, you may supply the ID code of */
/* the object as an integer string. For example, both */
/* 'EARTH' and '399' are legitimate strings to supply */
/* to indicate the observer is Earth. */
/* $ Detailed_Output */
/* SPOINT is the sub-observer point on the target body at ET */
/* expressed relative to the body-fixed frame of the */
/* target body. */
/* The sub-observer point is defined either as the point */
/* on the target body that is closest to the observer, */
/* or the target surface intercept of the line from the */
/* observer to the target's center; the input argument */
/* METHOD selects the definition to be used. */
/* The body-fixed frame, which is time-dependent, is */
/* evaluated at ET if ABCORR is 'NONE'; otherwise the */
/* frame is evaluated at ET-LT, where LT is the one-way */
/* light time from target to observer. */
/* The state of the target body is corrected for */
/* aberration as specified by ABCORR; the corrected */
/* state is used in the geometric computation. As */
/* indicated above, the rotation of the target is */
/* retarded by one-way light time if ABCORR specifies */
/* that light time correction is to be done. */
/* ALT is the "altitude" of the observer above the target */
/* body. When METHOD specifies a "near point" */
/* computation, ALT is truly altitude in the standard */
/* geometric sense: the length of a segment dropped from */
/* the observer to the target's surface, such that the */
/* segment is perpendicular to the surface at the */
/* contact point SPOINT. */
/* When METHOD specifies an "intercept" computation, ALT */
/* is still the length of the segment from the observer */
/* to the surface point SPOINT, but this segment in */
/* general is not perpendicular to the surface. */
/* $ Parameters */
/* None. */
/* $ Exceptions */
/* If any of the listed errors occur, the output arguments are */
/* left unchanged. */
/* 1) If the input argument METHOD is not recognized, the error */
/* SPICE(DUBIOUSMETHOD) is signaled. */
/* 2) If either of the input body names TARGET or OBSRVR cannot be */
/* mapped to NAIF integer codes, the error SPICE(IDCODENOTFOUND) */
/* is signaled. */
/* 3) If OBSRVR and TARGET map to the same NAIF integer ID codes, the */
/* error SPICE(BODIESNOTDISTINCT) is signaled. */
/* 4) If frame definition data enabling the evaluation of the state */
/* of the target relative to the observer in target body-fixed */
/* coordinates have not been loaded prior to calling SUBPT, the */
/* error will be diagnosed and signaled by a routine in the call */
/* tree of this routine. */
/* 5) If the specified aberration correction is not recognized, the */
/* error will be diagnosed and signaled by a routine in the call */
/* tree of this routine. */
/* 6) If insufficient ephemeris data have been loaded prior to */
/* calling SUBPT, the error will be diagnosed and signaled by a */
/* routine in the call tree of this routine. */
/* 7) If the triaxial radii of the target body have not been loaded */
/* into the kernel pool prior to calling SUBPT, the error will be */
/* diagnosed and signaled by a routine in the call tree of this */
/* routine. */
/* 8) The target must be an extended body: if any of the radii of */
/* the target body are non-positive, the error will be diagnosed */
/* and signaled by routines in the call tree of this routine. */
/* 9) If PCK data supplying a rotation model for the target body */
/* have not been loaded prior to calling SUBPT, the error will be */
/* diagnosed and signaled by a routine in the call tree of this */
/* routine. */
/* $ Files */
/* Appropriate SPK, PCK, and frame kernels must be loaded */
/* prior by the calling program before this routine is called. */
/* The following data are required: */
/* - SPK data: ephemeris data for target and observer must be */
/* loaded. If aberration corrections are used, the states of */
/* target and observer relative to the solar system barycenter */
/* must be calculable from the available ephemeris data. */
/* Typically ephemeris data are made available by loading one */
/* or more SPK files via FURNSH. */
/* - PCK data: triaxial radii for the target body must be loaded */
/* into the kernel pool. Typically this is done by loading a */
/* text PCK file via FURNSH. */
/* - Further PCK data: rotation data for the target body must */
/* be loaded. These may be provided in a text or binary PCK */
/* file. Either type of file may be loaded via FURNSH. */
/* - Frame data: if a frame definition is required to convert */
/* the observer and target states to the body-fixed frame of */
/* the target, that definition must be available in the kernel */
/* pool. Typically the definition is supplied by loading a */
/* frame kernel via FURNSH. */
/* In all cases, kernel data are normally loaded once per program */
/* run, NOT every time this routine is called. */
/* $ Particulars */
/* SUBPT computes the sub-observer point on a target body. */
/* (The sub-observer point is commonly called the sub-spacecraft */
/* point when the observer is a spacecraft.) SUBPT also */
/* determines the altitude of the observer above the target body. */
/* There are two different popular ways to define the sub-observer */
/* point: "nearest point on target to observer" or "target surface */
/* intercept of line containing observer and target." These */
/* coincide when the target is spherical and generally are distinct */
/* otherwise. */
/* When comparing sub-point computations with results from sources */
/* other than SPICE, it's essential to make sure the same geometric */
/* definitions are used. */
/* $ Examples */
/* The numerical results shown for this example may differ across */
/* platforms. The results depend on the SPICE kernels used as */
/* input, the compiler and supporting libraries, and the machine */
/* specific arithmetic implementation. */
/* In the following example program, the file */
/* spk_m_031103-040201_030502.bsp */
/* is a binary SPK file containing data for Mars Global Surveyor, */
/* Mars, and the Sun for a time interval bracketing the date */
/* 2004 JAN 1 12:00:00 UTC. */
/* pck00007.tpc is a planetary constants kernel file containing */
/* radii and rotation model constants. naif0007.tls is a */
/* leapseconds kernel. */
/* Find the sub-observer point of the Mars Global Surveyor (MGS) */
/* spacecraft on Mars for a specified time. Perform the computation */
/* twice, using both the "intercept" and "near point" options. */
/* IMPLICIT NONE */
/* CHARACTER*25 METHOD ( 2 ) */
/* INTEGER I */
/* DOUBLE PRECISION ALT */
/* DOUBLE PRECISION DPR */
/* DOUBLE PRECISION ET */
/* DOUBLE PRECISION LAT */
/* DOUBLE PRECISION LON */
/* DOUBLE PRECISION RADIUS */
/* DOUBLE PRECISION SPOINT ( 3 ) */
/* DATA METHOD / 'Intercept', 'Near point' / */
/* C */
/* C Load kernel files. */
/* C */
/* CALL FURNSH ( 'naif0007.tls' ) */
/* CALL FURNSH ( 'pck00007.tpc' ) */
/* CALL FURNSH ( 'spk_m_031103-040201_030502.bsp' ) */
/* C */
/* C Convert the UTC request time to ET (seconds past */
/* C J2000, TDB). */
/* C */
/* CALL STR2ET ( '2004 JAN 1 12:00:00', ET ) */
/* C */
/* C Compute sub-spacecraft point using light time and stellar */
/* C aberration corrections. Use the "target surface intercept" */
/* C definition of sub-spacecraft point on the first loop */
/* C iteration, and use the "near point" definition on the */
/* C second. */
/* C */
/* DO I = 1, 2 */
/* CALL SUBPT ( METHOD(I), */
/* . 'MARS', ET, 'LT+S', */
/* . 'MGS', SPOINT, ALT ) */
/* C */
/* C Convert rectangular coordinates to planetocentric */
/* C latitude and longitude. Convert radians to degrees. */
/* C */
/* CALL RECLAT ( SPOINT, RADIUS, LON, LAT ) */
/* LON = LON * DPR () */
/* LAT = LAT * DPR () */
/* C */
/* C Write the results. */
/* C */
/* WRITE (*,*) ' ' */
/* WRITE (*,*) 'Computation method: ', METHOD(I) */
/* WRITE (*,*) ' ' */
/* WRITE (*,*) ' Radius (km) = ', RADIUS */
/* WRITE (*,*) ' Planetocentric Latitude (deg) = ', LAT */
/* WRITE (*,*) ' Planetocentric Longitude (deg) = ', LON */
/* WRITE (*,*) ' Altitude (km) = ', ALT */
/* WRITE (*,*) ' ' */
/* END DO */
/* END */
/* When this program is executed, the output will be: */
/* Computation method: Intercept */
/* Radius (km) = 3387.97077 */
/* Planetocentric Latitude (deg) = -39.7022724 */
/* Planetocentric Longitude (deg) = -159.226663 */
/* Altitude (km) = 373.173506 */
/* Computation method: Near point */
/* Radius (km) = 3387.9845 */
/* Planetocentric Latitude (deg) = -39.6659329 */
/* Planetocentric Longitude (deg) = -159.226663 */
/* Altitude (km) = 373.166636 */
/* $ Restrictions */
/* None. */
/* $ Literature_References */
/* None. */
/* $ Author_and_Institution */
/* C.H. Acton (JPL) */
/* N.J. Bachman (JPL) */
/* J.E. McLean (JPL) */
/* $ Version */
/* - SPICELIB Version 1.2.3, 18-MAY-2010 (BVS) */
/* Index line now states that this routine is deprecated. */
/* - SPICELIB Version 1.2.2, 17-MAR-2009 (EDW) */
/* Typo correction in Required_Reading, changed */
/* FRAME to FRAMES. */
/* - SPICELIB Version 1.2.1, 07-FEB-2008 (NJB) */
/* Abstract now states that this routine is deprecated. */
/* - SPICELIB Version 1.2.0, 24-OCT-2005 (NJB) */
/* Replaced call to BODVAR with call to BODVCD. */
/* - SPICELIB Version 1.1.0, 21-JUL-2004 (EDW) */
/* Changed BODN2C call to BODS2C giving the routine */
/* the capability to accept string representations of */
/* interger IDs for TARGET and OBSRVR. */
/* - SPICELIB Version 1.0.1, 27-JUL-2003 (NJB) (CHA) */
/* Various header corrections were made. The example program */
/* was upgraded to use real kernels, and the program's output is */
/* shown. */
/* - SPICELIB Version 1.0.0, 03-SEP-1999 (NJB) (JEM) */
/* -& */
/* $ Index_Entries */
/* DEPRECATED sub-observer point */
/* -& */
/* SPICELIB functions */
/* Local parameters */
/* Local variables */
/* Saved variables */
/* Initial values */
/* Standard SPICE error handling. */
if (return_()) {
return 0;
} else {
chkin_("SUBPT", (ftnlen)5);
}
/* Obtain integer codes for the target and observer. */
/* Target... */
bods2c_(target, &trgcde, &found, target_len);
if (! found) {
setmsg_("The target, '#', is not a recognized name for an ephemeris "
"object. The cause of this problem may be that you need an up"
"dated version of the SPICE Toolkit. ", (ftnlen)155);
errch_("#", target, (ftnlen)1, target_len);
sigerr_("SPICE(IDCODENOTFOUND)", (ftnlen)21);
chkout_("SUBPT", (ftnlen)5);
return 0;
}
/* ...observer. */
bods2c_(obsrvr, &obscde, &found, obsrvr_len);
if (! found) {
setmsg_("The observer, '#', is not a recognized name for an ephemeri"
"s object. The cause of this problem may be that you need an "
"updated version of the SPICE Toolkit. ", (ftnlen)157);
errch_("#", obsrvr, (ftnlen)1, obsrvr_len);
sigerr_("SPICE(IDCODENOTFOUND)", (ftnlen)21);
chkout_("SUBPT", (ftnlen)5);
return 0;
}
/* Check the input body codes. If they are equal, signal */
/* an error. */
if (obscde == trgcde) {
setmsg_("In computing the sub-observer point, the observing body and"
" target body are the same. Both are #.", (ftnlen)97);
errch_("#", obsrvr, (ftnlen)1, obsrvr_len);
sigerr_("SPICE(BODIESNOTDISTINCT)", (ftnlen)24);
chkout_("SUBPT", (ftnlen)5);
return 0;
}
/* Get the radii of the target body from the kernel pool. */
bodvcd_(&trgcde, "RADII", &c__3, &nradii, radii, (ftnlen)5);
/* Find the name of the body-fixed frame associated with the */
/* target body. We'll want the state of the target relative to */
/* the observer in this body-fixed frame. */
cidfrm_(&trgcde, &frcode, frname, &found, (ftnlen)80);
if (! found) {
setmsg_("No body-fixed frame is associated with target body #; a fra"
"me kernel must be loaded to make this association. Consult "
"the FRAMES Required Reading for details.", (ftnlen)159);
errch_("#", target, (ftnlen)1, target_len);
sigerr_("SPICE(NOFRAME)", (ftnlen)14);
chkout_("SUBPT", (ftnlen)5);
return 0;
}
/* Determine the position of the observer in target */
/* body-fixed coordinates. */
/* - Call SPKEZR to compute the position of the target */
/* body as seen from the observing body and the light time */
/* (LT) between them. SPKEZR returns a state which is */
/* the position and velocity, but we'll only use the position */
/* which is the first three elements. We request that the */
/* coordinates of POS be returned relative to the body fixed */
/* reference frame associated with the target body, using */
/* aberration corrections specified by the input argument */
/* ABCORR. */
/* - Call VMINUS to negate the direction of the vector (POS) */
/* so it will be the position of the observer as seen from */
/* the target body in target body fixed coordinates. */
/* Note that this result is not the same as the result of */
/* calling SPKEZR with the target and observer switched. We */
/* computed the vector FROM the observer TO the target in */
/* order to get the proper light time and stellar aberration */
/* corrections (if requested). Now we need the inverse of */
/* that corrected vector in order to compute the sub-point. */
spkez_(&trgcde, et, frname, abcorr, &obscde, tstate, <, (ftnlen)80,
abcorr_len);
/* Negate the target's state to obtain the position of the observer */
/* relative to the target. */
vminus_(tstate, pos);
/* Find the sub-point and "altitude" (distance from observer to */
/* sub-point) using the specified geometric definition. */
if (eqstr_(method, "Near point", method_len, (ftnlen)10)) {
/* Locate the nearest point to the observer on the target. */
nearpt_(pos, radii, &radii[1], &radii[2], spoint, alt);
} else if (eqstr_(method, "Intercept", method_len, (ftnlen)9)) {
surfpt_(origin, pos, radii, &radii[1], &radii[2], spoint, &found);
/* Since the line in question passes through the center of the */
/* target, there will always be a surface intercept. So we should */
/* never have FOUND = .FALSE. */
if (! found) {
setmsg_("Call to SURFPT returned FOUND=FALSE even though vertex "
"of ray is at target center. This indicates a bug. Please"
" contact NAIF.", (ftnlen)125);
sigerr_("SPICE(BUG)", (ftnlen)10);
chkout_("SUBPT", (ftnlen)5);
return 0;
}
/* SURFPT doesn't compute altitude, so do it here. */
*alt = vdist_(pos, spoint);
} else {
setmsg_("The computation method # was not recognized. Allowed values"
" are \"Near point\" and \"Intercept.\"", (ftnlen)93);
errch_("#", method, (ftnlen)1, method_len);
sigerr_("SPICE(DUBIOUSMETHOD)", (ftnlen)20);
chkout_("SUBPT", (ftnlen)5);
return 0;
}
chkout_("SUBPT", (ftnlen)5);
return 0;
} /* subpt_ */
void spkez_c ( SpiceInt targ,
SpiceDouble et,
ConstSpiceChar *ref,
ConstSpiceChar *abcorr,
SpiceInt obs,
SpiceDouble starg[6],
SpiceDouble *lt )
/*
-Brief_I/O
Variable I/O Description
-------- --- --------------------------------------------------
targ I Target body.
et I Observer epoch.
ref I Reference frame of output state vector.
abcorr I Aberration correction flag.
obs I Observing body.
starg O State of target.
lt O One way light time between observer and target.
-Detailed_Input
targ is the NAIF ID code for a target body. The target
and observer define a state vector whose position
component points from the observer to the target.
et is the ephemeris time, expressed as seconds past J2000
TDB, at which the state of the target body relative to
the observer is to be computed. `et' refers to time at
the observer's location.
ref is the name of the reference frame relative to which
the output state vector should be expressed. This may
be any frame supported by the SPICE system, including
built-in frames (documented in the Frames Required
Reading) and frames defined by a loaded frame kernel
(FK).
When `ref' designates a non-inertial frame, the
orientation of the frame is evaluated at an epoch
dependent on the selected aberration correction.
See the description of the output state vector `starg'
for details.
abcorr indicates the aberration corrections to be applied
to the state of the target body to account for one-way
light time and stellar aberration. See the discussion
in the Particulars section for recommendations on
how to choose aberration corrections.
`abcorr' may be any of the following:
"NONE" Apply no correction. Return the
geometric state of the target body
relative to the observer.
The following values of `abcorr' apply to the
"reception" case in which photons depart from the
target's location at the light-time corrected epoch
et-lt and *arrive* at the observer's location at
`et':
"LT" Correct for one-way light time (also
called "planetary aberration") using a
Newtonian formulation. This correction
yields the state of the target at the
moment it emitted photons arriving at
the observer at `et'.
The light time correction uses an
iterative solution of the light time
equation (see Particulars for details).
The solution invoked by the "LT" option
uses one iteration.
"LT+S" Correct for one-way light time and
stellar aberration using a Newtonian
formulation. This option modifies the
state obtained with the "LT" option to
account for the observer's velocity
relative to the solar system
barycenter. The result is the apparent
state of the target---the position and
velocity of the target as seen by the
observer.
"CN" Converged Newtonian light time
correction. In solving the light time
equation, the "CN" correction iterates
until the solution converges (three
iterations on all supported platforms).
The "CN" correction typically does not
substantially improve accuracy because
the errors made by ignoring
relativistic effects may be larger than
the improvement afforded by obtaining
convergence of the light time solution.
The "CN" correction computation also
requires a significantly greater number
of CPU cycles than does the
one-iteration light time correction.
"CN+S" Converged Newtonian light time
and stellar aberration corrections.
The following values of `abcorr' apply to the
"transmission" case in which photons *depart* from
the observer's location at `et' and arrive at the
target's location at the light-time corrected epoch
et+lt:
"XLT" "Transmission" case: correct for
one-way light time using a Newtonian
formulation. This correction yields the
state of the target at the moment it
receives photons emitted from the
observer's location at `et'.
"XLT+S" "Transmission" case: correct for
one-way light time and stellar
aberration using a Newtonian
formulation This option modifies the
state obtained with the "XLT" option to
account for the observer's velocity
relative to the solar system
barycenter. The position component of
the computed target state indicates the
direction that photons emitted from the
observer's location must be "aimed" to
hit the target.
"XCN" "Transmission" case: converged
Newtonian light time correction.
"XCN+S" "Transmission" case: converged
Newtonian light time and stellar
aberration corrections.
Neither special nor general relativistic effects are
accounted for in the aberration corrections applied
by this routine.
Case and blanks are not significant in the string
`abcorr'.
obs is the NAIF ID code for an observing body.
-Detailed_Output
starg is a Cartesian state vector representing the position
and velocity of the target body relative to the
specified observer. `starg' is corrected for the
specified aberrations, and is expressed with respect
to the reference frame specified by `ref'. The first
three components of `starg' represent the x-, y- and
z-components of the target's position; the last three
components form the corresponding velocity vector.
Units are always km and km/sec.
The position component of `starg' points from the
observer's location at `et' to the aberration-corrected
location of the target. Note that the sense of the
position vector is independent of the direction of
radiation travel implied by the aberration
correction.
The velocity component of `starg' is the derivative
with respect to time of the position component of
`starg.'
Non-inertial frames are treated as follows: letting
`ltcent' be the one-way light time between the observer
and the central body associated with the frame, the
orientation of the frame is evaluated at et-ltcent,
et+ltcent, or `et' depending on whether the requested
aberration correction is, respectively, for received
radiation, transmitted radiation, or is omitted. `ltcent'
is computed using the method indicated by `abcorr'.
lt is the one-way light time between the observer and
target in seconds. If the target state is corrected
for aberrations, then 'lt' is the one-way light time
between the observer and the light time corrected
target location.
-Parameters
None.
-Exceptions
1) If the reference frame 'ref' is not a recognized reference
frame the error SPICE(UNKNOWNFRAME) is signaled.
2) If the loaded kernels provide insufficient data to
compute the requested state vector, the deficiency will
be diagnosed by a routine in the call tree of this routine.
3) If an error occurs while reading an SPK or other kernel file,
the error will be diagnosed by a routine in the call tree
of this routine.
-Files
This routine computes states using SPK files that have been
loaded into the SPICE system, normally via the kernel loading
interface routine furnsh_c. See the routine furnsh_c and the SPK
and KERNEL Required Reading for further information on loading
(and unloading) kernels.
If the output state `starg' is to be expressed relative to a
non-inertial frame, or if any of the ephemeris data used to
compute `starg' are expressed relative to a non-inertial frame in
the SPK files providing those data, additional kernels may be
needed to enable the reference frame transformations required to
compute the state. These additional kernels may be C-kernels, PCK
files or frame kernels. Any such kernels must already be loaded
at the time this routine is called.
-Particulars
This routine is part of the user interface to the SPICE ephemeris
system. It allows you to retrieve state information for any
ephemeris object relative to any other in a reference frame that
is convenient for further computations.
Aberration corrections
======================
In space science or engineering applications one frequently
wishes to know where to point a remote sensing instrument, such
as an optical camera or radio antenna, in order to observe or
otherwise receive radiation from a target. This pointing problem
is complicated by the finite speed of light: one needs to point
to where the target appears to be as opposed to where it actually
is at the epoch of observation. We use the adjectives
"geometric," "uncorrected," or "true" to refer to an actual
position or state of a target at a specified epoch. When a
geometric position or state vector is modified to reflect how it
appears to an observer, we describe that vector by any of the
terms "apparent," "corrected," "aberration corrected," or "light
time and stellar aberration corrected." The SPICE Toolkit can
correct for two phenomena affecting the apparent location of an
object: one-way light time (also called "planetary aberration") and
stellar aberration.
One-way light time
------------------
Correcting for one-way light time is done by computing, given an
observer and observation epoch, where a target was when the observed
photons departed the target's location. The vector from the
observer to this computed target location is called a "light time
corrected" vector. The light time correction depends on the motion
of the target relative to the solar system barycenter, but it is
independent of the velocity of the observer relative to the solar
system barycenter. Relativistic effects such as light bending and
gravitational delay are not accounted for in the light time
correction performed by this routine.
Stellar aberration
------------------
The velocity of the observer also affects the apparent location
of a target: photons arriving at the observer are subject to a
"raindrop effect" whereby their velocity relative to the observer
is, using a Newtonian approximation, the photons' velocity
relative to the solar system barycenter minus the velocity of the
observer relative to the solar system barycenter. This effect is
called "stellar aberration." Stellar aberration is independent
of the velocity of the target. The stellar aberration formula
used by this routine does not include (the much smaller)
relativistic effects.
Stellar aberration corrections are applied after light time
corrections: the light time corrected target position vector is
used as an input to the stellar aberration correction.
When light time and stellar aberration corrections are both
applied to a geometric position vector, the resulting position
vector indicates where the target "appears to be" from the
observer's location.
As opposed to computing the apparent position of a target, one
may wish to compute the pointing direction required for
transmission of photons to the target. This also requires correction
of the geometric target position for the effects of light time
and stellar aberration, but in this case the corrections are
computed for radiation traveling *from* the observer to the target.
We will refer to this situation as the "transmission" case.
The "transmission" light time correction yields the target's
location as it will be when photons emitted from the observer's
location at `et' arrive at the target. The transmission stellar
aberration correction is the inverse of the traditional stellar
aberration correction: it indicates the direction in which
radiation should be emitted so that, using a Newtonian
approximation, the sum of the velocity of the radiation relative
to the observer and of the observer's velocity, relative to the
solar system barycenter, yields a velocity vector that points in
the direction of the light time corrected position of the target.
One may object to using the term "observer" in the transmission
case, in which radiation is emitted from the observer's location.
The terminology was retained for consistency with earlier
documentation.
Below, we indicate the aberration corrections to use for some
common applications:
1) Find the apparent direction of a target. This is
the most common case for a remote-sensing observation.
Use "LT+S": apply both light time and stellar
aberration corrections.
Note that using light time corrections alone ("LT") is
generally not a good way to obtain an approximation to an
apparent target vector: since light time and stellar
aberration corrections often partially cancel each other,
it may be more accurate to use no correction at all than to
use light time alone.
2) Find the corrected pointing direction to radiate a signal
to a target. This computation is often applicable for
implementing communications sessions.
Use "XLT+S": apply both light time and stellar
aberration corrections for transmission.
3) Compute the apparent position of a target body relative
to a star or other distant object.
Use "LT" or "LT+S" as needed to match the correction
applied to the position of the distant object. For
example, if a star position is obtained from a catalog,
the position vector may not be corrected for stellar
aberration. In this case, to find the angular
separation of the star and the limb of a planet, the
vector from the observer to the planet should be
corrected for light time but not stellar aberration.
4) Obtain an uncorrected state vector derived directly from
data in an SPK file.
Use "NONE".
5) Use a geometric state vector as a low-accuracy estimate
of the apparent state for an application where execution
speed is critical.
Use "NONE".
6) While this routine cannot perform the relativistic
aberration corrections required to compute states
with the highest possible accuracy, it can supply the
geometric states required as inputs to these computations.
Use "NONE", then apply relativistic aberration
corrections (not available in the SPICE Toolkit).
Below, we discuss in more detail how the aberration corrections
applied by this routine are computed.
Geometric case
==============
spkez_c begins by computing the geometric position T(et) of the
target body relative to the solar system barycenter (SSB).
Subtracting the geometric position of the observer O(et) gives
the geometric position of the target body relative to the
observer. The one-way light time, 'lt', is given by
| T(et) - O(et) |
lt = -------------------
c
The geometric relationship between the observer, target, and
solar system barycenter is as shown:
SSB ---> O(et)
| /
| /
| /
| / T(et) - O(et)
V V
T(et)
The returned state consists of the position vector
T(et) - O(et)
and a velocity obtained by taking the difference of the
corresponding velocities. In the geometric case, the
returned velocity is actually the time derivative of the
position.
Reception case
==============
When any of the options "LT", "CN", "LT+S", "CN+S" is selected
for `abcorr', spkez_c computes the position of the target body at
epoch et-lt, where 'lt' is the one-way light time. Let T(t) and
O(t) represent the positions of the target and observer
relative to the solar system barycenter at time t; then 'lt' is
the solution of the light-time equation
| T(et-lt) - O(et) |
lt = ------------------------ (1)
c
The ratio
| T(et) - O(et) |
--------------------- (2)
c
is used as a first approximation to 'lt'; inserting (2) into the
right hand side of the light-time equation (1) yields the
"one-iteration" estimate of the one-way light time ("LT").
Repeating the process until the estimates of 'lt' converge yields
the "converged Newtonian" light time estimate ("CN").
Subtracting the geometric position of the observer O(et) gives
the position of the target body relative to the observer:
T(et-lt) - O(et).
SSB ---> O(et)
| \ |
| \ |
| \ | T(et-lt) - O(et)
| \ |
V V V
T(et) T(et-lt)
The position component of the light time corrected state
is the vector
T(et-lt) - O(et)
The velocity component of the light time corrected state
is the difference
T_vel(et-lt)*(1-d(lt)/d(et)) - O_vel(et)
where T_vel and O_vel are, respectively, the velocities of the
target and observer relative to the solar system barycenter at
the epochs et-lt and 'et'.
If correction for stellar aberration is requested, the target
position is rotated toward the solar system barycenter-relative
velocity vector of the observer. The rotation is computed as
follows:
Let r be the light time corrected vector from the observer
to the object, and v be the velocity of the observer with
respect to the solar system barycenter. Let w be the angle
between them. The aberration angle phi is given by
sin(phi) = v sin(w) / c
Let h be the vector given by the cross product
h = r X v
Rotate r by phi radians about h to obtain the apparent
position of the object.
When stellar aberration corrections are used, the rate of change
of the stellar aberration correction is accounted for in the
computation of the output velocity.
Transmission case
==================
When any of the options "XLT", "XCN", "XLT+S", "XCN+S" is
selected, spkez_c computes the position of the target body T at
epoch et+lt, where 'lt' is the one-way light time. 'lt' is the
solution of the light-time equation
| T(et+lt) - O(et) |
lt = ------------------------ (3)
c
Subtracting the geometric position of the observer, O(et),
gives the position of the target body relative to the
observer: T(et-lt) - O(et).
SSB --> O(et)
/ | *
/ | * T(et+lt) - O(et)
/ |*
/ *|
V V V
T(et+lt) T(et)
The position component of the light-time corrected state
is the vector
T(et+lt) - O(et)
The velocity component of the light-time corrected state
consists of the difference
T_vel(et+lt)*(1+d(lt)/d(et)) - O_vel(et)
where T_vel and O_vel are, respectively, the velocities of the
target and observer relative to the solar system barycenter at
the epochs et+lt and 'et'.
If correction for stellar aberration is requested, the target
position is rotated away from the solar system barycenter-
relative velocity vector of the observer. The rotation is
computed as in the reception case, but the sign of the
rotation angle is negated.
Precision of light time corrections
===================================
Corrections using one iteration of the light time solution
----------------------------------------------------------
When the requested aberration correction is "LT", "LT+S",
"XLT", or "XLT+S", only one iteration is performed in the
algorithm used to compute 'lt'.
The relative error in this computation
| LT_ACTUAL - LT_COMPUTED | / LT_ACTUAL
is at most
(V/C)**2
----------
1 - (V/C)
which is well approximated by (V/C)**2, where V is the
velocity of the target relative to an inertial frame and C is
the speed of light.
For nearly all objects in the solar system V is less than 60
km/sec. The value of C is 300000 km/sec. Thus the one
iteration solution for 'lt' has a potential relative error of
not more than 4*10**-8. This is a potential light time error
of approximately 2*10**-5 seconds per astronomical unit of
distance separating the observer and target. Given the bound
on V cited above:
As long as the observer and target are
separated by less than 50 astronomical units,
the error in the light time returned using
the one-iteration light time corrections
is less than 1 millisecond.
Converged corrections
---------------------
When the requested aberration correction is "CN", "CN+S",
"XCN", or "XCN+S", three iterations are performed in the
computation of 'lt'. The relative error present in this
solution is at most
(V/C)**4
----------
1 - (V/C)
which is well approximated by (V/C)**4. Mathematically the
precision of this computation is better than a nanosecond for
any pair of objects in the solar system.
However, to model the actual light time between target and
observer one must take into account effects due to general
relativity. These may be as high as a few hundredths of a
millisecond for some objects.
When one considers the extra time required to compute the
converged Newtonian light time (the state of the target relative
to the solar system barycenter is looked up three times instead
of once) together with the real gain in accuracy, it seems
unlikely that you will want to request either the "CN" or "CN+S"
light time corrections. However, these corrections can be useful
for testing situations where high precision (as opposed to
accuracy) is required.
Relativistic Corrections
=========================
This routine does not attempt to perform either general or
special relativistic corrections in computing the various
aberration corrections. For many applications relativistic
corrections are not worth the expense of added computation
cycles. If however, your application requires these additional
corrections we suggest you consult the astronomical almanac (page
B36) for a discussion of how to carry out these corrections.
-Examples
1) Load a planetary ephemeris SPK, then look up a series of
geometric states of the moon relative to the earth,
referenced to the J2000 frame.
#include <stdio.h>
#include "SpiceUsr.h"
int main()
{
#define ABCORR "NONE"
#define FRAME "J2000"
/.
The name of the SPK file shown here is fictitious;
you must supply the name of an SPK file available
on your own computer system.
./
#define SPK "planetary_spk.bsp"
/.
ET0 represents the date 2000 Jan 1 12:00:00 TDB.
./
#define ET0 0.0
/.
Use a time step of 1 hour; look up 100 states.
./
#define STEP 3600.0
#define MAXITR 100
/.
The NAIF IDs of the earth and moon are 399 and 301 respectively.
./
#define OBSERVER 399
#define TARGET 301
/.
Local variables
./
SpiceInt i;
SpiceDouble et;
SpiceDouble lt;
SpiceDouble state [6];
/.
Load the spk file.
./
furnsh_c ( SPK );
/.
Step through a series of epochs, looking up a state vector
at each one.
./
for ( i = 0; i < MAXITR; i++ )
{
et = ET0 + i*STEP;
spkez_c ( TARGET, et, FRAME, ABCORR,
OBSERVER, state, < );
printf( "\net = %20.10f\n\n", et );
printf( "J2000 x-position (km): %20.10f\n", state[0] );
printf( "J2000 y-position (km): %20.10f\n", state[1] );
printf( "J2000 z-position (km): %20.10f\n", state[2] );
printf( "J2000 x-velocity (km/s): %20.10f\n", state[3] );
printf( "J2000 y-velocity (km/s): %20.10f\n", state[4] );
printf( "J2000 z-velocity (km/s): %20.10f\n", state[5] );
}
return ( 0 );
}
-Restrictions
None.
-Literature_References
SPK Required Reading.
-Author_and_Institution
C.H. Acton (JPL)
W.L. Taber (JPL)
N.J. Bachman (JPL)
J.E. McLean (JPL)
H.A. Neilan (JPL)
M.J. Spencer (JPL)
I.M. Underwood (JPL)
-Version
-CSPICE Version 3.0.0, 27-DEC-2007 (NJB)
This routine was upgraded to more accurately compute
aberration-corrected velocity, and in particular, make it
more consistent with observer-target positions.
When light time corrections are used, the derivative of light
time with respect to time is now accounted for in the
computation of observer-target velocities. When the reference
frame associated with the output state is time-dependent, the
derivative of light time with respect to time is now accounted
for in the computation of the rate of change of orientation of
the reference frame.
When stellar aberration corrections are used, velocities
now reflect the rate of range of the stellar aberration
correction.
-CSPICE Version 2.0.3, 12-DEC-2004 (NJB)
Minor header error was corrected.
-CSPICE Version 2.0.2, 13-OCT-2003 (EDW)
Various minor header changes were made to improve clarity.
Added mention that 'lt' returns a value in seconds.
-CSPICE Version 2.0.1, 29-JUL-2003 (NJB) (CHA)
Various minor header changes were made to improve clarity.
-CSPICE Version 2.0.0, 28-DEC-2001 (NJB)
Updated to handle aberration corrections for transmission
of radiation. Formerly, only the reception case was
supported. The header was revised and expanded to explain
the functionality of this routine in more detail.
-CSPICE Version 1.1.0, 08-FEB-1998 (NJB)
References to C2F_CreateStr_Sig were removed; code was
cleaned up accordingly. String checks are now done using
the macro CHKFSTR.
-CSPICE Version 1.0.0, 25-OCT-1997 (NJB)
Based on SPICELIB Version 3.1.0, 09-JUL-1996 (WLT)
-Index_Entries
using body codes get target state relative to an observer
get state relative to observer corrected for aberrations
read ephemeris data
read trajectory data
-&
*/
{ /* Begin spkez_c */
/*
Participate in error tracing.
*/
chkin_c ( "spkez_c" );
/*
Check the input strings to make sure the pointers are non-null
and the string lengths are non-zero.
*/
CHKFSTR ( CHK_STANDARD, "spkez_c", ref );
CHKFSTR ( CHK_STANDARD, "spkez_c", abcorr );
/*
Call the f2c'd Fortran routine. Use explicit type casts for every
type defined by f2c.
*/
spkez_ ( ( integer * ) &targ,
( doublereal * ) &et,
( char * ) ref,
( char * ) abcorr,
( integer * ) &obs,
( doublereal * ) starg,
( doublereal * ) lt,
( ftnlen ) strlen(ref),
( ftnlen ) strlen(abcorr) );
chkout_c ( "spkez_c" );
} /* End spkez_c */
