Low-level API

daf(eph::EphemerisProvider)

Return the DAF files stored in the ephemeris provider.

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

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

spk_links(eph::EphemerisProvider)

Return the [SPKLinkTable] for the SPK segments.

pck_links(eph::EphemerisProvider)

Return the SPKLinkTable for the PCK 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

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.

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.

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.

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.

filename(head::DAFHeader)

Return the internal description of the DAF.

summary_size(head::DAFHeader)

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

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

segment_type(desc::DAFSegmentDescriptor)

Return the SPK/PCK segment type.

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

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

center(desc::DAFSegmentDescriptor)

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

target(desc::DAFSegmentDescriptor)

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

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.

initial_address(desc::DAFSegmentDescriptor)

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

final_address(desc::DAFSegmentDescriptor)

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

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.

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

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

References

• SPK Required Reading

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

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_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

get_comment(daf::DAF)

Return the comment written in the DAF comment section.

header(spk::AbstractSPKSegment)

Return the segment header.

get_header(daf::DAF)

Return the DAFHeader header of the DAF.

get_array(daf::DAF)

Return the byte content of the DAF file.

get_descriptors(daf::DAF)

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

get_segment_list(daf::DAF)

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

filepath(daf::DAF)

Return the system path of the DAF.

is_spk(daf::DAF)

Return true if the DAF stores SPK data.

is_pck(daf::DAF)

Return true if the DAF stores PCK data.

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

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

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

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

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

Retrieve a whole DAF record at position index.

is_little_endian(array::Vector{UInt8})

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

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

descriptor(link::SPKLink)

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

file_id(link::SPKLink)

Return the DAF file index.

list_id(link::SPKLink)

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

element_id(link::SPKLink)

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

factor(link::SPKLink)

Return the direction multiplicative factor.

reverse_link(link::SPKLink)

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

create_linktables(dafs::Vector{DAF})

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

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.

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!

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

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

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

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

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.

AbstractSPKHeader

Abstract type for all SPK segment type headers.

AbstractSPKCache

Abstract type for all SPK segment type caches.

AbstractSPKSegment

Abstract type for all SPK segment types.

cache(spk::AbstractSPKSegment)

Return the segment cache data.

spk_field(spk::AbstractSPKSegment)

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

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)

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.

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

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

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

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

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

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

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

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.

SPKSegmentType5 <: AbstractSPKSegment

Segment instance for SPK segments of type 5.

Fields

• head – Segment header
• cache – Segment cache

References

• SPK Required Reading
• SPICE Toolkit

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)

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.

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

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)

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.

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

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

SPKSegmentType14 <: AbstractSPKSegment

Segment instance for SPK segments of type 14.

Fields

• head – Segment header
• cache – Segment cache

References

• SPK Required Reading
• SPICE Toolkit

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

SPKSegmentType15 <: AbstractSPKSegment

Segment instance for SPK segments of type 15.

Fields

• head – Segment header
• cache – Segment cache

References

• SPK Required Reading
• SPICE Toolkit

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

SPKSegmentType17 <: AbstractSPKSegment

Segment instance for SPK segments of type 17.

Fields

• head – Segment header

References

• SPK Required Reading
• SPICE Toolkit

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)

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.

reset_indexes!(cache::SPKSegmentCache18)

Reset the cache indexes to force the coefficients reload.

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

Update the header of type 18 segments.

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.

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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(head::SPKSegmentHeader20, time::Number)

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

get_coefficients!(daf::DAF, head::SPKSegmentHeader2, cache::SPKSegmentCache2, 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)

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::SPKSegmentHeader20, cache::SPKSegmentCache20, index::Int)

InterpCache{T}

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

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

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

∂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

∂²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

∂³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

∫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).

∫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.

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.

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, Δ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

∂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 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

∂²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

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.

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 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.

∂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 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.

∂²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 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.

∂³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.

AbstractEphemRecord

Abstract type for ephemeris segment records.

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

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

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.

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.

update_cache!(c::TwoBodyUniversalCache)

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

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

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

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

References

• SPICE Toolkit