Index Page
cspice_limb_pl02
A  B  C  D  E  F  G  H  I  J  K  L  M  N  O  P  Q  R  S  T  U  V  W  X 

Abstract
I/O
Examples
Particulars
Required Reading
Version
Index_Entries

Abstract


   Deprecated: This routine has been superseded by the CSPICE routine
   cspice_limbpt. This routine is supported for purposes of backward
   compatibility only.

   CSPICE_LIMB_PL02 returns a set of points on the limb of a specified
   target body, where the target body's surface is represented by a
   triangular plate model contained in a type 2 DSK segment.

   For important details concerning this module's function, please refer to
   the CSPICE routine limb_pl02.

I/O


   Given:

      handle      the DAS file handle of a DSK file open for read
                  access. This kernel must contain a type 2 segment that
                  provides a plate model representing the entire surface
                  of the target body.

      dladsc      the DLA descriptor of a DSK segment representing the
                  surface of a target body.

      target      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.

                  This routine assumes that a kernel variable representing
                  the target's radii is present in the kernel pool.
                  Normally the kernel variable would be defined by loading
                  a PCK file.

      et          the epoch of participation of the observer,
                  expressed as ephemeris seconds past J2000 TDB: `et' is
                  the epoch at which the observer's position is
                  computed.

                  When aberration corrections are not used, `et' is also
                  the epoch at which the position and orientation of the
                  target body are computed.

                  When aberration corrections are used, `et' is the epoch
                  at which the observer's position relative to the solar
                  system barycenter is computed; in this case the position
                  and orientation of the target body are computed at
                  et-lt, where `lt' is the one-way light time between the
                  target body's center and the observer. See the
                  description of `abcorr' below for details.

      fixfrm      the name of the reference frame relative to which the
                  output limb points are expressed. This must a
                  body-centered, body-fixed frame associated with the
                  target. The frame's axes must be compatible with the
                  triaxial ellipsoidal shape model associated with the
                  target body (normally provide via a PCK): this routine
                  assumes that the first, second, and third ellipsoid radii
                  correspond, respectively, to the x, y, and z-axes of the
                  frame designated by `fixfrm'.

                  `fixfrm' may refer to a built-in frame (documented in
                  the Frames Required Reading) or a frame defined by a
                  loaded frame kernel (FK).

                  The orientation of the frame designated by `fixfrm' is
                  evaluated at epoch of participation of the target
                  body. See the descriptions of `et' and `abcorr' for
                  details.

      abcorr      indicates the aberration correction to be applied
                  when computing the observer-target position, the
                  orientation of the target body, and the target-
                  source position vector.

                  `abcorr' may be any of the following.

                     'NONE'     Apply no correction. Compute the limb
                                points using the position of the observer
                                and target, and the orientation of the
                                target, at `et'.

                  Let `lt' represent the one-way light time between the
                  observer and the target body's center. The following
                  values of `abcorr' apply to the "reception" case in
                  which photons depart from the target body's center 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 location of the limb points at
                                the approximate time they emitted photons
                                arriving at the observer at `et' (the
                                difference between light time to the
                                target center and light time to the limb
                                points is ignored).

                                The light time correction uses an
                                iterative solution of the light time
                                equation. The solution invoked by the
                                'LT' option uses one iteration.

                                The target position as seen by the
                                observer and the rotation of the target
                                body are corrected for light time.

                     'LT+S'     Correct for one-way light time and stellar
                                aberration using a Newtonian formulation.
                                This option modifies the position obtained
                                with the 'LT' option to account for the
                                observer's velocity relative to the solar
                                system barycenter. The result is the
                                apparent limb 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. The position and
                                rotation of the target body are corrected
                                for light time.

                     'CN+S'     Converged Newtonian light time
                                and stellar aberration corrections.


      obsrvr      the name of the observing body. This is 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.

      npoints     the number of limb points to compute.

                   For values of `npoints' less-than or equal-to zero,
                   the output arguments return as zeros and empty arrays.

   the call:

      cspice_limb_pl02, handle, dladsc, target, et, fixfrm, abcorr, $
                        obsrvr, npoints, trgepc, obspos, limbpts, plateIDs

   returns:

      trgepc      the "target epoch."  `trgepc' is defined as follows:
                  letting `lt' be the one-way light time between the
                  target center and observer, `trgepc' is either the
                  epoch et-lt or `et' depending on whether the requested
                  aberration correction is, respectively, for received
                  radiation or omitted. `lt' is computed using the
                  method indicated by `abcorr'.

                  `trgepc' is expressed as seconds past J2000 TDB.

      obspos      the vector from the center of the target body at
                  epoch `trgepc' to the observer at epoch `et'. `obspos' is
                  expressed in the target body-fixed reference frame
                  `fixfrm', which is evaluated at `trgepc'.

                  `obspos' is returned to simplify various related
                  computations that would otherwise be cumbersome. For
                  example, the vector `xvec' from the observer to the
                  Ith limb point can be calculated via the expression

                     xvec = limbpts[:,i] - obspos

                  The components of `obspos' are given in units of km.

      limbpts     an array of points on the limb of the target.

                  The ith point is contained in the array elements

                      limbpts[:,i]

                  As described above, each limb point lies on a ray
                  emanating from the center of the target and passing
                  through a limb point on the target's reference
                  ellipsoid. Each limb point *on the reference ellipsoid*
                  is the point of tangency of a ray that emanates from the
                  observer. Measured in a cylindrical coordinate system
                  whose Z-axis is parallel to the observer-target vector,
                  the magnitude of the separation in longitude between the
                  limb points is

                     2*Pi / npoints

                  The limb points are expressed in the body-fixed
                  reference frame designated by `fixfrm'; the
                  orientation of the frame is evaluated at `trgepc'.
                  Units are km.

      plateIDs    an array of integer ID codes of the plates on which
                  the limb points are located. The ith plate ID
                  corresponds to the ith limb point. These ID codes can
                  be use to look up data associated with the plates, such
                  as the plates' vertices or outward normal vectors.

Examples


   Any numerical results shown for this example may differ between
   platforms as the results depend on the SPICE kernels used as input
   and the machine specific arithmetic implementation.


Particulars


   Boundaries of visible regions on an arbitrary surface are often
   complicated point sets: boundaries of mountains and craters, if
   present, may contribute to the overall set. To make the limb
   computation tractable, we simplify the problem by using a reference
   ellipsoid for guidance. We compute a set of limb points on the
   reference ellipsoid for the target body, then use those points to
   define the latitudes and longitudes of limb points on the surface
   defined by the specified triangular shape model. As such, the set
   of limb points found by this routine is just an approximation.

Required Reading


   ICY.REQ
   DSK.REQ
   PCK.REQ
   SPK.REQ
   TIME.REQ

Version


   -Icy Version 1.0.0, 15-DEC-2016, ML (JPL), EDW (JPL)

Index_Entries


   find limb on a dsk type_2 model
   find limb on a triangular plate_model



Wed Apr  5 17:58:02 2017