Procedure

     EXPOOL ( Confirm the existence of a pooled kernel variable )

     ENTRY EXPOOL ( NAME, FOUND )

Abstract

     Confirm the existence of a numeric kernel variable in the kernel
     pool.

Required_Reading

     KERNEL

Keywords

     CONSTANTS
     FILES

Declarations

    CHARACTER*(*)         NAME
    LOGICAL               FOUND

Brief_I/O

     VARIABLE  I/O  DESCRIPTION
     --------  ---  --------------------------------------------------
     NAME       I   Name of a numeric kernel variable.
     FOUND      O   .TRUE. when the variable is in the pool.

Detailed_Input

     NAME     is the name of the numeric kernel variable whose
              existence in the kernel pool is to be checked.

Detailed_Output

     FOUND    is .TRUE. whenever the specified variable is included
              in the pool.

Parameters

     None.

Exceptions

     None.

Files

     None.

Particulars

     This routine determines whether or not a numeric kernel pool
     variable exists. It does not detect the existence of
     string valued kernel pool variables.

     A better routine for determining the existence of numeric kernel
     pool variables is the routine DTPOOL which determines the
     existence, size and type of kernel pool variables.

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.

     1) The following code example demonstrates how to use EXPOOL
        to confirm the existence of numeric kernel pool variables.
        In the example, we will look for different variables;
        some of them numeric, some string valued and some not
        present in the kernel pool.

        Use the kernel shown below; an IK defining two keywords
        used to provide data for an instrument with NAIF ID -999001.


           KPL/IK

           File name: expool_ex1.ti

           The keyword below define the three frequencies used by a
           hypothetical instrument (NAIF ID -999001). They correspond
           to three filters: red, green and blue. Frequencies are
           given in micrometers.

           \begindata

              INS-999001_FREQ_RGB   = (  0.65,  0.55, 0.475 )
              INS-999001_FREQ_UNITS = ( 'MICROMETERS'       )

           \begintext


           End of IK


        Example code begins here.


              PROGRAM EXPOOL_EX1
              IMPLICIT NONE

        C
        C     Local parameters.
        C
              CHARACTER*(*)         IKNAME
              PARAMETER           ( IKNAME = 'expool_ex1.ti' )

              INTEGER               KPVNLN
              PARAMETER           ( KPVNLN = 32 )

              INTEGER               NKPVNM
              PARAMETER           ( NKPVNM = 3  )

        C
        C     Local variables.
        C
              CHARACTER*(KPVNLN)    KEYWRD ( NKPVNM )

              INTEGER               I

              LOGICAL               FOUND

        C
        C     Define the variable names
        C
              DATA                  KEYWRD   /
             .                             'INS-999001_FREQ_RGB',
             .                             'NOT_IN_THE_POOL',
             .                             'INS-999001_FREQ_UNITS' /

        C
        C     Load the instrument kernel.
        C
              CALL FURNSH ( IKNAME )

              DO I = 1, NKPVNM

        C
        C        Check if the variable is numeric and present
        C        in the kernel pool.
        C
                 CALL EXPOOL ( KEYWRD(I), FOUND )

                 WRITE(*,*) 'Variable name: ', KEYWRD(I)

                 IF ( FOUND ) THEN

                    WRITE(*,*) '   It is numeric and exists in the '
             .              // 'kernel pool.'

                 ELSE

                    WRITE(*,*) '   Either it is not numeric or it is '
             .              // 'not in the kernel pool.'

                 END IF

              END DO

              END


        When this program was executed on a Mac/Intel/gfortran/64-bit
        platform, the output was:


         Variable name: INS-999001_FREQ_RGB
            It is numeric and exists in the kernel pool.
         Variable name: NOT_IN_THE_POOL
            Either it is not numeric or it is not in the kernel pool.
         Variable name: INS-999001_FREQ_UNITS
            Either it is not numeric or it is not in the kernel pool.

Restrictions

     None.

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)

        Edited the header to comply with NAIF standard. Added complete
        code example.

        Updated the header to reflect that only numeric variables
        present in the kernel pool will cause the routine to return
        .TRUE.

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

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

        Fixed typos.

    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.

    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)