ephem 0.4.1 → 0.5.0

data/lib/ephem/segments/chebyshev_type2.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Ephem
+  module Segments
+    # Shared evaluation machinery for DAF "type 2" Chebyshev segments.
+    module ChebyshevType2
+      include Core::Constants
+
+      # @return [void]
+      def clear_data
+        @data_lock.synchronize do
+          @data_loaded = false
+          @midpoints = nil
+          @radii = nil
+          @coefficients = nil
+        end
+      end
+
+      private
+
+      def load_data
+        @data_lock.synchronize do
+          return if @data_loaded
+
+          process_coefficient_data(load_coefficient_data)
+
+          @data_loaded = true
+        end
+      end
+
+      def load_coefficient_data
+        metadata = @daf.read_array(@end_i - 3, @end_i)
+        _start_index, _end_index, record_size, segment_count = metadata
+
+        coefficient_count = ((record_size - 2) / component_count).to_i
+        coefficients_raw = @daf.map_array(@start_i, @end_i - 4)
+
+        [
+          coefficients_raw,
+          record_size.to_i,
+          segment_count.to_i,
+          coefficient_count
+        ]
+      end
+
+      def process_coefficient_data(data)
+        coefficients_raw, record_size, segment_count, coefficient_count = data
+
+        coefficients = coefficients_raw.each_slice(record_size).to_a
+
+        @midpoints = coefficients.map { |row| row[0] }
+        @radii = coefficients.map { |row| row[1] }
+        n_terms = coefficient_count
+        n_components = component_count
+
+        @coefficients = Array.new(segment_count) do |i|
+          row = coefficients[i][2..]
+          Array.new(n_terms) do |k|
+            Array.new(n_components) do |j|
+              row[k + j * n_terms]
+            end
+          end
+        end
+      end
+
+      def convert_to_seconds(tdb, tdb2)
+        case tdb
+        when Array
+          tdb.map { |t| time_to_seconds(t, tdb2) }
+        else
+          time_to_seconds(tdb, tdb2)
+        end
+      end
+
+      def time_to_seconds(time, offset)
+        (time - Time::J2000_EPOCH + offset) * Time::SECONDS_PER_DAY
+      end
+
+      def generate_position(tdb_seconds)
+        interval = find_interval(tdb_seconds)
+        normalized_time = compute_normalized_time(tdb_seconds, interval)
+        coeffs = @coefficients[interval]
+        Computation::ChebyshevPolynomial.evaluate(coeffs, normalized_time)
+      end
+
+      def generate_single(tdb_seconds)
+        interval = find_interval(tdb_seconds)
+        normalized_time = compute_normalized_time(tdb_seconds, interval)
+
+        coeffs = @coefficients[interval] # already [n_terms][3]
+        Computation::ChebyshevPolynomial.evaluate_with_derivative(
+          coeffs,
+          normalized_time,
+          @radii[interval]
+        )
+      end
+
+      def generate_multiple(tdb_seconds)
+        tdb_seconds.map { |time| generate_single(time) }
+      end
+
+      def find_interval(tdb_seconds)
+        left = 0
+        right = @midpoints.size - 1
+
+        if @last_interval && time_in_interval?(tdb_seconds, @last_interval)
+          return @last_interval
+        end
+
+        while left <= right
+          mid = (left + right) / 2
+          min_time = @midpoints[mid] - @radii[mid]
+          max_time = @midpoints[mid] + @radii[mid]
+
+          if tdb_seconds < min_time
+            right = mid - 1
+          elsif tdb_seconds > max_time
+            left = mid + 1
+          else
+            @last_interval = mid
+            return mid
+          end
+        end
+
+        raise OutOfRangeError.new(
+          "Time #{tdb_seconds} is outside the coverage of this segment",
+          tdb_seconds
+        )
+      end
+
+      def time_in_interval?(time, interval)
+        min_time = @midpoints[interval] - @radii[interval]
+        max_time = @midpoints[interval] + @radii[interval]
+        time.between?(min_time, max_time)
+      end
+
+      def compute_normalized_time(time_seconds, interval)
+        (time_seconds - @midpoints[interval]) / @radii[interval]
+      end
+    end
+  end
+end

data/lib/ephem/segments/orientation_group.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Ephem
+  module Segments
+    # The orientation segments for one PCK body frame. Routes each query to the
+    # segment covering the requested time. Returned by PCK#[].
+    #
+    # @see Ephem::Segments::OrientationSegment
+    class OrientationGroup < SegmentGroup
+      include OrientationSource
+
+      # @return [Integer] NAIF frame ID of the oriented body frame
+      def body
+        @segments.first.body
+      end
+
+      # @return [Integer] NAIF ID of the inertial reference frame
+      def reference_frame
+        @segments.first.reference_frame
+      end
+
+      # Euler angles at the given time, without rates. See
+      # {OrientationSegment#angles_at}.
+      #
+      # @param tdb [Numeric, Array<Numeric>] Time(s) in TDB Julian Date
+      # @param tdb2 [Numeric] Optional fractional part of TDB date
+      # @return [Core::Orientation, Array<Core::Orientation>]
+      def angles_at(tdb, tdb2 = 0.0)
+        query(tdb, tdb2) do |segment, time, fraction|
+          segment.angles_at(time, fraction)
+        end
+      end
+
+      # Euler angles and their rates at the given time. See
+      # {OrientationSegment#orientation_at}.
+      #
+      # @param tdb [Numeric, Array<Numeric>] Time(s) in TDB Julian Date
+      # @param tdb2 [Numeric] Optional fractional part of TDB date
+      # @return [Core::Orientation, Array<Core::Orientation>]
+      def orientation_at(tdb, tdb2 = 0.0)
+        query(tdb, tdb2) do |segment, time, fraction|
+          segment.orientation_at(time, fraction)
+        end
+      end
+
+      # The reference-frame to body-fixed rotation matrix at the given time.
+      # See {OrientationSegment#matrix_at}.
+      #
+      # @param tdb [Numeric, Array<Numeric>] Time(s) in TDB Julian Date
+      # @param tdb2 [Numeric] Optional fractional part of TDB date
+      # @return [Array<Array<Float>>, Array<Array<Array<Float>>>]
+      def matrix_at(tdb, tdb2 = 0.0)
+        query(tdb, tdb2) do |segment, time, fraction|
+          segment.matrix_at(time, fraction)
+        end
+      end
+    end
+  end
+end

data/lib/ephem/segments/orientation_segment.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Ephem
+  module Segments
+    # Binary PCK orientation segment (data type 2): the orientation of a body
+    # frame relative to an inertial reference frame, stored as three Euler
+    # angles in Chebyshev coefficients.
+    class OrientationSegment < BaseSegment
+      include ChebyshevType2
+      include OrientationSource
+
+      COMPONENT_COUNT = 3 # phi, theta, psi
+
+      def initialize(daf:, source:, descriptor:)
+        super
+        @data_loaded = false
+        @data_lock = Mutex.new
+      end
+
+      # @return [Integer] NAIF frame ID of the oriented body frame
+      alias_method :body, :target
+      # @return [Integer] NAIF ID of the inertial reference frame
+      alias_method :reference_frame, :center
+
+      # Euler angles at the given time, without rates.
+      #
+      # @param tdb [Numeric, Array<Numeric>] Time(s) in TDB Julian Date
+      # @param tdb2 [Numeric] Optional fractional part of TDB date
+      # @return [Core::Orientation, Array<Core::Orientation>] angles in radians
+      # @raise [Ephem::OutOfRangeError] if time is outside segment coverage
+      def angles_at(tdb, tdb2 = 0.0)
+        load_data
+        tdb_seconds = convert_to_seconds(tdb, tdb2)
+
+        case tdb_seconds
+        when Numeric
+          to_orientation(generate_position(tdb_seconds))
+        else
+          tdb_seconds.map do |seconds|
+            to_orientation(generate_position(seconds))
+          end
+        end
+      end
+
+      # Euler angles and their rates at the given time.
+      #
+      # @param tdb [Numeric, Array<Numeric>] Time(s) in TDB Julian Date
+      # @param tdb2 [Numeric] Optional fractional part of TDB date
+      # @return [Core::Orientation, Array<Core::Orientation>] angles (radians)
+      #   carrying rates (radians/day)
+      # @raise [Ephem::OutOfRangeError] if time is outside segment coverage
+      def orientation_at(tdb, tdb2 = 0.0)
+        load_data
+        tdb_seconds = convert_to_seconds(tdb, tdb2)
+
+        case tdb_seconds
+        when Numeric
+          to_orientation(*generate_single(tdb_seconds))
+        else
+          generate_multiple(tdb_seconds).map do |angles, rates|
+            to_orientation(angles, rates)
+          end
+        end
+      end
+
+      # The reference-frame to body-fixed rotation matrix at the given time,
+      # built from the 3-1-3 Euler angles. See {Core::Orientation#to_matrix}.
+      #
+      # @param tdb [Numeric, Array<Numeric>] Time(s) in TDB Julian Date
+      # @param tdb2 [Numeric] Optional fractional part of TDB date
+      # @return [Array<Array<Float>>, Array<Array<Array<Float>>>] a 3x3 matrix,
+      #   or one per time for an array input
+      # @raise [Ephem::OutOfRangeError] if time is outside segment coverage
+      def matrix_at(tdb, tdb2 = 0.0)
+        angles = angles_at(tdb, tdb2)
+        angles.is_a?(Array) ? angles.map(&:to_matrix) : angles.to_matrix
+      end
+
+      def describe(verbose: false)
+        start_date = format_date(*julian_to_gregorian(@start_jd))
+        end_date = format_date(*julian_to_gregorian(@end_jd))
+
+        description =
+          "#{start_date}..#{end_date} Type #{@data_type} orientation of " \
+          "frame #{body} relative to frame #{reference_frame}"
+        return description unless verbose
+
+        <<~DESCRIPTION.chomp
+          #{description}
+          source=#{@source}
+        DESCRIPTION
+      end
+
+      private
+
+      def parse_descriptor(descriptor)
+        @start_second,
+          @end_second,
+          @target,
+          @center,
+          @data_type,
+          @start_i,
+          @end_i = descriptor
+        @frame = @center
+      end
+
+      def component_count
+        COMPONENT_COUNT
+      end
+
+      def to_orientation(angles, rates = nil)
+        Core::Orientation.new(angles[0], angles[1], angles[2], rates: rates)
+      end
+
+      Registry.register(:pck, 2, self)
+    end
+  end
+end

data/lib/ephem/segments/orientation_source.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Ephem
+  module Segments
+    module OrientationSource
+      def compute(*)
+        raise NotImplementedError,
+          "Use #angles_at or #orientation_at for orientation kernels"
+      end
+
+      def compute_and_differentiate(*)
+        raise NotImplementedError,
+          "Use #orientation_at for orientation kernels"
+      end
+    end
+  end
+end

data/lib/ephem/segments/position_group.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Ephem
+  module Segments
+    # The position segments for one SPK center/target pair. Routes each query to
+    # the segment covering the requested time. Returned by SPK#[].
+    #
+    # @see Ephem::Segments::Segment
+    class PositionGroup < SegmentGroup
+      # @return [Integer] the center body ID
+      def center
+        @segments.first.center
+      end
+
+      # @return [Integer] the target body ID
+      def target
+        @segments.first.target
+      end
+
+      # Position at the given time. See {Segment#compute}.
+      #
+      # @param tdb [Numeric, Array<Numeric>] Time(s) in TDB Julian Date
+      # @param tdb2 [Numeric] Optional fractional part of TDB date
+      # @return [Core::Vector, Array<Core::Vector>]
+      def compute(tdb, tdb2 = 0.0)
+        query(tdb, tdb2) do |segment, time, fraction|
+          segment.compute(time, fraction)
+        end
+      end
+      alias_method :position_at, :compute
+
+      # Position and velocity at the given time. See
+      # {Segment#compute_and_differentiate}.
+      #
+      # @param tdb [Numeric, Array<Numeric>] Time(s) in TDB Julian Date
+      # @param tdb2 [Numeric] Optional fractional part of TDB date
+      # @return [Core::State, Array<Core::State>]
+      def compute_and_differentiate(tdb, tdb2 = 0.0)
+        query(tdb, tdb2) do |segment, time, fraction|
+          segment.compute_and_differentiate(time, fraction)
+        end
+      end
+      alias_method :state_at, :compute_and_differentiate
+    end
+  end
+end

data/lib/ephem/segments/registry.rb

@@ -2,9 +2,15 @@
 
 module Ephem
   module Segments
-    class Registry
-      def self.register(type, klass)
-        SPK::SEGMENT_CLASSES[type] = klass
+    module Registry
+      TABLES = {spk: {}, pck: {}}.freeze
+
+      def self.register(kind, type, klass)
+        TABLES.fetch(kind)[type] = klass
+      end
+
+      def self.lookup(kind, type, default = nil)
+        TABLES.fetch(kind).fetch(type, default)
       end
     end
   end