Procedure

     RTPOOL ( Return the value of a pooled kernel variable )

     ENTRY RTPOOL ( NAME, N, VALUES, FOUND )

Abstract

     Return the value of a kernel variable from the kernel pool.

     This routine is maintained only for backward compatibility.
     It should be regarded as obsolete. Use one of the entry points
     GDPOOL, GIPOOL or GCPOOL in its place.

Required_Reading

     KERNEL

Keywords

     CONSTANTS
     FILES

Declarations

    CHARACTER*(*)         NAME
    INTEGER               N
    DOUBLE PRECISION      VALUES   ( * )
    LOGICAL               FOUND

Brief_I/O

     VARIABLE  I/O  DESCRIPTION
     --------  ---  --------------------------------------------------
     NAME       I   Name of the variable whose value is to be returned.
     N          O   Number of values associated with NAME.
     VALUES     O   Values associated with NAME.
     FOUND      O   .TRUE. if variable is in pool.

Detailed_Input

     NAME     is the name of the variable whose values are to be
              returned. If the variable is not in the pool, FOUND
              will be .FALSE.

Detailed_Output

     N        is the number of values associated with NAME.
              If NAME is not in the pool, no value is given to
              N.

     VALUES   is the array of values associated with NAME.
              If NAME is not in the pool, no values are given to
              the elements of VALUES.

     FOUND    is .TRUE. if the variable is in the pool, .FALSE. if it
              is not.

Parameters

     None.

Exceptions

     1)  If the output argument VALUES is not large enough to hold all
         of the values of the kernel variable designated by NAME,
         then memory will be corrupted. RTPOOL cannot detect this
         error.

Files

     None.

Particulars

     None.

Examples

     The following code fragment demonstrates how the data from
     several kernel files can be loaded into a kernel pool. After the
     pool is loaded, the values in the pool are written to a kernel
     file.


     C
     C     Store in an array the names of the kernel files whose
     C     values will be loaded into the kernel pool.
     C
           FNAME (1) = 'AXES.KER'
           FNAME (2) = 'GM.KER'
           FNAME (3) = 'LEAP_SECONDS.KER'

     C
     C     Clear the kernel pool. (This is optional.)
     C
           CALL CLPOOL

     C
     C     Load the variables from the three kernel files into the
     C     the kernel pool.
     C
           DO I = 1, 3
             CALL LDPOOL ( FNAME (I) )
           END DO

     C
     C     We can examine the values associated with any variable
     C     in the kernel pool using RTPOOL.
     C
           CALL RTPOOL ( VARIABLE, NUMVAL, VALUES, FOUND )

     C
     C     Open the new text file 'NEWKERNEL.KER'.
     C
           CALL TXTOPN ( 'NEWKERNEL.KER', UNIT )

     C
     C     Write the values in the kernel pool to the file.
     C
           CALL WRPOOL ( UNIT )

Restrictions

     See $Exceptions section.

Literature_References

     None.

Author_and_Institution

     N.J. Bachman       (JPL)
     J. Diaz del Rio    (ODC Space)
     W.L. Taber         (JPL)
     I.M. Underwood     (JPL)

Version

    SPICELIB Version 8.1.1, 17-AUG-2021 (JDR) (NJB)

        Edited the header to comply with NAIF standard.

    SPICELIB Version 8.1.0, 19-MAR-2009 (NJB)

        ZZPINI call was updated for compatibility
        with new watcher system implementation.

        Updated code example to use TXTOPN.

    SPICELIB Version 8.0.1, 22-DEC-2004 (NJB)

        Corrected an in-line comment relating to finding the
        head node of the conflict resolution list for NAME.

    SPICELIB Version 8.0.0, 04-JUN-1999 (WLT)

        Added the entry points PCPOOL, PDPOOL and PIPOOL to allow
        direct insertion of data into the kernel pool without having
        to read an external file.

        Added the interface LMPOOL that allows SPICE
        programs to load text kernels directly from memory
        instead of requiring a text file.

        Added the entry point SZPOOL to return kernel pool definition
        parameters.

        Added the entry point DVPOOL to allow the removal of a variable
        from the kernel pool.

        Added the entry point GNPOOL to allow users to determine
        variables that are present in the kernel pool

    SPICELIB Version 7.0.0, 20-SEP-1995 (WLT)

        The implementation of the kernel pool was completely redone
        to improve performance in loading and fetching data. In
        addition the pool was upgraded so that variables may be
        either string or numeric valued.

        The entry points GCPOOL, GDPOOL, GIPOOL and DTPOOL were added
        to the routine.

        The entry point RTPOOL should now be regarded as obsolete
        and is maintained solely for backward compatibility with
        existing routines that make use of it.

    SPICELIB Version 4.0.0, 12-JUN-1990 (IMU)

        All entry points except POOL and CLPOOL now initialize the
        pool if it has not been done yet.

    SPICELIB Version 1.0.0, 08-JAN-1989 (IMU)