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

Table of contents

Procedure Abstract Required_Reading Keywords Brief_I/O Detailed_Input | Detailed_Output Parameters Exceptions Files Particulars Examples | Restrictions Literature_References Author_and_Institution Version Index_Entries

#### Procedure

       sct2e_c ( SCLK ticks to ET )

       void sct2e_c ( SpiceInt       sc,
                      SpiceDouble    sclkdp,
                      SpiceDouble  * et     )

#### Abstract

       Convert encoded spacecraft clock (`ticks') to ephemeris
       seconds past J2000 (ET).

#### Required_Reading

       CK
       SCLK
       SPK
       TIME

#### Keywords

       CONVERSION
       TIME

#### Brief_I/O

       VARIABLE  I/O  DESCRIPTION
       --------  ---  --------------------------------------------------
       sc         I   NAIF spacecraft ID code.
       sclkdp     I   SCLK, encoded as ticks since spacecraft clock
                      start.
       et         O   Ephemeris time, seconds past J2000.

#### Detailed_Input

       sc          is a NAIF integer code for a spacecraft, one of
                   whose encoded clock values is represented by
                   `sclkdp'.

       sclkdp      is an encoded spacecraft clock value. `sclkdp'
                   represents time measured from spacecraft clock
                   start: partition information IS reflected in the
                   encoded value.

#### Detailed_Output

       et          is the epoch, specified as ephemeris seconds past
                   J2000, that corresponds to `sclkdp'.

#### Parameters

       None.

#### Exceptions

       1)  If an SCLK kernel has not been loaded, does not contain all of
           the required data, or contains invalid data, an error is
           signaled by a routine in the call tree of this routine. The
           output argument `et' will not be modified. This routine assumes
           that that an SCLK kernel appropriate to the spacecraft clock
           identified by the input argument `sc' has been loaded.

       2)  If a leapseconds kernel is required for conversion between
           SCLK and ET but is not loaded, an error is signaled by a
           routine in the call tree of this routine. The output argument
           `et' will not be modified. When using SCLK kernels that map SCLK
           to a time system other than ET (also called barycentric
           dynamical time---`TDB'), it is necessary to have a leapseconds
           kernel loaded at the time this routine is called.

           The time system that an SCLK kernel maps SCLK to is indicated
           by the variable SCLK_TIME_SYSTEM_nn in the kernel, where nn
           is the negative of the NAIF integer code for the spacecraft.
           The time system used in a kernel is TDB if and only if the
           variable is assigned the value 1.

       3)  If the clock type for the spacecraft clock identified by `sc' is
           not supported by this routine, the error SPICE(NOTSUPPORTED)
           is signaled by a routine in the call tree of this routine. The
           output argument `et' will not be modified.

       4)  If the input argument `sclkdp' is invalid, an error is signaled
           by a routine in the call tree of this routine. The output
           argument `et' will not be modified.

#### Files

       None.

#### Particulars

       This routine operates on encoded SCLK values. These values
       are obtained by calling the CSPICE routine scencd_c or other
       SCLK conversion routines. The advantage of encoded SCLK, as
       opposed to character string representations of SCLK is that
       encoded SCLK values are easy to perform arithmetic operations on.
       Additionally, working with encoded SCLK reduces the overhead of
       repeated conversion of character strings to integers or double
       precision numbers.

       To convert a string representation of an SCLK value to ET, use
       the CSPICE routine scs2e_c.

       See the SCLK Required Reading for a list of the entire set of
       SCLK conversion routines.

#### Examples

       1)  Encode a Galileo SCLK string, and convert the encoded value
           to ET; use these time values to look up both GLL orbiter
           scan platform's pointing and the GLL--Earth state vector
           for an epoch specified by an SCLK string.

              During program initialization, load the leapseconds and
              SCLK kernels. We will pretend that these files are named
              "leapseconds.ker" and "gllsclk.ker".  To use this code
              fragment, you must substitute the actual names of these
              kernel files for the names used here.

                 /.
                 load leapseconds and SCLK kernels:
                 ./
                 furnsh_c ( "leapseconds.ker" );
                 furnsh_c ( "gllsclk.ker"     );

                 /.
                 The mission is Galileo, which has spacecraft ID -77.
                 Let's assume that the SCLK string is

                    1 / 1900000:00:00

                 The number 1, followed by a slash, indicates that the
                 epoch is in the first partition.

                 The next step is to encode this SCLK string, and also
                 find the corresponding ET value:
                 ./

                 scencd_c ( -77, "1/ 1900000:00:00", &sclkdp );
                 sct2e_c  ( -77,  sclkdp,            &et     );

              We'll assume that you've already loaded SPK and CK files
              containing ephemeris data for the GLL orbiter and the
              Earth, as well as scan platform pointing. Now you're
              ready to call both ckgp_c, which expects the input epoch to
              be specified by an encoded SCLK string, and spkez_c, which
              expects the epoch to be specified as an ephemeris time.

                 /.
                 Find scan platform pointing cmat and s/c--target
                 vector (first 3 components of state) at epoch.
                 We assume that CK and SPK kernels have been loaded
                 already, via cklpf_c and spklef_c respectively.

                 Use tolerance of 80 ticks for the CK look-up.
                 ./
                 scanpl = -77001;
                 earth  =    399;
                 tol    =   80.0;

                 ckgp_c  ( scanpl,  sclkdp,   tol,    refsys,
                           cmat,    &clkout,  &found         );

                 if ( !found )
                 {
                    [ Indicate to user that pointing was not
                      available ]
                 }

                 spkez_c ( earth,  et,     refsys,  corr,
                           -77,    state,  &lt           );

       2)  Convert an encoded Voyager 2 SCLK value to UTC, using calendar
           format, with 3 digits of precision.

              Again, your initialization code must load the leapseconds
              and SCLK kernels:

                 /.
                 load leapseconds and SCLK kernels:
                 ./
                 furnsh_c ( "leapseconds.ker" );
                 furnsh_c ( "vgr2sclk.ker"    );

              To find the UTC value corresponding to the encoded
              Voyager 2 SCLK value sclkdp, you can use the code fragment

                 sct2e_c  ( -32,  sclkdp,     &et          );
                 et2utc_c (  et,  "c",    3,  UTCLEN,  utc );

              where UTCLEN is a constant indicating the available
              room in the string utc. A value of 25 characters suffices.

#### Restrictions

       1)  An SCLK kernel appropriate to the spacecraft clock identified
           by `sc' must be loaded at the time this routine is called.

       2)  If the SCLK kernel used with this routine does not map SCLK
           directly to barycentric dynamical time, a leapseconds kernel
           must be loaded at the time this routine is called.

#### Literature_References

       None.

#### Author_and_Institution

       N.J. Bachman        (JPL)
       J. Diaz del Rio     (ODC Space)
       E.D. Wright         (JPL)

#### Version

       -CSPICE Version 1.0.2, 05-AUG-2021 (JDR)

           Edited the header to comply with NAIF standard. Moved CK and SPK
           required readings from -Literature_References to -Required_Reading
           section.

       -CSPICE Version 1.0.1, 14-AUG-2006 (EDW)

           Replace mention of ldpool_c with furnsh_c.

       -CSPICE Version 1.0.0, 08-FEB-1998 (NJB)

           Based on SPICELIB Version 1.0.2, 10-APR-1992 (NJB) (WLT)

#### Index_Entries

       spacecraft_clock ticks to ephemeris time

#### Link to routine sct2e_c source file sct2e_c.c

    Fri Dec 31 18:41:12 2021