fr.cnes.sirius.patrius.bodies.bsp.spice

Class SpkReader

java.lang.Object

fr.cnes.sirius.patrius.bodies.bsp.spice.SpkReader

public final class SpkReader
extends Object

This class contains the methods linked to the reading of SPK files.
It is build as an adaptation of a variety of routines from the SPICE library.

Since:

4.11

Author:

T0281925

Method Summary

Modifier and Type	Method and Description
static double[]	getStateRelativeToBody(String target, double epoch, String ref, String obs, double[] lightTime) Return the state (position and velocity) of a target body relative to an observing body.
static double[]	getStateRelativeToCenterOfMotion(int handle, double[] descr, double epoch, int[] ref, int[] center) Return, for a specified SPK segment and time, the state (position and velocity) of the segment's target body relative to its center of motion.
static void	spkObjects(String file, Set<Integer> ids) Find the set of ID codes of all objects in a specified SPK file.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

spkObjects

public static void spkObjects(String file,
                              Set<Integer> ids)
                       throws PatriusException,
                              IOException

Find the set of ID codes of all objects in a specified SPK file.

This method is based on the SPKOBJ routine of the SPICE library.

Parameters:

file - the name of an SPK file

ids - w An initialized SPICE set data structure. IDS optionally may contain a set of ID codes on input; on output, the data already present in IDS will be combined with ID code set found for the file SPKFNM. The elements of sets are unique; hence each ID code in IDS appears only once, even if the SPK file contains multiple segments for that ID code.

Throws:

IOException - if there is a problem managing the file

PatriusException - if there is problem managing or reading the file

getStateRelativeToBody

public static double[] getStateRelativeToBody(String target,
                                              double epoch,
                                              String ref,
                                              String obs,
                                              double[] lightTime)
                                       throws PatriusException

Return the state (position and velocity) of a target body relative to an observing body. Never corrected for light time (planetary aberration) or stellar aberration.

This is based on the SPKEZR routine of the SPICE library.

Parameters:

target - The name of a target body. 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 target body.
The target and observer define a state vector whose position component points from the observer to the target.

epoch - The ephemeris time, expressed as seconds past J2000 TDB, at which the state of the target body relative to the observer is to be computed. EPOCH refers to time at the observer's location.

ref - The name of the reference frame relative to which the output state vector should be expressed. This may be any frame supported by the SPICE system.

obs - The name of an observing body. Optionally, you may supply the ID code of the object as an integer string. For example, both 'EARTH' and '399' are legitimate strings to supply to indicate the observer is Earth.

lightTime - The one-way light time between the observer and target in seconds.

Returns:

a Cartesian state vector representing the position and velocity of the target body relative to the specified observer. It is expressed with respect to the reference frame specified by REF. The first three components of STATE represent the x-, y- and z-components of the target's position; the last three components form the corresponding velocity vector.
The position component of STATE points from the observer's location at EPOCH to the location of the target.
The velocity component of STATE is the derivative with respect to time of the position component of STATE.
Units are always km and km/sec.

Throws:

PatriusException - if there is a counter, frame retrieving or state calculation problem

IOException - if there is a problem while calculating the state.

getStateRelativeToCenterOfMotion

public static double[] getStateRelativeToCenterOfMotion(int handle,
                                                        double[] descr,
                                                        double epoch,
                                                        int[] ref,
                                                        int[] center)
                                                 throws PatriusException

Return, for a specified SPK segment and time, the state (position and velocity) of the segment's target body relative to its center of motion.

This method is based on the SPKPVN of the SPICE library. <:p>

Parameters:

handle - File handle

descr - Segment descriptor

epoch - Target epoch

ref - (out) Target reference frame

center - (out) Center of state

Returns:

a 6-array containing position and velocity

Throws:

PatriusException - if there is a problem reading or evaluating the segment