DAF_RECORD_LENGTH

DAF record length, in bytes.

References

• DAF Required Reading

FTPSTR

Validation string that guarantees the integrity of a DAF file.

References

• DAF Required Reading

SPK_SEGMENT_MAPPING

A dictionary mapping SPK segment types to the field index of the SPKSegmentList.

TCB_SEGMENTS

List of the SPK/PCK segment types for which the time argument is expressed in the TCB scale.

TDB_SEGMENTS

List of the SPK/PCK segment types for which the time argument is expressed in the TDB scale.

AbstractEphemRecord

Abstract type for ephemeris segment records.

AbstractSPKCache

Abstract type for all SPK segment type caches.

AbstractSPKHeader

Abstract type for all SPK segment type headers.

AbstractSPKSegment

Abstract type for all SPK segment types.

DAF

Container to hold the information of NAIF's Double precision Array File (DAF).

Fields

• filepath – String system filepath of the DAF
• array – Vector{UInt8} binary content of the DAF
• header – DAFHeader file record of the DAF
• comment – String text within the DAF comment area
• ftype – Int file type, equals 1 for SPK and 2 for PCK
• desc – DAF PCK/SPK segment descriptors
• seglist – SPKSegmentList list of the SPK/PCK segments within the DAF

References

• DAF Required Reading

See Also

See also DAFHeader, Ephemerides.SPKSegmentList and EphemerisProvider

DAF(filename::String)

Parse a DAF file and retrieve its content.

See Also

See also initialise_segments!.

DAFHeader

The DAF header, or file record, is the first physical record in a DAF and stores general information about the content of the file.

Fields

• nd – Int32 number of double components in each array summary
• ni – Int32 number of integer components in each array summary
• fwd – Int32 record number of initial summary record
• bwd – Int32 record number of final summary record
• ffa – Int32 first free address of the file
• name – String internal name of the file
• lend – Bool true if the file was generated in little endian

References

• DAF Required Reading

See Also

See also DAF and EphemerisProvider

DAFHeader(record::Vector{UInt8})

Parse the header (file record) of the DAF file, i.e., the first physical record in a DAF which contains global information about the file.

References

• DAF Required Reading

See Also

See also DAF, parse_daf_comment and parse_daf_summaries

DAFSegmentDescriptor

A container object to store both SPK and PCK descriptors information.

Fields

• segtype – Int32 SPK/PCK segment type
• tstart – Float64 initial segment type, in TDB seconds since J2000.0
• tend – Float64 final segment type, in TDB seconds since J2000.0
• tid – Int32 target object NAIF ID
• cid – Int32 center object NAIF ID
• axesid – Int32 reference axes ID. Defaults to -1 for PCKs
• iaa – Int32 initial array address
• faa – Int32 final array address

References

• SPK Required Reading
• PCK Required Reading

DAFSegmentDescriptor(summary::Vector{UInt8}, head::DAFHeader, isspk::Bool)

Generate an SPK or PCK descriptor by parsing a DAF summary.

EphemRecordPCK <: AbstractEphemRecord

Store the PCK metadata relative to a given (target, center) axes pair.

Fields

• target – Int target axes NAIF ID
• center – Int center axes NAIF ID
• t_start – start times of each sub-window, in TDB seconds since J2000
• t_end – final times of each sub-window, in TDB seconds since J2000

EphemRecordSPK <: AbstractEphemRecord

Store the SPK metadata relative to a given (target, center) objects pair.

Fields

• target – Int target object NAIF ID
• center – Int center object NAIF ID
• axes – Int reference axes ID
• t_start – start times of each sub-window, in TDB seconds since J2000
• t_end – final times of each sub-window, in TDB seconds since J2000

EphemerisProvider(file::String)
EphemerisProvider(files::Vector{String})

Create an EphemerisProvider instance by loading a single or multiple binary ephemeris kernel files specified by files. Currently, only NAIF Double precision Array File (DAF) kernels (i.e., SPK and PCK) are accepted.

Example

julia> eph = EphemerisProvider("PATH_TO_KERNEL")
EphemerisProvider([...])

julia> eph = EphemerisProvider(["PATH_TO_KERNEL_1", "PATH_TO_KERNEL_2"])
EphemerisProvider([])

InterpCache{T}

InterpCache{T}(len::Int, buffsize::Int)

Create an InterpCache instance of type T with len buffers, each of size buffsize.

SPKLink

A link object to create a mapping between DAFSegmentDescriptor and its actual location within an EphemerisProvider object.

Fields

• desc – DAFSegmentDescriptor for the segment associated to this link
• fid – Int index of the DAF containg the link data.
• lid – Int field number in the SPKSegmentList for this segment type.
• eid – Int index of the inner segment list that stores this SPK segment.
• fct – Int 1 or -1 depending on whether the (from, to) directions must be reversed.

See Also

See also SPKLinkTable, SPKSegmentList and add_spklinks!.

SPKLinkTable

Dictionary object providing all the SPKLink available between a set of (from, to) objects

SPKSegmentCache1 <: AbstractSPKCache

Cache instance for SPK segments of type 1 and 21. The fields contained within this cache are taken from the FORTRAN NAIF's SPICE implementation for type 1 SPK segments.

Fields

• tl – Reference epoch of the difference line.
• g – Stepsize function vector.
• refpos – Reference position vector.
• refvel – Reference velocity vector.
• dt – Modified Divided Difference arrays, with size (maxdim, 3)
• kqmax – Maximum integration order plus 1.
• kq – Integration order array.
• id – Index of the currently loaded logical record.
• fc – Buffer for the MDA computations.
• wc – Buffer for the MDA computations.
• w – Buffer for the MDA computations.
• vct – Buffer for the MDA computations.

SPKSegmentCache1(head::SPKSegmentHeader1)

Initialise the cache for an SPK segment of type 1.

SPKSegmentCache18 <: AbstractSPKCache

Cache instance for SPK segments of type 18.

Fields

• p – Vector storing indexes of the first and last points as well as the window size.
• epochs – Epochs of the interpolating points.
• states – Matrix storing the states of the interpolating points.
• buff – Buffers to compute the interpolating polynomials.

SPKSegmentCache19 <: AbstractSPKCache

Cache instance for SPK segments of type 19.

Fields

• minihead – Header with the mini-segment properties.
• minidata – Cache for the mini-segment.
• id – Index of the currently loaded mini-segment.

SPKSegmentCache19(daf::DAF, head::SPKSegmentHeader2)

Initialise the cache for an SPK segment of type 19.

SPKSegmentCache2 <: AbstractSPKCache

Cache instance for SPK segments of type 2 and 3.

Fields

• A – Chebyshev's polynomial coefficients, with size (ncomp, order)
• p – Stores the record mid point and radius and scale factor
• buff – Stores the buffers for the Chebyshev polynomials
• id – Index of the currently loaded logical record

SPKSegmentCache14(head::SPKSegmentHeader14)

Initialise the cache for an SPK segment of type 14.

SPKSegmentCache2(head::SPKSegmentHeader2)

Initialise the cache for an SPK segment of type 2 and 3.

SPKSegmentCache20 <: AbstractSPKCache

Cache instance for SPK segments of type 20.

Fields

• id – Index of the currently loaded logical record
• p – Stores the record position constants
• A – Chebyshev's polynomial coefficients, with size (ncomp, order)
• buff – Stores the buffers for the Chebyshev polynomials

SPKSegmentCache20(head::SPKSegmentHeader2)

Initialise the cache for an SPK segment of type 20.

SPKSegmentCache5 <: AbstractSPKCache

Cache instance for SPK segments of type 5.

Fields

• c1 – Twobody propagation cache for the left state.
• c2 – Twobody propagation cache for the right state.
• epochs – Epochs associated to the two states.
• id – Index of the currently loaded logical record.

SPKSegmentCache5(head::SPKSegmentHeader5)

Initialise the cache for an SPK segment of type 5.

SPKSegmentCache8 <: AbstractSPKCache

Cache instance for SPK segments of type 8 and 12.

Fields

• states – Matrix storing the states of the interpolating points.
• buff – Buffers to compute the interpolating polynomials.
• id – Index of the currently loaded logical record.

SPKSegmentCache8(head::SPKSegmentHeader2)

Initialise the cache for an SPK segment of type 8 and 12.

SPKSegmentCache9 <: AbstractSPKCache

Cache instance for SPK segments of type 9 and 13.

Fields

• epochs – Epochs of the interpolating points.
• states – Matrix storing the states of the interpolating points.
• buff – Buffers to compute the interpolating polynomials.
• id – Index of the currently loaded logical record.

SPKSegmentCache9(head::SPKSegmentHeader2)

Initialise the cache for an SPK segment of type 9 and 13.

SPKSegmentHeader1 <: AbstractSPKHeader

Header instance for SPK segments of type 1 and 21.

Fields

• n – Int number of records in the segment
• ndirs – Int number of directory epochs
• epochs – Storage for directory epochs or epochs (when ndirs = 0)
• iaa - Int initial segment file address
• etid – Int initial address for the epoch table (after all the MDA records)
• recsize - Int Number of double numbers stored in each MDA record
• maxdim - Int MDA dimension (fixed to 15 for type 1)

SPKSegmentHeader1(daf::DAF, desc::DAFSegmentDescriptor)

Create the segment header for an SPK segment of type 1.

SPKSegmentHeader14 <: AbstractSPKHeader

Header instance for SPK segments of type 14.

Fields

• order – Int interpolating polynomial degree
• n – Int number of packets in the segment
• ndirs – Int number of epoch directories
• epochs – Storage for directory epochs or epochs (when ndirs = 0)
• etid – Int initial address for the epoch table (after all the state data)
• ptid – Int initial address for the packet table (after the constants)
• pktsize – Int size of each data packet excluding the packet information area.
• pktoff – Int offset of the packet data from the packet start
• ncomp – Int number of states coefficients (= 6 for SPK 14)
• N – Int number of polynomial coefficients

SPKSegmentHeader14(daf::DAF, desc::DAFSegmentDescriptor)

Create the segment header for an SPK segment of type 14.

SPKSegmentHeader15 <: AbstractSPKHeader

Header instance for SPK segments of type 15.

Fields

• epoch – Epoch of periapsis
• tp – Trajectory pole, i.e., vector parallel to the angular momentum of the orbit
• pv – Central body north pole unit vector
• pa – Periapsis unit vector at epoch
• p – Semi-latus rectum
• ecc – Eccentricity
• j2f – J2 processing flag
• vj2 – J2 validation flag, true if the orbit shape is compliant with J2 pertubations.
• GM – Central body gravitational constant (km³/s²)
• J2 – Central body J2
• R – Central body radius (km)
• dmdt – Mean anomaly rate of change (rad/s)
• kn – Gain factor for the regression of the nodes
• kp – Gain factor for the precession of the pericenter

SPKSegmentHeader15(daf::DAF, desc::DAFSegmentDescriptor)

Create the segment header for an SPK segment of type 15.

SPKSegmentHeader17 <: AbstractSPKHeader

Header instance for SPK segments of type 17.

Fields

• epoch: epoch of periapsis (s)
• sma: semi-major axis (km)
• h: H term of the equinoctial elements
• k: K term of the equinoctial elements
• lon: mean longitude at epoch (rad)
• p: P term of the equinoctial elements
• q: Q term of the equinoctial elements
• dlpdt: rate of longitude of the periapse (rad/s)
• dmldt: mean longitude rate (mean motion rate), (rad/s)
• dnodedt: longitude of the ascending node rate (rad/s)
• ra: equatorial pole right ascension (rad)
• de: equatorial pole declination (rad)
• R: Rotation matrix from planetary equator to inertial reference frame

SPKSegmentHeader17(daf::DAF, desc::DAFSegmentDescriptor)

Create the segment header for an SPK segment of type 17.

SPKSegmentHeader18 <: AbstractSPKHeader

Header instance for SPK segments of type 18.

Fields

• n – Int number of states in the segment
• ndirs – Int number of epoch directories
• epochs – Storage for directory epochs or epochs (when ndirs = 0)
• iaa - Int initial segment file address
• etid – Int initial address for the epoch table (after all the state data)
• order – Int interpolating polynomial degree
• N – Int group size
• subtype – Int type 18 subtype, either 0 (Hermite) or 1 (Lagrange)
• packetsize – Int packet size for each point, either 12 (Hermite) or 6 (Lagrange)

SPKSegmentHeader18(n::Int)

Create a default header for type 18 segments, whose epoch array has length n.

SPKSegmentHeader19 <: AbstractSPKHeader

Header instance for SPK segments of type 19.

Fields

• n – Int number of states in the segment.
• ndirs – Int number of epoch directories.
• times – Storage for interval directories or start times (when ndirs = 0).
• iaa - Int initial segment file address.
• etid – Int byte address for the interval table (after all the minisegment data).
• ptid – Int byte for the pointer table.
• usefirst – Bool boundary flag, true if the preceding segment should be used.
• type – Int either type 18 or 19.

SPKSegmentHeader19(daf::DAF, desc::DAFSegmentDescriptor)

Create the segment header for an SPK segment of type 18 and 19.

SPKSegmentHeader2 <: AbstractSPKHeader

Header instance for SPK segments of type 2 and 3.

Fields

• tstart – Float64 initial epoch of the first record, in seconds since J2000
• tlen – Float64 interval length covered by each record, in seconds
• order – Int polynomial order
• N – Int number of coefficients in each window
• n – Int number of records in the segment
• recsize – Int byte size of each logical record
• ncomp – Int number of vector components
• iaa – Int initial segment file address
• type – Int SPK segment type, either 2 or 2

SPKSegmentHeader2(daf::DAF, desc::DAFSegmentDescriptor)

Create the segment header for an SPK segment of type 2 and 3.

SPKSegmentHeader20 <: AbstractSPKHeader

Header instance for SPK segments of type 20.

Fields

• dscale – Float64 length conversion factor
• tscale – Float64 time conversion factor
• tstart – Float64 initial epoch of the first record, in seconds since J2000
• tlen – Float64 interval length covered by each record, in seconds
• recsize – Int byte size of each logical record
• order – Int polynomial order
• N – Int number of coefficients in each window
• n – Int number of records in the segment
• iaa – Int initial segment file address

SPKSegmentHeader20(daf::DAF, desc::DAFSegmentDescriptor)

Create the segment header for an SPK segment of type 20

SPKSegmentHeader5 <: AbstractSPKHeader

Header instance for SPK segments of type 5.

Fields

• GM – Float64 Gravitational constant
• n – Int number of states
• ndirs – Int number of epoch directories
• etid – Int initial address for the epoch table (after all the state data)
• epochs – Storage for directory epochs or epochs (when ndirs = 0)
• iaa - Int initial segment file address

SPKSegmentHeader5(daf::DAF, desc::DAFSegmentDescriptor)

Create the segment header for an SPK segment of type 5.

SPKSegmentHeader8 <: AbstractSPKHeader

Header instance for SPK segments of type 8 and 12.

Fields

• tstart – Float64 segment starting epoch, in TDB seconds since J2000
• tlen – Float64 interval length, in seconds
• order – Int interpolating polynomial degree
• N – Int group size
• n – Int number of states in the segment
• iaa - Int initial segment file address
• iseven – Bool true for even group size
• type – Int SPK type (either 8 or 12)

SPKSegmentHeader8(daf::DAF, desc::DAFSegmentDescriptor)

Create the segment header for an SPK segment of type 8 and 12.

SPKSegmentHeader9 <: AbstractSPKHeader

Header instance for SPK segments of type 9 and 13.

Fields

• n – Int number of states in the segment
• ndirs – Int number of epoch directories
• epochs – Storage for directory epochs or epochs (when ndirs = 0)
• iaa - Int initial segment file address
• etid – Int initial address for the epoch table (after all the state data)
• order – Int interpolating polynomial degree
• N – Int group size
• iseven – Bool true for even group size
• type – Int SPK type (either 9 or 13)

SPKSegmentHeader9(daf::DAF, desc::DAFSegmentDescriptor)

Create the segment header for an SPK segment of type 9 and 13.

SPKSegmentList

A container object to efficiently store all the different SPK segments that are contained within a single DAF file.

SPKSegmentList()

Initialises an empty SPKSegmentList object.

See also

See also Ephemerides.add_segment!

SPKSegmentType1 <: AbstractSPKSegment

Segment instance for SPK segments of type 1 and 21, which contain Modified Difference Arrays (MDA). This data type is normally used for spacecraft whose ephemerides are produced by JPL's principal trajectory integrator DPTRAJ.

Fields

• head – Segment header
• cache – Segment cache

References

• SPK Required Reading
• SPICE Toolkit

SPKSegmentType1(daf::DAF, desc::DAFSegmentDescriptor)

Create the object representing an SPK segment of type 1.

SPKSegmentType14 <: AbstractSPKSegment

Segment instance for SPK segments of type 14.

Fields

• head – Segment header
• cache – Segment cache

References

• SPK Required Reading
• SPICE Toolkit

SPKSegmentType14(daf::DAF, desc::DAFSegmentDescriptor)

Create the object representing an SPK segment of type 14.

SPKSegmentType15 <: AbstractSPKSegment

Segment instance for SPK segments of type 15.

Fields

• head – Segment header
• cache – Segment cache

References

• SPK Required Reading
• SPICE Toolkit

SPKSegmentType15(daf::DAF, desc::DAFSegmentDescriptor)

Create the object representing an SPK segment of type 15.

SPKSegmentType17 <: AbstractSPKSegment

Segment instance for SPK segments of type 17.

Fields

• head – Segment header

References

• SPK Required Reading
• SPICE Toolkit

SPKSegmentType17(daf::DAF, desc::DAFSegmentDescriptor)

Create the object representing an SPK segment of type 17.

SPKSegmentType19 <: AbstractSPKSegment

Segment instance for SPK segments of type 18 and 19. Type 18 segments are treated as special cases of a type 19 with a single mini-segment.

Fields

• head – Segment header
• cache – Segment cache

References

• SPK Required Reading
• SPICE Toolkit

SPKSegmentType19(daf::DAF, desc::DAFSegmentDescriptor)

Create the object representing an SPK segment of type 19.

SPKSegmentType2 <: AbstractSPKSegment

Segment instance for SPK segments of type 2 and 3, which contain Chebyshev polynomial coefficients for the position and/or state of the body as function of time. This data type is normally used for planet barycenters, and for satellites whose ephemerides are integrated.

Fields

• head – Segment header
• cache – Segment cache

References

• SPK Required Reading
• SPICE Toolkit

SPKSegmentType2(daf::DAF, desc::DAFSegmentDescriptor)

Create the object representing an SPK segment of type 2.

SPKSegmentType2 <: AbstractSPKSegment

Segment instance for SPK segments of type 20, which contain Chebyshev polynomial coefficients for the position and/or state of the body as function of time. This data type is normally used for planet barycenters, and for satellites whose ephemerides are integrated.

Fields

• head – Segment header
• cache – Segment cache

References

• SPK Required Reading
• SPICE Toolkit

SPKSegmentType20(daf::DAF, desc::DAFSegmentDescriptor)

Create the object representing an SPK segment of type 2.

SPKSegmentType5 <: AbstractSPKSegment

Segment instance for SPK segments of type 5.

Fields

• head – Segment header
• cache – Segment cache

References

• SPK Required Reading
• SPICE Toolkit

SPKSegmentType2(daf::DAF, desc::DAFSegmentDescriptor)

Create the object representing an SPK segment of type 5.

SPKSegmentType8 <: AbstractSPKSegment

Segment instance for SPK segments of type 8 and 12.

Fields

• head – Segment header
• cache – Segment cache

References

• SPK Required Reading
• SPICE Toolkit

SPKSegmentType8(daf::DAF, desc::DAFSegmentDescriptor)

Create the object representing an SPK segment of type 8 and 12.

SPKSegmentType9 <: AbstractSPKSegment

Segment instance for SPK segments of type 9 and 13.

Fields

• head – Segment header
• cache – Segment cache

References

• SPK Required Reading
• SPICE Toolkit

SPKSegmentType9(daf::DAF, desc::DAFSegmentDescriptor)

Create the object representing an SPK segment of type 9 and 13.

TwoBodyUniversalCache

A container to store precomputed quantities required for the two-body propagation based on universal variables. Only the quantities that depend on the initial state are computed.

add_segment!(list::SPKSegmentList, spk::AbstractSPKSegment)

Add the SPK segment to the proper vector within the given Ephemerides.SPKSegmentList list

add_spklinks!(table::SPKLinkTable, daf::DAF, fid::Int)

Insert in the input SPKLinkTable all the SPK or PCK links associated to the segment descriptors of the input DAF.

analyse_timespan(records)

Analyse a set of AbstractEphemRecord, returning the minimum and maximum covered times, in TDB seconds since J2000, together with a continuity parameter.

References

• CALCEPH C++ library

See Also

See also ephem_spk_timespan and ephem_pck_timespan.

get_array(daf::DAF)

Return the byte content of the DAF file.

axes(desc::DAFSegmentDescriptor)

Return the NAIF integer code for the reference axes. It is valid only for SPK files and defaults to -1 for PCKs.

cache(spk::AbstractSPKSegment)

Return the segment cache data.

center(desc::DAFSegmentDescriptor)

Return the NAIF integer code for the reference object or axes for SPK and PCK, respectively.

chebyshev(cache::InterpCache, cₖ, t::Number, idx::Int, N::Int, ibuff::Int)

Evaluate a sum of Cheybyshev polynomials of the first kind at t using a recursive algorithm. It simultenously evalutes the 3 state components. idx is the index of the starting row (in 0-based notation) in the matrix of coefficients cₖ. ibuff is the index of the first free buffer.

See Also

See also ∂chebyshev, ∂²chebyshev and ∂³chebyshev

get_comment(daf::DAF)

Return the comment written in the DAF comment section.

compute_mda_position(cache::SPKSegmentCache1, Δ::Number)

compute_mda_velocity(cache::SPKSegmentCache1, Δ::Number)

create_linktables(dafs::Vector{DAF})

Create the SPK and PCK SPKLinkTable for all the segments stores in the input DAFs.

create_spk_segment(daf::DAF, desc::DAFSegmentDescriptor)

Initialise an SPK segment according to the segment type defined in the DAFSegmentDescriptor desc.

descriptor(link::SPKLink)

Return the SPK/PCK segment descriptor associated to this link.

get_descriptors(daf::DAF)

Return the SPK/PCK segment descriptors contained in the DAF.

element_id(link::SPKLink)

Return the segment index in the inner SPK/PCK segment list.

endian(head::DAFHeader)

Return true if the DAF file is in little-endian.

endian(daf::DAF)

Return true if the DAF is in little-endian.

ephem_get_axes(eph::EphemerisProvider)

Return a list of Frame IDs representing axes with available orientation data.

ephem_get_points(eph::EphemerisProvider)

Return a list of NAIFIds representing bodies with available ephemeris data.

ephem_pck_records(eph::EphemerisProvider)

Return a list of EphemRecordPCK storing metadata relative to each (target, center) axes pairs in the loaded PCK kernels.

ephem_pck_timespan(eph::EphemerisProvider)

Return the minimum and maximum time available in the PCK kernels loaded within eph, in TDB seconds since J2000, together with a continuity parameter defined as follows:

• 0 no PCK data is available.
• 1 the quantities of all axes are available for any time between the first and last time.
• 2 the quantities of some axes are available on discontinuous time intervals between the first and last time.
• 3 the quantities of each axis are available on a continuous time interval between the first and the last time, but not available for any time between the first and last time.

References

• CALCEPH C++ library

See Also

See also ephem_spk_timespan.

ephem_rotation12(eph::EphemerisProvider, from::Int, to::Int, time::Number)

Compute the 12-elements orientation angles of one set of axes (to) relative to another (from) at time, expressed in TDB/TCB seconds since J2000, in accordance with the kernel timescale.

ephem_rotation3(eph::EphemerisProvider, from::Int, to::Int, time::Number)

Compute the 3-elements orientation angles of one set of axes (to) relative to another (from) at time, expressed in TDB/TCB seconds since J2000, in accordance with the kernel timescale.

ephem_rotation6(eph::EphemerisProvider, from::Int, to::Int, time::Number)

Compute the 6-elements orientation angles of one set of axes (to) relative to another (from) at time, expressed in TDB/TCB seconds since J2000, in accordance with the kernel timescale.

ephem_rotation9(eph::EphemerisProvider, from::Int, to::Int, time::Number)

Compute the 9-elements orientation angles of one set of axes (to) relative to another (from) at time, expressed in TDB/TCB seconds since J2000, in accordance with the kernel timescale.

ephem_spk_records(eph::EphemerisProvider)

Return a list of EphemRecordSPK storing metadata relative to each (target, center) object pairs in the loaded SPK kernels.

ephem_spk_timespan(eph::EphemerisProvider)

Return the minimum and maximum time available in the SPK kernels loaded within eph, in TDB seconds since J2000, together with a continuity parameter defined as follows:

• 0 no SPK data is available.
• 1 the quantities of all bodies are available for any time between the first and last time.
• 2 the quantities of some bodies are available on discontinuous time intervals between the first and last time.
• 3 the quantities of each body are available on a continuous time interval between the first and the last time, but not available for any time between the first and last time.

References

• CALCEPH C++ library

See Also

See also ephem_pck_timespan.

ephem_timescale_id(eph::EphemerisProvider)

Retrieve a timescale ID associated with the ephemeris handler eph. It returns 1 for Barycentric Dynamical Time (TDB) and 2 for Barycentric Coordinate Time (TCB).

ephem_vector12(eph::EphemerisProvider, from::Int, to::Int, time::Number)

Compute the 12-elements state of one body (to) relative to another (from) at time, expressed in TDB/TCB seconds since J2000, in accordance with the kernel timescale.

ephem_vector3(eph::EphemerisProvider, from::Int, to::Int, time::Number)

Compute the 3-elements state of one body (to) relative to another (from) at time, expressed in TDB/TCB seconds since J2000, in accordance with the kernel timescale.

ephem_vector6(eph::EphemerisProvider, from::Int, to::Int, time::Number)

Compute the 6-elements state of one body (to) relative to another (from) at time, expressed in TDB/TCB seconds since J2000, in accordance with the kernel timescale.

ephem_vector9(eph::EphemerisProvider, from::Int, to::Int, time::Number)

Compute the 9-elements state of one body (to) relative to another (from) at time, expressed in TDB/TCB seconds since J2000, in accordance with the kernel timescale.

factor(link::SPKLink)

Return the direction multiplicative factor.

file_id(link::SPKLink)

Return the DAF file index.

filename(head::DAFHeader)

Return the internal description of the DAF.

filepath(daf::DAF)

Return the system path of the DAF.

final_address(desc::DAFSegmentDescriptor)

Return the final address of the segment array in teh DAF.

final_record(head::DAFHeader)

Return the record number of the final summary record in the DAF

final_record(daf::DAF)

Return the record number of the final summary record in the DAF.

final_time(desc::DAFSegmentDescriptor)

Return the final epoch of the interval for which ephemeris data are contained in the segment, in seconds since J2000.0

final_time(link::SPKLink)

Return the final epoch of the interval for which ephemeris data are contained in the segment associated to this link, in seconds since J2000.0

final_times(record::AbstractEphemRecord)

Recover the final times of each sub-window in which the ephemeris data of record is defined, expressed in TDB seconds since J2000

find_logical_record(daf::DAF, head::SPKSegmentHeader1, time::Number)

find_logical_record(daf::DAF, head::SPKSegmentHeader14, time::Number)

find_logical_record(daf::DAF, head::SPKSegmentHeader18, time::Number)

find_logical_record(daf::DAF, head::SPKSegmentHeader5, time::Number)

find_logical_record(daf::DAF, head::SPKSegmentHeader1, time::Number)

find_logical_record(head::SPKSegmentHeader2, time::Number)

find_logical_record(head::SPKSegmentHeader20, time::Number)

find_logical_record(head::SPKSegmentHeader8, time::Number)

find_minirecord(daf::DAF, head::SPKSegmentHeader19, time::Number)

free_address(head::DAFHeader)

Return the first free address in the file, i.e., the address at which the first element of the next array is to be added.

free_address(daf::DAF)

Return the first free address in the file, i.e., the address at which the first element of the next array is to be added.

get_buffer(c::InterpCache, idx::int, x::Number)

Return the idx-th buffer from the corresponding DiffCache depending on the type of x.

get_coefficients!(daf::DAF, head::SPKSegmentHeader1, cache::SPKSegmentCache1, index::Int)

get_coefficients!(daf::DAF, head::SPKSegmentHeader14, cache::SPKSegmentCache14, index::Int)

get_coefficients!(daf::DAF, head::SPKSegmentHeader18, cache::SPKSegmentCache18, first::Int, last::Int)

get_coefficients!(daf::DAF, head::SPKSegmentHeader2, cache::SPKSegmentCache2, index::Int)

get_coefficients!(daf::DAF, head::SPKSegmentHeader20, cache::SPKSegmentCache20, index::Int)

get_coefficients!(daf::DAF, head::SPKSegmentHeader5, cache::SPKSegmentCache5, index::Int)

get_coefficients!(daf::DAF, head::SPKSegmentHeader8, cache::SPKSegmentCache8, index::Int)

get_coefficients!(daf::DAF, head::SPKSegmentHeader9, cache::SPKSegmentCache9, index::Int)

daf(eph::EphemerisProvider, id::Int)

Return the DAF file in the ephemeris provider at index id.

daf(eph::EphemerisProvider)

Return the DAF files stored in the ephemeris provider.

get_record(array::Vector{UInt8}, index::Integer)

Retrieve a whole DAF record at position index.

get_segment(list::SPKSegmentList, lid::Int, eid::Int)

Return the segment contained in the lid list at index eid.

get_segment_boundaries(desclist::Vector{DAFSegmentDescriptor})

Parse all the segment descriptors of a given (center, target) pair and return a set of initial and final times, in TDB seconds since J2000, representing all the time sub-windows in which the ephemeris data for this pair is defined.

get_header(daf::DAF)

Return the DAFHeader header of the DAF.

header(spk::AbstractSPKSegment)

Return the segment header.

hermite(cache::InterpCache, states, epochs, x, idx::Int, N::Int)

Evalute a Hermite polynomial at x using a recursive algorithm. This function handles unequally-spaced polynomials, where the coefficients in states are interpolated at epochs.

hermite(cache::InterpCache, states, x, idx::Int, N::Int, Δt::Number)

Evalute a Hermite polynomial at x using a recursive algorithm. This function is valid only for equally-spaced polynomials. idx is the index of the desired state, N is the number of coefficients of the polynomial and Δt is the length of the polynomial interval.

See Also

See also ∂hermite, ∂²hermite and ∂³hermite.

initial_address(desc::DAFSegmentDescriptor)

Return the initial address of the segment array in the DAF.

initial_record(head::DAFHeader)

Return the record number of the initial summary record in the DAF

initial_record(daf::DAF)

Return the record number of the initial summary record in the DAF.

initial_time(desc::DAFSegmentDescriptor)

Return the initial epoch of the interval for which ephemeris data are contained in the segment, in seconds since J2000.0

initial_time(link::SPKLink)

Return the initial epoch of the interval for which ephemeris data are contained in the segment associated to this link, in seconds since J2000.0

initial_times(record::AbstractEphemRecord)

Recover the initial times of each sub-window in which the ephemeris data of record is defined, expressed in TDB seconds since J2000

initialise_segments!(daf::DAF)

Fill the Ephemerides.SPKSegmentList by initialising the SPK/PCK segments associated to all the descriptors stores within the DAF.

See Also

See also DAF and create_spk_segment

is_little_endian(array::Vector{UInt8})

Return true if the array corresponds to the string indicating a little-endian format.

is_pck(daf::DAF)

Return true if the DAF stores PCK data.

is_spk(daf::DAF)

Return true if the DAF stores SPK data.

lagrange(cache::InterpCache, states, epochs, x, idx::Int, N::Int)

Recursively evaluate a Lagrange polynomial at x by using Neville's algorithm. This function handles unequally-spaced polynomials, where the coefficients in states are interpolated at epochs.

lagrange(cache::InterpCache, states, x, idx::Int, N::Int)

Recursively evaluate a Lagrange polynomial at x by using Neville's algorithm. This function is valid only for equally-spaced polynomials. idx is the index of the desired state and N is the number of coefficients of the polynomial.

See Also

See also ∂lagrange and ∂²lagrange.

list_id(link::SPKLink)

Return the index of the list containing the segments of the given SPK/PCK type.

load_minisegment!(daf::DAF, head::SPKSegmentHeader19, cache::SPKSegmentCache19, index::Int)

normalise_time(cache::SPKSegmentCache2, time::Number)

Transform time in an interval between [-1, 1] for compliance with Chebyshev polynomials.

normalise_time(head::SPKSegmentHeader20, time::Number, index::Int)

normalise_time(head::SPKSegmentHeader8, time::Number, index::Int)

Returned a normalised time that starts at 1 at the beginning of the interval.

parse_daf_comment(array::Vector{UInt8}, header::DAFHeader)

Retrieve the comment section of a binary DAF.

References

• DAF Required Reading

See Also

See also DAF, DAFHeader and parse_daf_summaries

parse_daf_summaries(array::Vector{UInt8}, head::DAFHeader)

Parse the DAF binary content and retrieve all the summary records.

References

• DAF Required Reading

See Also

See also DAF, DAFHeader and parse_daf_comment

parse_pck_segment_descriptor(summary::Vector{UInt8}, lend::Bool)

Create a DAFSegmentDescriptor object by parsing a binary PCK segment descriptor. A default value of -1 is used to fill the reference frame field. The target and center fields are used for the actual target and center axes.

References

• PCK Required Reading

parse_spk_segment_descriptor(summary::Vector{UInt8}, lend::Bool)

Create a DAFSegmentDescriptor object by parsing a binary SPK segment descriptor.

References

• SPK Required Reading

pck_links(eph::EphemerisProvider)

Return the SPKLinkTable for the PCK segments.

propagate_twobody(cache::TwoBodyUniversalCache, Δt::Number)

Propagate the state vector in cache of Δt using the universal variables formulation for Kepler's Equation and the Lagrange coefficients f and g.

References

• SPICE Toolkit

reset_indexes!(cache::SPKSegmentCache18)

Reset the cache indexes to force the coefficients reload.

reverse_link(link::SPKLink)

Reverse the sign, i.e. change the sign of the multiplicative factor, of the link.

get_segment_list(daf::DAF)

Return the Ephemerides.SPKSegmentList list of segments stored in the DAF.

segment_type(desc::DAFSegmentDescriptor)

Return the SPK/PCK segment type.

spk_field(spk::AbstractSPKSegment)

Return the field number in the Ephemerides.SPKSegmentList associated to the given SPK segment type.

spk_links(eph::EphemerisProvider)

Return the [SPKLinkTable] for the SPK segments.

stumpff(x::Number, p::AbstractVector)

Compute Stumpff's functions from C₀ up to C₃ at x.

References

• SPICE Toolkit

summary_size(head::DAFHeader)

Compute the size of a single summary record of a DAF file, in bytes.

target(desc::DAFSegmentDescriptor)

Return the NAIF integer code for the target object or axes for SPK and PCK, respectively.

update_cache!(c::TwoBodyUniversalCache)

Update the precomputed values in the cache using the position and velocity in c.

update_header!(head::SPKSegmentHeader18, daf::DAF, iaa, faa, type)

Update the header of type 18 segments.

∂chebyshev(cache::InterpCache, cₖ, t::Number, idx::Int, N::Int, Δt, ibuff=1)

Evaluate a sum of Cheybyshev polynomials of the first kind and its derivative at t using a recursive algorithm. It simultenously evalutes the 3 state components. idx is the index of the starting row (in 0-based notation) in the matrix of coefficients cₖ. ibuff is the index of the first free buffer.

See Also

See also chebyshev, ∂²chebyshev and ∂³chebyshev

∂hermite(cache::InterpCache, states, epochs, x, idx::Int, N::Int)

Evalute a Hermite polynomial and its derivative at x using a recursive algorithm. This function handles unequally-spaced polynomials, where the coefficients in states are interpolated at epochs.

∂hermite(cache::InterpCache, states, x, idx::Int, N::Int, Δt::Number)

Evalute a Hermite polynomial and its derivative at x using a recursive algorithm. This function is valid only for equally-spaced polynomials. idx is the index of the desired state, N is the number of coefficients of the polynomial and Δt is the length of the polynomial interval.

See Also

See also hermite, ∂²hermite and ∂³hermite.

∂lagrange(cache::InterpCache, states, epochs, x, idx::Int, N::Int)

Recursively evaluate a Lagrange polynomial and its derivative at x by using Neville's algorithm. This function handles unequally-spaced polynomials, where the coefficients in states are interpolated at epochs.

∂lagrange(cache::InterpCache, states, x, idx::Int, N::Int, Δt::Number)

Recursively evaluate a Lagrange polynomial and its derivative at x by using Neville's algorithm. This function is valid only for equally-spaced polynomials. idx is the index of the desired state, N is the number of coefficients of the polynomial and Δtis the length of the polynomial interval

See Also

See also lagrange and ∂²lagrange

∂²chebyshev(cache::InterpCache, cₖ, t::Number, idx::Int, N::Int, Δt, ibuff=1)

Evaluate a sum of Cheybyshev polynomials of the first kind and its two derivatives at t using a recursive algorithm. It simultenously evalutes the 3 state components. idx is the index of the starting row (in 0-based notation) in the matrix of coefficients cₖ. ibuff is the index of the first free buffer.

See Also

See also chebyshev, ∂chebyshev and ∂³chebyshev

∂²hermite(cache::InterpCache, states, epochs, x, idx::Int, N::Int)

Evalute a Hermite polynomial and its two derivatives at x using a recursive algorithm. This function handles unequally-spaced polynomials, where the coefficients in states are interpolated at epochs.

∂²hermite(cache::InterpCache, states, x, idx::Int, N::Int, Δt::Number)

Evalute a Hermite polynomial and its two derivatives at x using a recursive algorithm. This function is valid only for equally-spaced polynomials. idx is the index of the desired state, N is the number of coefficients of the polynomial and Δt is the length of the polynomial interval.

See Also

See also hermite, ∂hermite and ∂³hermite.

∂²lagrange(cache::InterpCache, states, epochs, x, idx::Int, N::Int)

Recursively evaluate a Lagrange polynomial and its two derivatives at x by using Neville's algorithm. This function handles unequally-spaced polynomials, where the coefficients in states are interpolated at epochs.

See Also

See also lagrange and ∂lagrange

∂²lagrange(cache::InterpCache, states, x, idx::Int, N::Int, Δt::Number)

Recursively evaluate a Lagrange polynomial and its two derivatives at x by using Neville's algorithm. This function is valid only for equally-spaced polynomials. idx is the index of the desired state, N is the number of coefficients of the polynomial and Δtis the length of the polynomial interval

See Also

See also lagrange and ∂lagrange

∂³chebyshev(cache::InterpCache, cₖ, t::Number, idx::Int, N::Int, Δt, ibuff=1)

Evaluate a sum of Cheybyshev polynomials of the first kind and its three derivatives at t using a recursive algorithm. It simultenously evalutes the 3 state components. idx is the index of the starting row (in 0-based notation) in the matrix of coefficients cₖ. ibuff is the index of the first free buffer.

See Also

See also chebyshev, ∂chebyshev and ∂²chebyshev

∂³hermite(cache::InterpCache, states, epochs, x, idx::Int, N::Int)

Evalute a Hermite polynomial and its three derivatives at x using a recursive algorithm. This function handles unequally-spaced polynomials, where the coefficients in states are interpolated at epochs.

∂³hermite(cache::InterpCache, states, x, idx::Int, N::Int, Δt::Number)

Evalute a Hermite polynomial and its three derivatives at x using a recursive algorithm. This function is valid only for equally-spaced polynomials. idx is the index of the desired state, N is the number of coefficients of the polynomial and Δt is the length of the polynomial interval.

See Also

See also hermite, ∂hermite and ∂²hermite.

∫chebyshev(cache::InterpCache, cₖ, t::Number, N::Int, Δt, tlen, p₀)

Evaluate the integral of a sum of Cheybyshev polynomials of the first kind using a recursive algorithm. It simultenously evalutes the 3 state components. This function simultaneously computes both the Chebyshev polynomials as well as their integrals.

∫chebyshev(cache::InterpCache, cₖ, t::Number, N::Int, Δt, tlen, p₀)

Evaluate the integral of a sum of Cheybyshev polynomials of the first kind using a recursive algorithm. It simultenously evalutes the 3 state components. It assumes the Chebyshev polynomials up to degree N have already been computed and are stored in the buffer with index ibuff. tlen is the size of the record interval, Δt is the timescale factor, and p₀ is a vector containing the position coefficients at the midpoint (i.e., when the integral is evaluated at t = 0).