/* gftfov.f -- translated by f2c (version 19980913).
   You must link the resulting object file with the libraries:
	-lf2c -lm   (in that order)
*/

#include "f2c.h"

/* Table of constant values */

static doublereal c_b15 = 1e-6;
static logical c_false = FALSE_;

/* $Procedure      GFTFOV ( GF, is target in FOV? ) */
/* Subroutine */ int gftfov_(char *inst, char *target, char *tshape, char *
	tframe, char *abcorr, char *obsrvr, doublereal *step, doublereal *
	cnfine, doublereal *result, ftnlen inst_len, ftnlen target_len, 
	ftnlen tshape_len, ftnlen tframe_len, ftnlen abcorr_len, ftnlen 
	obsrvr_len)
{
    /* Initialized data */

    static doublereal raydir[3] = { 0.,0.,0. };

    /* System generated locals */
    integer i__1;

    /* Local variables */
    extern /* Subroutine */ int chkin_(char *, ftnlen), errdp_(char *, 
	    doublereal *, ftnlen);
    extern integer sized_(doublereal *);
    extern logical eqstr_(char *, char *, ftnlen, ftnlen), gfbail_();
    extern /* Subroutine */ int gfrefn_(), gfrepf_(), gfrepi_();
    extern /* Subroutine */ int gffove_(char *, char *, doublereal *, char *, 
	    char *, char *, char *, doublereal *, U_fp, U_fp, logical *, U_fp,
	     U_fp, U_fp, logical *, L_fp, doublereal *, doublereal *, ftnlen, 
	    ftnlen, ftnlen, ftnlen, ftnlen, ftnlen);
    extern /* Subroutine */ int gfrepu_(), gfstep_();
    extern /* Subroutine */ int setmsg_(char *, ftnlen), sigerr_(char *, 
	    ftnlen), chkout_(char *, ftnlen);
    extern logical return_(void);
    extern /* Subroutine */ int errint_(char *, integer *, ftnlen), gfsstp_(
	    doublereal *);

/* $ Abstract */

/*     Determine time intervals when a specified ephemeris object */
/*     intersects the space bounded by the field-of-view (FOV) of a */
/*     specified instrument. */

/* $ 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 */

/*     CK */
/*     FRAMES */
/*     GF */
/*     KERNEL */
/*     NAIF_IDS */
/*     PCK */
/*     SPK */
/*     TIME */
/*     WINDOWS */

/* $ Keywords */

/*     EVENT */
/*     FOV */
/*     GEOMETRY */
/*     INSTRUMENT */
/*     SEARCH */
/*     WINDOW */

/* $ Declarations */
/* $ Abstract */

/*     This file contains public, global parameter declarations */
/*     for the SPICELIB Geometry Finder (GF) subsystem. */

/* $ 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 */

/*     GF */

/* $ Keywords */

/*     GEOMETRY */
/*     ROOT */

/* $ Restrictions */

/*     None. */

/* $ Author_and_Institution */

/*     N.J. Bachman      (JPL) */
/*     L.E. Elson        (JPL) */
/*     E.D. Wright       (JPL) */

/* $ Literature_References */

/*     None. */

/* $ Version */

/* -    SPICELIB Version 1.0.0, 21-FEB-2009 (NJB) (LSE) (EDW) */

/* -& */

/*     Root finding parameters: */

/*     CNVTOL is the default convergence tolerance used by the */
/*     high-level GF search API routines. This tolerance is */
/*     used to terminate searches for binary state transitions: */
/*     when the time at which a transition occurs is bracketed */
/*     by two times that differ by no more than CNVTOL, the */
/*     transition time is considered to have been found. */

/*     Units are TDB seconds. */


/*     NWMAX is the maximum number of windows allowed for user-defined */
/*     workspace array. */

/*        DOUBLE PRECISION      WORK   ( LBCELL : MW, NWMAX ) */

/*     Currently no more than twelve windows are required; the three */
/*     extra windows are spares. */

/*     Callers of GFEVNT can include this file and use the parameter */
/*     NWMAX to declare the second dimension of the workspace array */
/*     if necessary. */


/*     Callers of GFIDST should declare their workspace window */
/*     count using NWDIST. */


/*     Callers of GFSEP should declare their workspace window */
/*     count using NWSEP. */


/*     ADDWIN is a parameter used to expand each interval of the search */
/*     (confinement) window by a small amount at both ends in order to */
/*     accommodate searches using equality constraints. The loaded */
/*     kernel files must accommodate these expanded time intervals. */


/*     FRMNLN is a string length for frame names. */


/*     NVRMAX is the maximum number of vertices if FOV type is "POLYGON" */


/*     FOVTLN -- maximum length for FOV string. */


/*     Specify the character strings that are allowed in the */
/*     specification of field of view shapes. */


/*     Character strings that are allowed in the */
/*     specification of occultation types: */


/*     Occultation target shape specifications: */


/*     Specify the number of supported occultation types and occultation */
/*     type string length: */


/*     Instrument field-of-view (FOV) parameters */

/*     Maximum number of FOV boundary vectors: */


/*     FOV shape parameters: */

/*        circle */
/*        ellipse */
/*        polygon */
/*        rectangle */


/*     End of file gf.inc. */

/* $ Brief_I/O */

/*     VARIABLE  I/O  DESCRIPTION */
/*     --------  ---  -------------------------------------------------- */
/*     MARGIN     P   Minimum complement of FOV cone angle. */
/*     LBCELL     P   SPICE Cell lower bound. */
/*     CNVTOL     P   Convergence tolerance. */
/*     MAXVRT     P   Maximum number of FOV boundary vertices. */
/*     INST       I   Name of the instrument. */
/*     TARGET     I   Name of the target body. */
/*     TSHAPE     I   Type of shape model used for target body. */
/*     TFRAME     I   Body-fixed, body-centered frame for target body. */
/*     ABCORR     I   Aberration correction flag. */
/*     OBSRVR     I   Name of the observing body. */
/*     STEP       I   Step size in seconds for finding FOV events. */
/*     CNFINE     I   SPICE window to which the search is restricted. */
/*     RESULT     O   SPICE window containing results. */


/* $ Detailed_Input */

/*     INST       indicates the name of an instrument, such as a */
/*                spacecraft-mounted framing camera, the field of view */
/*                (FOV) of which is to be used for a target intersection */
/*                search: times when the specified target intersects the */
/*                region of space corresponding to the FOV are sought. */

/*                The position of the instrument designated by INST is */
/*                considered to coincide with that of the ephemeris */
/*                object designated by the input argument OBSRVR (see */
/*                description below). */

/*                INST must have a corresponding NAIF ID and a frame */
/*                defined, as is normally done in a frame kernel. It */
/*                must also have an associated reference frame and a FOV */
/*                shape, boresight and boundary vertices (or reference */
/*                vector and reference angles) defined, as is usually */
/*                done in an instrument kernel. */

/*                See the header of the SPICELIB routine GETFOV for a */
/*                description of the required parameters associated with */
/*                an instrument. */


/*     TARGET     is the name of the target body, the appearances of */
/*                which in the specified instrument's field of view are */
/*                sought. The body must be an ephemeris object. */

/*                Optionally, you may supply the integer NAIF ID code */
/*                for the body as a string. For example both 'MOON' and */
/*                '301' are legitimate strings that designate the Moon. */

/*                Case and leading or trailing blanks are not */
/*                significant in the string TARGET. */


/*     TSHAPE     is a string indicating the geometric model used to */
/*                represent the shape of the target body. The supported */
/*                options are: */

/*                   'ELLIPSOID'     Use a triaxial ellipsoid model, */
/*                                   with radius values provided via the */
/*                                   kernel pool. A kernel variable */
/*                                   having a name of the form */

/*                                      'BODYnnn_RADII' */

/*                                   where nnn represents the NAIF */
/*                                   integer code associated with the */
/*                                   body, must be present in the kernel */
/*                                   pool. This variable must be */
/*                                   associated with three numeric */
/*                                   values giving the lengths of the */
/*                                   ellipsoid's X, Y, and Z semi-axes. */

/*                   'POINT'         Treat the body as a single point. */

/*                Case and leading or trailing blanks are not */
/*                significant in the string TSHAPE. */


/*     TFRAME     is the name of the body-fixed, body-centered reference */
/*                frame associated with the target body. Examples of */
/*                such names are 'IAU_SATURN' (for Saturn) and 'ITRF93' */
/*                (for the Earth). */

/*                If the target body is modeled as a point, TFRAME */
/*                is ignored and should be left blank. */

/*                Case and leading or trailing blanks bracketing a */
/*                non-blank frame name are not significant in the string */
/*                TFRAME. */


/*     ABCORR     indicates the aberration corrections to be applied */
/*                when computing the target's position and orientation. */

/*                For remote sensing applications, where the apparent */
/*                position and orientation of the target seen by the */
/*                observer are desired, normally either of the */
/*                corrections */

/*                   'LT+S' */
/*                   'CN+S' */

/*                should be used. These and the other supported options */
/*                are described below. */

/*                Supported aberration correction options for */
/*                observation (the case where radiation is received by */
/*                observer at ET) are: */

/*                   'NONE'         No correction. */
/*                   'LT'           Light time only */
/*                   'LT+S'         Light time and stellar aberration. */
/*                   'CN'           Converged Newtonian (CN) light time. */
/*                   'CN+S'         CN light time and stellar aberration. */

/*                Supported aberration correction options for */
/*                transmission (the case where radiation is emitted from */
/*                observer at ET) are: */

/*                   'XLT'          Light time only. */
/*                   'XLT+S'        Light time and stellar aberration. */
/*                   'XCN'          Converged Newtonian (CN) light time. */
/*                   'XCN+S'        CN light time and stellar aberration. */

/*                For detailed information, see the GF Required Reading, */
/*                gf.req. */

/*                Case, leading and trailing blanks are not significant */
/*                in the string ABCORR. */


/*     OBSRVR     is the name of the body from which the target is */
/*                observed. The instrument designated by INST is treated */
/*                as if it were co-located with the observer. */

/*                Optionally, you may supply the integer NAIF ID code */
/*                for the body as a string. */

/*                Case and leading or trailing blanks are not */
/*                significant in the string OBSRVR. */


/*     STEP       is the step size to be used in the search. STEP must */
/*                be shorter than any interval, within the confinement */
/*                window, over which the specified condition is met. In */
/*                other words, STEP must be shorter than the shortest */
/*                visibility event that the user wishes to detect. STEP */
/*                also must be shorter than the minimum duration */
/*                separating any two visibility events. However, STEP */
/*                must not be *too* short, or the search will take an */
/*                unreasonable amount of time. */

/*                The choice of STEP affects the completeness but not */
/*                the precision of solutions found by this routine; the */
/*                precision is controlled by the convergence tolerance. */
/*                See the discussion of the parameter CNVTOL for */
/*                details. */

/*                STEP has units of seconds. */


/*     CNFINE     is a SPICE window that confines the time period over */
/*                which the specified search is conducted. CNFINE may */
/*                consist of a single interval or a collection of */
/*                intervals. */

/*                The endpoints of the time intervals comprising CNFINE */
/*                are interpreted as seconds past J2000 TDB. */

/*                See the Examples section below for a code example */
/*                that shows how to create a confinement window. */

/*                CNFINE must be initialized by the caller via the */
/*                SPICELIB routine SSIZED. */

/* $ Detailed_Output */

/*     RESULT     is a SPICE window representing the set of time */
/*                intervals, within the confinement period, when the */
/*                target body is visible; that is, when the target body */
/*                intersects the space bounded by the specified */
/*                instrument's field of view. */

/*                The endpoints of the time intervals comprising RESULT */
/*                are interpreted as seconds past J2000 TDB. */

/*                If RESULT is non-empty on input, its contents */
/*                will be discarded before GFTFOV conducts its */
/*                search. */

/* $ Parameters */

/*     LBCELL     is the lower bound for SPICE cell arrays. */

/*     CNVTOL     is the convergence tolerance used for finding */
/*                endpoints of the intervals comprising the result */
/*                window. CNVTOL is used to determine when binary */
/*                searches for roots should terminate: when a root is */
/*                bracketed within an interval of length CNVTOL, the */
/*                root is considered to have been found. */

/*                The accuracy, as opposed to precision, of roots found */
/*                by this routine depends on the accuracy of the input */
/*                data. In most cases, the accuracy of solutions will be */
/*                inferior to their precision. */

/*     MAXVRT     is the maximum number of vertices that may be used */
/*                to define the boundary of the specified instrument's */
/*                field of view. */

/*     MARGIN     is a small positive number used to constrain the */
/*                orientation of the boundary vectors of polygonal */
/*                FOVs. Such FOVs must satisfy the following constraints: */

/*                   1)  The boundary vectors must be contained within */
/*                       a right circular cone of angular radius less */
/*                       than than (pi/2) - MARGIN radians; in other */
/*                       words, there must be a vector A such that all */
/*                       boundary vectors have angular separation from */
/*                       A of less than (pi/2)-MARGIN radians. */

/*                   2)  There must be a pair of boundary vectors U, V */
/*                       such that all other boundary vectors lie in */
/*                       the same half space bounded by the plane */
/*                       containing U and V. Furthermore, all other */
/*                       boundary vectors must have orthogonal */
/*                       projections onto a specific plane normal to */
/*                       this plane (the normal plane contains the angle */
/*                       bisector defined by U and V) such that the */
/*                       projections have angular separation of at least */
/*                       2*MARGIN radians from the plane spanned by U */
/*                       and V. */

/*                 MARGIN is currently set to 1.D-12. */


/*     See INCLUDE file gf.inc for declarations and descriptions of */
/*     parameters used throughout the GF system. */

/* $ Exceptions */

/*     1)  In order for this routine to produce correct results, */
/*         the step size must be appropriate for the problem at hand. */
/*         Step sizes that are too large may cause this routine to miss */
/*         roots; step sizes that are too small may cause this routine */
/*         to run unacceptably slowly and in some cases, find spurious */
/*         roots. */

/*         This routine does not diagnose invalid step sizes, except */
/*         that if the step size is non-positive, the error */
/*         SPICE(INVALIDSTEPSIZE) will be signaled. */

/*     2)  Due to numerical errors, in particular, */

/*            - Truncation error in time values */
/*            - Finite tolerance value */
/*            - Errors in computed geometric quantities */

/*         it is *normal* for the condition of interest to not always be */
/*         satisfied near the endpoints of the intervals comprising the */
/*         result window. */

/*         The result window may need to be contracted slightly by the */
/*         caller to achieve desired results. The SPICE window routine */
/*         WNCOND can be used to contract the result window. */

/*     3)  If the name of either the target or observer cannot be */
/*         translated to a NAIF ID code, the error will be diagnosed by */
/*         a routine in the call tree of this routine. */

/*     4)  If the specified aberration correction is an unrecognized */
/*         value, the error will be diagnosed and signaled by a routine */
/*         in the call tree of this routine. */

/*     5)  If the radii of a target body modeled as an ellipsoid cannot */
/*         be determined by searching the kernel pool for a kernel */
/*         variable having a name of the form */

/*            'BODYnnn_RADII' */

/*         where nnn represents the NAIF integer code associated with */
/*         the body, the error will be diagnosed by a routine in the */
/*         call tree of this routine. */

/*     6)  If the target body coincides with the observer body OBSRVR, */
/*         the error will be diagnosed by a routine in the call tree of */
/*         this routine. */

/*     7)  If the body model specifier TSHAPE is invalid, the error will */
/*         be diagnosed either here or by a routine in the call tree of */
/*         this routine. */

/*     8)  If a target body-fixed reference frame associated with a */
/*         non-point target is not recognized, the error will be */
/*         diagnosed by a routine in the call tree of this routine. */

/*     9)  If a target body-fixed reference frame is not centered at */
/*         the corresponding target body,  the error will be */
/*         diagnosed by a routine in the call tree of this routine. */

/*     10) If the instrument name INST does not have corresponding NAIF */
/*         ID code, the error will be diagnosed by a routine in the call */
/*         tree of this routine. */

/*     11) If the FOV parameters of the instrument are not present in */
/*         the kernel pool, the error will be be diagnosed by routines */
/*         in the call tree of this routine. */

/*     12) If the FOV boundary has more than MAXVRT vertices, the error */
/*         will be be diagnosed by routines in the call tree of this */
/*         routine. */

/*     13) If the instrument FOV is polygonal, and this routine cannot */
/*         find a ray R emanating from the FOV vertex such that maximum */
/*         angular separation of R and any FOV boundary vector is within */
/*         the limit (pi/2)-MARGIN radians, the error will be diagnosed */
/*         by a routine in the call tree of this routine. If the FOV */
/*         is any other shape, the same error check will be applied with */
/*         the instrument boresight vector serving the role of R. */

/*     14) If the loaded kernels provide insufficient data to compute a */
/*         requested state vector, the error will be diagnosed by a */
/*         routine in the call tree of this routine. */

/*     15) 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. */

/*     16) If the output SPICE window RESULT has insufficient capacity */
/*         to contain the number of intervals on which the specified */
/*         visibility condition is met, the error will be diagnosed */
/*         by a routine in the call tree of this routine. If the result */
/*         window has size less than 2, the error SPICE(WINDOWTOOSMALL) */
/*         will be signaled by this routine. */

/* $ Files */

/*     Appropriate SPICE kernels must be loaded by the calling program */
/*     before this routine is called. */

/*     The following data are required: */

/*        - SPK data:  ephemeris data for target and observer that */
/*          describes the ephemeris of these objects for the period */
/*          defined by the confinement window, 'CNFINE' 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. */

/*        - 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 definitions of frames not already */
/*          built-in to SPICE are supplied by loading a frame kernel. */

/*          Data defining the reference frame associated with the */
/*          instrument designated by INST must be available in the */
/*          kernel pool. Additionally the name INST must be associated */
/*          with an ID code. Normally these data are  made available by */
/*          loading a frame kernel via FURNSH. */

/*        - IK data: the kernel pool must contain data such that */
/*          the SPICELIB routine GETFOV may be called to obtain */
/*          parameters for INST. Normally such data are provided by */
/*          an IK via FURNSH. */

/*     The following data may be required: */

/*        - PCK data: bodies modeled as triaxial ellipsoids must have */
/*          orientation data provided by variables in the kernel pool. */
/*          Typically these data are made available by loading a text */
/*          PCK file via FURNSH. */

/*          Bodies modeled as triaxial ellipsoids must have semi-axis */
/*          lengths provided by variables in the kernel pool. Typically */
/*          these data are made available by loading a text PCK file via */
/*          FURNSH. */

/*        - CK data: if the instrument frame is fixed to a spacecraft, */
/*          at least one CK file will be needed to permit transformation */
/*          of vectors between that frame and both J2000 and the target */
/*          body-fixed frame. */

/*        - SCLK data:  if a CK file is needed, an associated SCLK */
/*          kernel is required to enable conversion between encoded SCLK */
/*          (used to time-tag CK data) and barycentric dynamical time */
/*          (TDB). */

/*     Kernel data are normally loaded once per program run, NOT every */
/*     time this routine is called. */

/* $ Particulars */

/*     This routine determines a set of one or more time intervals */
/*     within the confinement window when any portion of a specified */
/*     target body appears within the field of view of a specified */
/*     instrument. We'll use the term "visibility event" to designate */
/*     such an appearance. The set of time intervals resulting from the */
/*     search is returned as a SPICE window. */

/*     This routine provides a simpler, but less flexible, interface */
/*     than does the SPICELIB routine GFFOVE for conducting searches for */
/*     visibility events. Applications that require support for progress */
/*     reporting, interrupt handling, non-default step or refinement */
/*     functions, or non-default convergence tolerance should call */
/*     GFFOVE rather than this routine. */

/*     To treat the target as a ray rather than as an ephemeris object, */
/*     use either the higher-level SPICELIB routine GFRFOV or GFFOVE. */
/*     Those routines may be used to search for times when distant */
/*     target objects such as stars are visible in an instrument FOV, as */
/*     long the direction from the observer to the target can be modeled */
/*     as a ray. */

/*     Below we discuss in greater detail aspects of this routine's */
/*     solution process that are relevant to correct and efficient use */
/*     of this routine in user applications. */


/*     The Search Process */
/*     ================== */

/*     The search for visibility events is treated as a search for state */
/*     transitions: times are sought when the state of the target body */
/*     changes from "not visible" to "visible" or vice versa. */

/*     Step Size */
/*     ========= */

/*     Each interval of the confinement window is searched as follows: */
/*     first, the input step size is used to determine the time */
/*     separation at which the visibility state will be sampled. */
/*     Starting at the left endpoint of an interval, samples will be */
/*     taken at each step. If a state change is detected, a root has */
/*     been bracketed; at that point, the "root"--the time at which the */
/*     state change occurs---is found by a refinement process, for */
/*     example, via binary search. */

/*     Note that the optimal choice of step size depends on the lengths */
/*     of the intervals over which the visibility state is constant: */
/*     the step size should be shorter than the shortest visibility event */
/*     duration and the shortest period between visibility events, within */
/*     the confinement window. */

/*     Having some knowledge of the relative geometry of the target and */
/*     observer can be a valuable aid in picking a reasonable step size. */
/*     In general, the user can compensate for lack of such knowledge by */
/*     picking a very short step size; the cost is increased computation */
/*     time. */

/*     Note that the step size is not related to the precision with which */
/*     the endpoints of the intervals of the result window are computed. */
/*     That precision level is controlled by the convergence tolerance. */


/*     Convergence Tolerance */
/*     ===================== */

/*     Once a root has been bracketed, a refinement process is used to */
/*     narrow down the time interval within which the root must lie. */
/*     This refinement process terminates when the location of the root */
/*     has been determined to within an error margin called the */
/*     "convergence tolerance." The convergence tolerance used by this */
/*     routine is set via the parameter CNVTOL. */

/*     The value of CNVTOL is set to a "tight" value so that the */
/*     tolerance doesn't become the limiting factor in the accuracy of */
/*     solutions found by this routine. In general the accuracy of input */
/*     data will be the limiting factor. */

/*     To use a different tolerance value, a lower-level GF routine such */
/*     as GFFOVE  must be called. Making the tolerance tighter than */
/*     CNVTOL is unlikely to be useful, since the results are unlikely */
/*     to be more accurate. Making the tolerance looser will speed up */
/*     searches somewhat, since a few convergence steps will be omitted. */
/*     However, in most cases, the step size is likely to have a much */
/*     greater effect on processing time than would the convergence */
/*     tolerance. */


/*     The Confinement Window */
/*     ====================== */

/*     The simplest use of the confinement window is to specify a time */
/*     interval within which a solution is sought. However, the */
/*     confinement window can, in some cases, be used to make searches */
/*     more efficient. Sometimes it's possible to do an efficient search */
/*     to reduce the size of the time period over which a relatively */
/*     slow search of interest must be performed. For an example, see */
/*     the program CASCADE in the GF Example Programs chapter of the GF */
/*     Required Reading, gf.req. */

/* $ Examples */

/*     The numerical results shown for these examples 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) Search for times when Saturn's satellite Phoebe is within */
/*        the FOV of the Cassini narrow angle camera (CASSINI_ISS_NAC). */
/*        To simplify the problem, restrict the search to a short time */
/*        period where continuous Cassini bus attitude data are */
/*        available. */

/*        Use a step size of 10 seconds to reduce chances of missing */
/*        short visibility events. */

/*        Use the meta-kernel shown below to load the required SPICE */
/*        kernels. */


/*           KPL/MK */

/*           File name: gftfov_ex1.tm */

/*           This meta-kernel is intended to support operation of SPICE */
/*           example programs. The kernels shown here should not be */
/*           assumed to contain adequate or correct versions of data */
/*           required by SPICE-based user applications. */

/*           In order for an application to use this meta-kernel, the */
/*           kernels referenced here must be present in the user's */
/*           current working directory. */

/*           The names and contents of the kernels referenced */
/*           by this meta-kernel are as follows: */

/*              File name                     Contents */
/*              ---------                     -------- */
/*              naif0009.tls                  Leapseconds */
/*              cpck05Mar2004.tpc             Satellite orientation and */
/*                                            radii */
/*              981005_PLTEPH-DE405S.bsp      Planetary ephemeris */
/*              020514_SE_SAT105.bsp          Satellite ephemeris */
/*              030201AP_SK_SM546_T45.bsp     Spacecraft ephemeris */
/*              cas_v37.tf                    Cassini FK */
/*              04135_04171pc_psiv2.bc        Cassini bus CK */
/*              cas00084.tsc                  Cassini SCLK kernel */
/*              cas_iss_v09.ti                Cassini IK */


/*           \begindata */

/*              KERNELS_TO_LOAD = ( 'naif0009.tls', */
/*                                  'cpck05Mar2004.tpc', */
/*                                  '981005_PLTEPH-DE405S.bsp', */
/*                                  '020514_SE_SAT105.bsp', */
/*                                  '030201AP_SK_SM546_T45.bsp', */
/*                                  'cas_v37.tf', */
/*                                  '04135_04171pc_psiv2.bc', */
/*                                  'cas00084.tsc', */
/*                                  'cas_iss_v09.ti'            ) */
/*           \begintext */



/*        Example code begins here. */


/*           PROGRAM EX1 */
/*           IMPLICIT NONE */
/*     C */
/*     C     SPICELIB functions */
/*     C */
/*           INTEGER               WNCARD */

/*     C */
/*     C     Local parameters */
/*     C */
/*           CHARACTER*(*)         META */
/*           PARAMETER           ( META   = 'gftfov_ex1.tm' ) */

/*           CHARACTER*(*)         TIMFMT */
/*           PARAMETER           ( TIMFMT = */
/*          .      'YYYY-MON-DD HR:MN:SC.######::TDB (TDB)' ) */

/*           INTEGER               LBCELL */
/*           PARAMETER           ( LBCELL = -5 ) */

/*           INTEGER               MAXWIN */
/*           PARAMETER           ( MAXWIN = 10000 ) */

/*           INTEGER               CORLEN */
/*           PARAMETER           ( CORLEN = 10 ) */

/*           INTEGER               BDNMLN */
/*           PARAMETER           ( BDNMLN = 36 ) */

/*           INTEGER               FRNMLN */
/*           PARAMETER           ( FRNMLN = 32 ) */

/*           INTEGER               SHPLEN */
/*           PARAMETER           ( SHPLEN = 25 ) */

/*           INTEGER               TIMLEN */
/*           PARAMETER           ( TIMLEN = 35 ) */

/*           INTEGER               LNSIZE */
/*           PARAMETER           ( LNSIZE = 80 ) */

/*     C */
/*     C     Local variables */
/*     C */
/*           CHARACTER*(CORLEN)    ABCORR */
/*           CHARACTER*(BDNMLN)    INST */
/*           CHARACTER*(LNSIZE)    LINE */
/*           CHARACTER*(BDNMLN)    OBSRVR */
/*           CHARACTER*(BDNMLN)    TARGET */
/*           CHARACTER*(FRNMLN)    TFRAME */
/*           CHARACTER*(TIMLEN)    TIMSTR ( 2 ) */
/*           CHARACTER*(SHPLEN)    TSHAPE */

/*           DOUBLE PRECISION      CNFINE ( LBCELL : MAXWIN ) */
/*           DOUBLE PRECISION      ENDPT  ( 2 ) */
/*           DOUBLE PRECISION      ET0 */
/*           DOUBLE PRECISION      ET1 */
/*           DOUBLE PRECISION      RESULT ( LBCELL : MAXWIN ) */
/*           DOUBLE PRECISION      STEPSZ */

/*           INTEGER               I */
/*           INTEGER               J */
/*           INTEGER               N */

/*     C */
/*     C     Load kernels. */
/*     C */
/*           CALL FURNSH ( META ) */

/*     C */
/*     C     Initialize windows. */
/*     C */
/*           CALL SSIZED ( MAXWIN, CNFINE ) */
/*           CALL SSIZED ( MAXWIN, RESULT ) */

/*     C */
/*     C     Insert search time interval bounds into the */
/*     C     confinement window. */
/*     C */
/*           CALL STR2ET ( '2004 JUN 11 06:30:00 TDB', ET0 ) */
/*           CALL STR2ET ( '2004 JUN 11 12:00:00 TDB', ET1 ) */

/*           CALL WNINSD ( ET0, ET1, CNFINE ) */

/*     C */
/*     C     Initialize inputs for the search. */
/*     C */
/*           INST   = 'CASSINI_ISS_NAC' */
/*           TARGET = 'PHOEBE' */
/*           TSHAPE = 'ELLIPSOID' */
/*           TFRAME = 'IAU_PHOEBE' */
/*           ABCORR = 'LT+S' */
/*           OBSRVR = 'CASSINI' */
/*           STEPSZ = 10.D0 */

/*           WRITE (*,*) ' ' */
/*           WRITE (*,*) 'Instrument: '//INST */
/*           WRITE (*,*) 'Target:     '//TARGET */
/*           WRITE (*,*) ' ' */
/*     C */
/*     C     Perform the search. */
/*     C */
/*           CALL GFTFOV ( INST,   TARGET, TSHAPE, TFRAME, */
/*          .              ABCORR, OBSRVR, STEPSZ, CNFINE, RESULT ) */

/*           N = WNCARD( RESULT ) */

/*           IF ( N .EQ. 0 ) THEN */

/*              WRITE (*,*) 'No FOV intersection found.' */

/*           ELSE */

/*           WRITE (*,*) ' Visibility start time              Stop time' */

/*              DO I = 1, N */

/*                 CALL WNFETD ( RESULT, I, ENDPT(1), ENDPT(2) ) */

/*                 DO J = 1, 2 */
/*                    CALL TIMOUT ( ENDPT(J), TIMFMT, TIMSTR(J) ) */
/*                 END DO */

/*                 LINE( :3) = ' ' */
/*                 LINE(2: ) = TIMSTR(1) */
/*                 LINE(37:) = TIMSTR(2) */

/*                 WRITE (*,*) LINE */

/*              END DO */

/*           END IF */

/*           WRITE (*,*) ' ' */
/*           END */


/*        When this program was executed on a PC/Linux/g77 platform, the */
/*        output was: */


/*  Instrument: CASSINI_ISS_NAC */
/*  Target:     PHOEBE */

/*   Visibility start time              Stop time */
/*   2004-JUN-11 07:35:49.958590 (TDB)  2004-JUN-11 08:48:27.485965 (TDB) */
/*   2004-JUN-11 09:03:19.767799 (TDB)  2004-JUN-11 09:35:27.634790 (TDB) */
/*   2004-JUN-11 09:50:19.585474 (TDB)  2004-JUN-11 10:22:27.854253 (TDB) */
/*   2004-JUN-11 10:37:19.332696 (TDB)  2004-JUN-11 11:09:28.116016 (TDB) */
/*   2004-JUN-11 11:24:19.049485 (TDB)  2004-JUN-11 11:56:28.380304 (TDB) */



/* $ Restrictions */

/*     1) The reference frame associated with INST must be */
/*        centered at the observer or must be inertial. No check is done */
/*        to ensure this. */

/*     2) The kernel files to be used by GFTFOV must be loaded (normally */
/*        via the SPICELIB routine FURNSH) before GFTFOV is called. */

/* $ Literature_References */

/*     None. */

/* $ Author_and_Institution */

/*     N.J. Bachman  (JPL) */
/*     L.S. Elson    (JPL) */
/*     E.D. Wright   (JPL) */

/* $ Version */

/* -    SPICELIB Version 1.0.0  15-APR-2009 (NJB) (LSE) (EDW) */

/* -& */
/* $ Index_Entries */

/*     GF target in instrument FOV search */

/* -& */
/* $ Revisions */

/*     None. */

/* -& */

/*     SPICELIB functions */


/*     External routines */


/*     Interrupt handler: */


/*     Routines to set step size, refine transition times */
/*     and report work: */


/*     Local parameters */


/*     Geometric quantity  bail switch: */


/*     Progress report switch: */


/*     Local variables */


/*     Ray direction vector required by GFFOVE. This is */
/*     an unused variable as far is this routine is concerned: */
/*     the target is an ephemeris object. We initialize the */
/*     ray to prevent portability problems. */


/*     Saved variables */


/*     Initial values */


/*     Standard SPICE error handling. */

    if (return_()) {
	return 0;
    }
    chkin_("GFTFOV", (ftnlen)6);

/*     Reject the target shape 'RAY'. */

    if (eqstr_(tshape, "RAY", tshape_len, (ftnlen)3)) {
	setmsg_("The target shape RAY is not supported by this routine. Use "
		"the routine GFRFOV instead.", (ftnlen)86);
	sigerr_("SPICE(INVALIDOPTION)", (ftnlen)20);
	chkout_("GFTFOV", (ftnlen)6);
	return 0;
    }

/*     Note to maintenance programmer: input exception checks */
/*     are delegated to GFFOVE. If the implementation of that */
/*     routine changes, or if this routine is modified to call */
/*     a different routine in place of GFFOVE, then the error */
/*     handling performed by GFFOVE will have to be performed */
/*     here or in a routine called by this routine. */

/*     Check the result window's size. */

    if (sized_(result) < 2) {
	setmsg_("Result window size must be at least 2 but was #.", (ftnlen)
		48);
	i__1 = sized_(result);
	errint_("#", &i__1, (ftnlen)1);
	sigerr_("SPICE(WINDOWTOOSMALL)", (ftnlen)21);
	chkout_("GFTFOV", (ftnlen)6);
	return 0;
    }

/*     Check step size. */

    if (*step <= 0.) {
	setmsg_("Step size must be positive but was #.", (ftnlen)37);
	errdp_("#", step, (ftnlen)1);
	sigerr_("SPICE(INVALIDSTEP)", (ftnlen)18);
	chkout_("GFTFOV", (ftnlen)6);
	return 0;
    }

/*     Set the step size. */

    gfsstp_(step);

/*     Look for solutions. */

    gffove_(inst, tshape, raydir, target, tframe, abcorr, obsrvr, &c_b15, (
	    U_fp)gfstep_, (U_fp)gfrefn_, &c_false, (U_fp)gfrepi_, (U_fp)
	    gfrepu_, (U_fp)gfrepf_, &c_false, (L_fp)gfbail_, cnfine, result, 
	    inst_len, tshape_len, target_len, tframe_len, abcorr_len, 
	    obsrvr_len);
    chkout_("GFTFOV", (ftnlen)6);
    return 0;
} /* gftfov_ */

