/* bodvrd.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 integer c__0 = 0; static integer c__1 = 1; /* $Procedure BODVRD ( Return d.p. values from the kernel pool ) */ /* Subroutine */ int bodvrd_(char *bodynm, char *item, integer *maxn, integer *dim, doublereal *values, ftnlen bodynm_len, ftnlen item_len) { /* Builtin functions */ /* Subroutine */ int s_copy(char *, char *, ftnlen, ftnlen); integer s_cmp(char *, char *, ftnlen, ftnlen); /* Local variables */ char code[16], type__[1]; extern /* Subroutine */ int chkin_(char *, ftnlen); extern logical beint_(char *, ftnlen); extern /* Subroutine */ int errch_(char *, char *, ftnlen, ftnlen); logical found; extern /* Subroutine */ int bodn2c_(char *, integer *, logical *, ftnlen); integer bodyid; char varnam[32]; extern /* Subroutine */ int gdpool_(char *, integer *, integer *, integer *, doublereal *, logical *, ftnlen), sigerr_(char *, ftnlen), nparsi_(char *, integer *, char *, integer *, ftnlen, ftnlen), chkout_(char *, ftnlen); char errmsg[320]; extern /* Subroutine */ int dtpool_(char *, logical *, integer *, char *, ftnlen, ftnlen), setmsg_(char *, ftnlen), errint_(char *, integer *, ftnlen), suffix_(char *, integer *, char *, ftnlen, ftnlen); extern logical return_(void); extern /* Subroutine */ int intstr_(integer *, char *, ftnlen); integer ptr; /* $ Abstract */ /* Fetch from the kernel pool the double precision values */ /* of an item associated with a body. */ /* $ Copyright */ /* Copyright (2004), California Institute of Technology. */ /* U.S. Government sponsorship acknowledged. */ /* $ Required_Reading */ /* KERNEL */ /* NAIF_IDS */ /* $ Keywords */ /* CONSTANTS */ /* $ Declarations */ /* $ Brief_I/O */ /* VARIABLE I/O DESCRIPTION */ /* -------- --- -------------------------------------------------- */ /* BODYNM I Body name. */ /* ITEM I Item for which values are desired. ('RADII', */ /* 'NUT_PREC_ANGLES', etc. ) */ /* MAXN I Maximum number of values that may be returned. */ /* DIM O Number of values returned. */ /* VALUES O Values. */ /* $ Detailed_Input */ /* BODYNM is the name of the body for which ITEM is requested. */ /* BODYNM is case-insensitive, and leading and trailing */ /* blanks in BODYNM are not significant. Optionally, you */ /* may supply the integer ID code for the object as an */ /* integer string. For example both 'MOON' and '301' are */ /* legitimate strings that indicate the moon is the body */ /* of interest. */ /* ITEM is the item to be returned. Together, the NAIF ID */ /* code of the body and the item name combine to form a */ /* kernel variable name, e.g., */ /* 'BODY599_RADII' */ /* 'BODY401_POLE_RA' */ /* The values associated with the kernel variable having */ /* the name constructed as shown are sought. Below */ /* we'll take the shortcut of calling this kernel variable */ /* the "requested kernel variable." */ /* Note that ITEM *is* case-sensitive. This attribute */ /* is inherited from the case-sensitivity of kernel */ /* variable names. */ /* MAXN is the maximum number of values that may be returned. */ /* The output array VALUES must be declared with size at */ /* least MAXN. It's an error to supply an output array */ /* that is too small to hold all of the values associated */ /* with the requested kernel variable. */ /* $ Detailed_Output */ /* DIM is the number of values returned; this is always the */ /* number of values associated with the requested kernel */ /* variable unless an error has been signaled. */ /* VALUES is the array of values associated with the requested */ /* kernel variable. If VALUES is too small to hold all */ /* of the values associated with the kernel variable, the */ /* returned values of DIM and VALUES are undefined. */ /* $ Parameters */ /* None. */ /* $ Exceptions */ /* 1) If the input body name cannot be translated to an ID code, */ /* and if the name is not a string representation of an integer */ /* (for example, '399'), the error SPICE(NOTRANSLATION) is */ /* signaled. */ /* 2) If the requested kernel variable is not found in the kernel */ /* pool, the error SPICE(KERNELVARNOTFOUND) is signaled. */ /* 3) If the requested kernel variable is found but the associated */ /* values aren't numeric, the error SPICE(TYPEMISMATCH) is */ /* signaled. */ /* 4) The output array VALUES must be declared with sufficient size */ /* to contain all of the values associated with the requested */ /* kernel variable. If the dimension of */ /* VALUES indicated by MAXN is too small to contain the */ /* requested values, the error SPICE(ARRAYTOOSMALL) is signaled. */ /* 5) If the input dimension MAXN indicates there is more room */ /* in VALUES than there really is---for example, if MAXN is */ /* 10 but values is declared with dimension 5---and the dimension */ /* of the requested kernel variable is larger than the actual */ /* dimension of VALUES, then this routine may overwrite */ /* memory. The results are unpredictable. */ /* $ Files */ /* None. */ /* $ Particulars */ /* This routine simplifies looking up PCK kernel variables by */ /* constructing names of requested kernel variables and by */ /* performing error checking. */ /* This routine is intended for use in cases where the maximum */ /* number of values that may be returned is known at compile */ /* time. The caller fetches all of the values associated with */ /* the specified kernel variable via a single call to this */ /* routine. If the number of values to be fetched cannot be */ /* known until run time, the lower-level routine GDPOOL (an */ /* entry point of POOL) should be used instead. GDPOOL supports */ /* fetching arbitrary amounts of data in multiple "chunks." */ /* This routine is intended for use in cases where the requested */ /* kernel variable is expected to be present in the kernel pool. If */ /* the variable is not found or has the wrong data type, this */ /* routine signals an error. In cases where it is appropriate to */ /* indicate absence of an expected kernel variable by returning a */ /* boolean "found flag" with the value .FALSE., again the routine */ /* GDPOOL should be used. */ /* $ Examples */ /* 1) When the kernel variable */ /* BODY399_RADII */ /* is present in the kernel pool---normally because a PCK */ /* defining this variable has been loaded---the call */ /* CALL BODVRD ( 'EARTH', 'RADII', 3, DIM, VALUES ) */ /* returns the dimension and values associated with the variable */ /* 'BODY399_RADII', for example, */ /* DIM = 3 */ /* VALUES(1) = 6378.140 */ /* VALUES(2) = 6378.140 */ /* VALUES(3) = 6356.755 */ /* 2) The call */ /* CALL BODVRD ( 'earth', 'RADII', 3, DIM, VALUES ) */ /* will produce the same results shown in example (1), */ /* since the case of the input argument BODYNM is */ /* not significant. */ /* 3) The call */ /* CALL BODVRD ( '399', 'RADII', 3, DIM, VALUES ) */ /* will produce the same results shown in example (1), */ /* since strings containing integer codes are accepted */ /* by this routine. */ /* 4) The call */ /* CALL BODVRD ( 'EARTH', 'radii', 3, DIM, VALUES ) */ /* usually will cause a SPICE(KERNELVARNOTFOUND) error to be */ /* signaled, because this call will attempt to look up the */ /* values associated with a kernel variable of the name */ /* 'BODY399_radii' */ /* Since kernel variable names are case sensitive, this */ /* name is not considered to match the name */ /* 'BODY399_RADII' */ /* which normally would be present after a text PCK */ /* containing data for all planets and satellites has */ /* been loaded. */ /* $ Restrictions */ /* None. */ /* $ Literature_References */ /* None. */ /* $ Author_and_Institution */ /* N.J. Bachman (JPL) */ /* B.V. Semenov (JPL) */ /* W.L. Taber (JPL) */ /* I.M. Underwood (JPL) */ /* $ Version */ /* - SPICELIB Version 1.0.0, 23-FEB-2004 (NJB) (BVS) (WLT) (IMU) */ /* -& */ /* $ Index_Entries */ /* fetch constants for a body from the kernel pool */ /* physical constants for a body */ /* -& */ /* SPICELIB functions */ /* Local parameters */ /* Local variables */ /* Standard SPICE error handling. */ if (return_()) { return 0; } else { chkin_("BODVRD", (ftnlen)6); } /* Translate the input name to an ID code. */ bodn2c_(bodynm, &bodyid, &found, bodynm_len); if (! found) { if (beint_(bodynm, bodynm_len)) { s_copy(errmsg, " ", (ftnlen)320, (ftnlen)1); nparsi_(bodynm, &bodyid, errmsg, &ptr, bodynm_len, (ftnlen)320); if (s_cmp(errmsg, " ", (ftnlen)320, (ftnlen)1) != 0) { found = FALSE_; } else { found = TRUE_; } } } if (! found) { setmsg_("The body name # could not be translated to a NAIF ID code. " " The cause of this problem may be that you need an updated v" "ersion of the SPICE Toolkit.", (ftnlen)147); errch_("#", bodynm, (ftnlen)1, bodynm_len); sigerr_("SPICE(NOTRANSLATION)", (ftnlen)20); chkout_("BODVRD", (ftnlen)6); return 0; } /* Construct the variable name from BODY and ITEM. */ s_copy(varnam, "BODY", (ftnlen)32, (ftnlen)4); intstr_(&bodyid, code, (ftnlen)16); suffix_(code, &c__0, varnam, (ftnlen)16, (ftnlen)32); suffix_("_", &c__0, varnam, (ftnlen)1, (ftnlen)32); suffix_(item, &c__0, varnam, item_len, (ftnlen)32); /* Make sure the item is present in the kernel pool. */ dtpool_(varnam, &found, dim, type__, (ftnlen)32, (ftnlen)1); if (! found) { setmsg_("The variable # could not be found in the kernel pool.", ( ftnlen)53); errch_("#", varnam, (ftnlen)1, (ftnlen)32); sigerr_("SPICE(KERNELVARNOTFOUND)", (ftnlen)24); chkout_("BODVRD", (ftnlen)6); return 0; } /* Make sure the item's data type is numeric. */ if (*(unsigned char *)type__ != 'N') { setmsg_("The data associated with variable # are not of numeric type." , (ftnlen)60); errch_("#", varnam, (ftnlen)1, (ftnlen)32); sigerr_("SPICE(TYPEMISMATCH)", (ftnlen)19); chkout_("BODVRD", (ftnlen)6); return 0; } /* Make sure there's enough room in the array VALUES to hold */ /* the requested data. */ if (*maxn < *dim) { setmsg_("The data array associated with variable # has dimension #, " "which is larger than the available space # in the output arr" "ay.", (ftnlen)122); errch_("#", varnam, (ftnlen)1, (ftnlen)32); errint_("#", dim, (ftnlen)1); errint_("#", maxn, (ftnlen)1); sigerr_("SPICE(ARRAYTOOSMALL)", (ftnlen)20); chkout_("BODVRD", (ftnlen)6); return 0; } /* Grab the values. We know at this point they're present in */ /* the kernel pool, so we don't check the FOUND flag. */ gdpool_(varnam, &c__1, maxn, dim, values, &found, (ftnlen)32); chkout_("BODVRD", (ftnlen)6); return 0; } /* bodvrd_ */