astronoby 0.9.0 → 0.10.0

data/lib/astronoby/observer.rb

@@ -10,15 +10,26 @@ module Astronoby
     MOLAR_MASS_OF_AIR = 0.0289644
     UNIVERSAL_GAS_CONSTANT = 8.31432
 
-    attr_reader :latitude,
-      :longitude,
-      :elevation,
-      :utc_offset,
-      :temperature,
-      :pressure
-
-    # @param latitude [Angle] geographic latitude of the observer
-    # @param longitude [Angle] geographic longitude of the observer
+    # @return [Astronoby::Angle] geographic latitude
+    attr_reader :latitude
+
+    # @return [Astronoby::Angle] geographic longitude
+    attr_reader :longitude
+
+    # @return [Astronoby::Distance] geographic elevation above sea level
+    attr_reader :elevation
+
+    # @return [Numeric, String] offset from Coordinated Universal Time
+    attr_reader :utc_offset
+
+    # @return [Numeric] temperature in kelvins
+    attr_reader :temperature
+
+    # @return [Numeric] atmospheric pressure in millibars
+    attr_reader :pressure
+
+    # @param latitude [Astronoby::Angle] geographic latitude of the observer
+    # @param longitude [Astronoby::Angle] geographic longitude of the observer
     # @param elevation [Astronoby::Distance] geographic elevation (or altitude)
     #   of the observer above sea level
     # @param utc_offset [Numeric, String] offset from Coordinated Universal Time
@@ -42,45 +53,44 @@ module Astronoby
       @pressure = pressure || compute_pressure
     end
 
+    # Returns the observer's ECEF position vector (WGS-84 geodetic to ECEF).
+    #
+    # @return [Astronoby::Vector<Astronoby::Distance>] geocentric position
     def geocentric_position
-      n = earth_prime_vertical_radius_of_curvature
-      x = (n + @elevation.m) * @latitude.cos * @longitude.cos
-      y = (n + @elevation.m) * @latitude.cos * @longitude.sin
-      z = (n * (1 - Constants::WGS84_ECCENTICITY_SQUARED) + @elevation.m) *
-        @latitude.sin
-      Distance.vector_from_meters([x, y, z])
+      @geocentric_position ||= begin
+        n = earth_prime_vertical_radius_of_curvature
+        x = (n + @elevation.m) * @latitude.cos * @longitude.cos
+        y = (n + @elevation.m) * @latitude.cos * @longitude.sin
+        z = (n * (1 - Constants::WGS84_ECCENTICITY_SQUARED) + @elevation.m) *
+          @latitude.sin
+        Distance.vector_from_meters([x, y, z])
+      end
     end
 
+    # Returns the observer's ECEF velocity vector due to Earth rotation.
+    #
+    # @return [Astronoby::Vector<Astronoby::Velocity>] geocentric velocity
     def geocentric_velocity
-      r = projected_radius
-      vx = -Constants::EARTH_ANGULAR_VELOCITY_RAD_PER_S * r * @longitude.sin
-      vy = Constants::EARTH_ANGULAR_VELOCITY_RAD_PER_S * r * @longitude.cos
-      vz = 0.0
-      Velocity.vector_from_mps([vx, vy, vz])
+      @geocentric_velocity ||= begin
+        r = projected_radius
+        vx = -Constants::EARTH_ANGULAR_VELOCITY_RAD_PER_S * r * @longitude.sin
+        vy = Constants::EARTH_ANGULAR_VELOCITY_RAD_PER_S * r * @longitude.cos
+        vz = 0.0
+        Velocity.vector_from_mps([vx, vy, vz])
+      end
     end
 
+    # Computes the Earth-fixed rotation matrix R₃(GAST) * W (polar motion)
+    # for a given instant.
+    #
+    # @param instant [Astronoby::Instant] the time instant
+    # @return [Matrix] 3x3 rotation matrix
     def earth_fixed_rotation_matrix_for(instant)
-      dpsi = Nutation.new(instant: instant).nutation_in_longitude
-
-      mean_obliquity = MeanObliquity.at(instant)
-
-      gast = Angle.from_radians(
-        Angle.from_hours(instant.gmst).radians +
-          dpsi.radians * mean_obliquity.cos
-      )
-
-      earth_rotation_matrix = Matrix[
-        [gast.cos, -gast.sin, 0],
-        [gast.sin, gast.cos, 0],
-        [0, 0, 1]
-      ]
-
-      nutation_matrix = Nutation.matrix_for(instant)
-      precession_matrix = Precession.matrix_for(instant)
-
-      earth_rotation_matrix * nutation_matrix * precession_matrix
+      EarthRotation.matrix_for(instant) * polar_motion_matrix_for(instant)
     end
 
+    # @param other [Astronoby::Observer] observer to compare with
+    # @return [Boolean] true if all attributes are equal
     def ==(other)
       return false unless other.is_a?(self.class)
 
@@ -93,6 +103,7 @@ module Astronoby
     end
     alias_method :eql?, :==
 
+    # @return [Integer] hash value
     def hash
       [
         self.class,
@@ -107,7 +118,6 @@ module Astronoby
 
     private
 
-    # @return [Float] the atmospheric pressure in millibars.
     def compute_pressure
       @pressure ||= PRESSURE_AT_SEA_LEVEL * pressure_ratio
     end
@@ -124,20 +134,28 @@ module Astronoby
       Math.exp(-term1 / term2)
     end
 
+    def polar_motion_matrix_for(instant)
+      rows = IERS::PolarMotion.rotation_matrix_at(instant.to_time)
+      Matrix[*rows]
+    rescue IERS::OutOfRangeError
+      Matrix.identity(3)
+    end
+
     def earth_prime_vertical_radius_of_curvature
-      Constants::WGS84_EARTH_EQUATORIAL_RADIUS_IN_METERS./(
-        Math.sqrt(
-          1 -
-            Constants::WGS84_ECCENTICITY_SQUARED * @latitude.sin * @latitude.sin
+      @earth_prime_vertical_radius_of_curvature ||=
+        Constants::WGS84_EARTH_EQUATORIAL_RADIUS_IN_METERS./(
+          Math.sqrt(
+            1 -
+              Constants::WGS84_ECCENTICITY_SQUARED * @latitude.sin * @latitude.sin
+          )
         )
-      )
     end
 
     def projected_radius
-      Math.sqrt(
-        geocentric_position.x.m * geocentric_position.x.m +
-          geocentric_position.y.m * geocentric_position.y.m
-      )
+      @projected_radius ||= begin
+        pos = geocentric_position
+        Math.sqrt(pos.x.m * pos.x.m + pos.y.m * pos.y.m)
+      end
     end
   end
 end

data/lib/astronoby/orientation.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "ephem"
+require "matrix"
+
+module Astronoby
+  # Wraps a binary PCK lunar orientation kernel (for example
+  # +moon_pa_de440_200625.bpc+) and exposes the rotation from the inertial frame
+  # (J2000/ICRF) to the Moon's mean-Earth (ME) body-fixed frame at a given
+  # instant.
+  #
+  # A binary kernel only provides the principal-axis (PA) orientation, and which
+  # PA frame it describes is read from the kernel itself. JPL Horizons and IMCCE
+  # report selenographic positions in the mean-Earth frame, whose small fixed
+  # offset from the principal axes is published in the NAIF lunar frame kernels
+  # (the +moon_*.tf+ files) rather than in the binary kernel. That alignment is
+  # essentially constant across ephemeris versions (below 0.15 arcsecond), so
+  # the DE440 values are applied here.
+  class Orientation
+    # Principal-axis to mean-Earth alignment from the NAIF DE440 lunar frame
+    # kernel (moon_de440_250416.tf): the rotation angles about the z, y and x
+    # axes that align the principal-axis frame with the mean-Earth frame.
+    MEAN_EARTH_ALIGNMENT = [
+      Angle.from_degree_arcseconds(67.8526),
+      Angle.from_degree_arcseconds(78.6944),
+      Angle.from_degree_arcseconds(0.2785)
+    ].freeze
+
+    # Download a binary PCK orientation kernel.
+    #
+    # @param name [String] kernel name supported by the Ephem gem
+    # @param target [String] destination path
+    # @return [Boolean] true if the download was successful
+    def self.download(name:, target:)
+      ::Ephem::Download.call(name: name, target: target)
+    end
+
+    # Load a binary PCK orientation kernel.
+    #
+    # @param target [String] path to the +.bpc+ file
+    # @return [Astronoby::Orientation]
+    # @raise [Astronoby::OrientationError] if the kernel has no orientation data
+    def self.load(target)
+      new(::Ephem::PCK.open(target))
+    end
+
+    # @param pck [::Ephem::PCK] an opened binary PCK
+    def initialize(pck)
+      @pck = pck
+      @source = orientation_source
+      @mean_earth_rotation = mean_earth_rotation
+      @start_jd = @pck.segments.map(&:start_jd).min
+      @end_jd = @pck.segments.map(&:end_jd).max
+    end
+
+    # Rotation from the inertial frame (J2000/ICRF) to the Moon's mean-Earth
+    # body-fixed frame.
+    #
+    # @param instant [Astronoby::Instant] the time instant
+    # @return [Matrix] a 3x3 rotation matrix
+    # @raise [Astronoby::OrientationOutOfRangeError] if the kernel does not
+    #   cover the instant
+    def rotation_for(instant)
+      @mean_earth_rotation * principal_axis_rotation(instant)
+    end
+
+    # @return [void]
+    def close
+      @pck.close
+    end
+
+    private
+
+    # The orientation source for the body frame the kernel describes, read from
+    # the kernel rather than assumed.
+    def orientation_source
+      segment = @pck.segments.first
+      raise OrientationError, "Orientation kernel has no segments" unless segment
+
+      @pck[segment.target]
+    end
+
+    # Inertial -> principal-axis rotation from the binary kernel's Euler angles.
+    def principal_axis_rotation(instant)
+      terrestrial_time = instant.terrestrial_time
+      unless terrestrial_time.between?(@start_jd, @end_jd)
+        raise OrientationOutOfRangeError,
+          "Orientation kernel covers #{date(@start_jd)} to #{date(@end_jd)}; " \
+          "requested #{date(terrestrial_time)}"
+      end
+
+      Matrix[*@source.matrix_at(terrestrial_time)]
+    end
+
+    # Principal-axis -> mean-Earth rotation (constant), about the x, y, z axes.
+    def mean_earth_rotation
+      about_z, about_y, about_x = MEAN_EARTH_ALIGNMENT
+      Rotation.about_x(-about_x) *
+        Rotation.about_y(-about_y) *
+        Rotation.about_z(-about_z)
+    end
+
+    def date(terrestrial_time)
+      Instant.from_terrestrial_time(terrestrial_time).to_time.utc.to_date
+    end
+  end
+end

data/lib/astronoby/position.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Astronoby
+  module Position
+    # @param observer [Astronoby::Observer] the observer
+    # @return [Astronoby::Topocentric] the topocentric reference frame
+    def observed_by(observer)
+      Topocentric.build_from_apparent(
+        apparent: apparent,
+        observer: observer,
+        instant: instant,
+        target_body: body
+      )
+    end
+  end
+end

data/lib/astronoby/precession.rb

@@ -1,88 +1,89 @@
 # frozen_string_literal: true
 
 module Astronoby
+  # Computes precession matrices using the IAU 2006 Fukushima-Williams
+  # angles with ICRS frame bias. Also provides coordinate precession
+  # using the classical method.
   class Precession
+    # Computes the combined precession-bias matrix for a given instant.
+    #
+    # @param instant [Astronoby::Instant] the time instant
+    # @return [Matrix] the 3x3 precession-bias matrix PB(t)
     def self.matrix_for(instant)
       new(instant: instant).matrix
     end
 
+    # @param instant [Astronoby::Instant] the time instant
     def initialize(instant:)
       @instant = instant
     end
 
+    # Computes the combined precession-bias matrix PB(t) = R1(-εA) R3(-ψ̄) R1(φ̄) R3(γ̄)
+    #
+    # @return [Matrix] the 3x3 precession-bias matrix
     def matrix
+      # Fukushima-Williams precession angles including frame bias.
       # Source:
-      #  IAU resolution in 2006 in favor of the P03 astronomical model
-      #  https://syrte.obspm.fr/iau2006/aa03_412_P03.pdf
-      # P(t) = R3(χA) R1(−ωA) R3(−ψA) R1(ϵ0)
+      #  IERS Conventions 2010, Section 5.6.4
+      #  Wallace & Capitaine (2006), A&A 459, 981
+      #  ERFA eraPfw06 / eraFw2m
+      # PB(t) = R1(−εA) R3(−ψ̄) R1(φ̄) R3(γ̄)
 
       cache.fetch(cache_key) do
-        # Precession in right ascension
-        psi_a = ((((
-            -0.0000000951 * t +
-            +0.000132851) * t +
-            -0.00114045) * t +
-            -1.0790069) * t +
-            +5038.481507) * t
-
-        # Precession in declination
-        omega_a = ((((
-          +0.0000003337 * t +
-          -0.000000467) * t +
-          -0.00772503) * t +
-          +0.0512623) * t +
-          -0.025754) * t +
-          eps0
-
-        # Precession of the ecliptic
-        chi_a = ((((
-          -0.0000000560 * t +
-          +0.000170663) * t +
-          -0.00121197) * t +
-          -2.3814292) * t +
-          +10.556403) * t
-
-        psi_a = Angle.from_degree_arcseconds(psi_a)
-        omega_a = Angle.from_degree_arcseconds(omega_a)
-        chi_a = Angle.from_degree_arcseconds(chi_a)
-
-        r3_psi = rotation_z(-psi_a)
-        r1_omega = rotation_x(-omega_a)
-        r3_chi = rotation_z(chi_a)
-        r1_eps0 = rotation_x(MeanObliquity.obliquity_of_reference)
-
-        r3_chi * r1_omega * r3_psi * r1_eps0
+        gamma_bar = ((((
+          +0.0000000260 * t +
+          -0.000002788) * t +
+          -0.00031238) * t +
+          +0.4932044) * t +
+          +10.556378) * t +
+          -0.052928
+
+        phi_bar = ((((
+          -0.0000000176 * t +
+          -0.000000440) * t +
+          +0.00053289) * t +
+          +0.0511268) * t +
+          -46.811016) * t +
+          +84381.412819
+
+        psi_bar = ((((
+          -0.0000000148 * t +
+          -0.000026452) * t +
+          -0.00018522) * t +
+          +1.5584175) * t +
+          +5038.481484) * t +
+          -0.041775
+
+        gamma_bar = Angle.from_degree_arcseconds(gamma_bar)
+        phi_bar = Angle.from_degree_arcseconds(phi_bar)
+        psi_bar = Angle.from_degree_arcseconds(psi_bar)
+        eps_a = MeanObliquity.at(@instant)
+
+        Rotation.about_x(-eps_a) * Rotation.about_z(-psi_bar) *
+          Rotation.about_x(phi_bar) * Rotation.about_z(gamma_bar)
       end
     end
 
-    def rotation_x(angle)
-      c, s = angle.cos, angle.sin
-      Matrix[
-        [1, 0, 0],
-        [0, c, s],
-        [0, -s, c]
-      ]
-    end
-
-    def rotation_z(angle)
-      c, s = angle.cos, angle.sin
-      Matrix[
-        [c, s, 0],
-        [-s, c, 0],
-        [0, 0, 1]
-      ]
-    end
-
     # Source:
     #  Title: Practical Astronomy with your Calculator or Spreadsheet
     #  Authors: Peter Duffett-Smith and Jonathan Zwart
     #  Edition: Cambridge University Press
     #  Chapter: 34 - Precession
 
+    # Precesses equatorial coordinates from their current epoch to a new epoch.
+    #
+    # @param coordinates [Astronoby::Coordinates::Equatorial] coordinates to
+    #   precess
+    # @param epoch [Numeric] the target Julian Date epoch
+    # @return [Astronoby::Coordinates::Equatorial] precessed coordinates
     def self.for_equatorial_coordinates(coordinates:, epoch:)
       precess(coordinates, epoch)
     end
 
+    # @param coordinates [Astronoby::Coordinates::Equatorial] coordinates to
+    #   precess
+    # @param epoch [Numeric] the target Julian Date epoch
+    # @return [Astronoby::Coordinates::Equatorial] precessed coordinates
     def self.precess(coordinates, epoch)
       matrix_a = matrix_for_epoch(coordinates.epoch)
       matrix_b = matrix_for_epoch(epoch).transpose
@@ -107,6 +108,10 @@ module Astronoby
       )
     end
 
+    # Computes the classical precession matrix for a given epoch.
+    #
+    # @param epoch [Numeric] a Julian Date epoch
+    # @return [Matrix] 3x3 precession matrix
     def self.matrix_for_epoch(epoch)
       t = (epoch - JulianDate::DEFAULT_EPOCH) / Constants::DAYS_PER_JULIAN_CENTURY
 
@@ -162,9 +167,5 @@ module Astronoby
         Constants::DAYS_PER_JULIAN_CENTURY
       )
     end
-
-    def eps0
-      @eps0 ||= MeanObliquity.obliquity_of_reference_in_arcseconds
-    end
   end
 end

data/lib/astronoby/reference_frame.rb

@@ -1,27 +1,46 @@
 # frozen_string_literal: true
 
 module Astronoby
+  # Base class for reference frames in the astronomical reference frame chain.
+  # Each frame represents a body's position and velocity relative to a center,
+  # at a specific instant.
   class ReferenceFrame
-    attr_reader :position,
-      :velocity,
-      :instant,
-      :center_identifier,
-      :target_body
+    # @return [Astronoby::Vector<Astronoby::Distance>] position vector
+    attr_reader :position
 
+    # @return [Astronoby::Vector<Astronoby::Velocity>] velocity vector
+    attr_reader :velocity
+
+    # @return [Astronoby::Instant] the time instant
+    attr_reader :instant
+
+    # @return [Astronoby::Center] the center of the frame
+    attr_reader :center
+
+    # @return [Astronoby::Body, nil] the target body
+    attr_reader :target_body
+
+    # @param position [Astronoby::Vector<Astronoby::Distance>] position vector
+    # @param velocity [Astronoby::Vector<Astronoby::Velocity>] velocity vector
+    # @param instant [Astronoby::Instant] the time instant
+    # @param center [Astronoby::Center] the center of the frame
+    # @param target_body [Astronoby::Body, nil] the target body
     def initialize(
       position:,
       velocity:,
       instant:,
-      center_identifier:,
+      center:,
       target_body:
     )
       @position = position
       @velocity = velocity
       @instant = instant
-      @center_identifier = center_identifier
+      @center = center
       @target_body = target_body
     end
 
+    # @return [Astronoby::Coordinates::Equatorial] equatorial coordinates
+    #   derived from the position vector
     def equatorial
       @equatorial ||= begin
         return Coordinates::Equatorial.zero if distance.zero?
@@ -30,6 +49,8 @@ module Astronoby
       end
     end
 
+    # @return [Astronoby::Coordinates::Ecliptic] ecliptic coordinates derived
+    #   from the equatorial coordinates at J2000.0
     def ecliptic
       @ecliptic ||= begin
         return Coordinates::Ecliptic.zero if distance.zero?
@@ -39,6 +60,7 @@ module Astronoby
       end
     end
 
+    # @return [Astronoby::Distance] the Euclidean distance from the center
     def distance
       @distance ||= begin
         return Distance.zero if @position.zero?
@@ -46,5 +68,49 @@ module Astronoby
         @position.magnitude
       end
     end
+
+    # @param other [Astronoby::ReferenceFrame] another frame at the same stage
+    #   and instant
+    # @return [Astronoby::Angle] the angular separation, between 0° and 180°
+    # @raise [Astronoby::IncompatibleArgumentsError] if the frames cannot be
+    #   meaningfully compared
+    def separation_from(other)
+      ensure_comparable!(other)
+      return Angle.zero if @position.zero? || other.position.zero?
+
+      position_vector = @position.map(&:m)
+      other_position_vector = other.position.map(&:m)
+      cross = Util::Maths.cross_product(position_vector, other_position_vector)
+      cross_magnitude = Math.sqrt(Util::Maths.dot_product(cross, cross))
+      dot = Util::Maths.dot_product(position_vector, other_position_vector)
+
+      Angle.from_radians(Math.atan2(cross_magnitude, dot))
+    end
+
+    private
+
+    def ensure_comparable!(other)
+      unless other.is_a?(ReferenceFrame)
+        raise IncompatibleArgumentsError,
+          "Expected an Astronoby::ReferenceFrame, got #{other.class}"
+      end
+
+      unless instance_of?(other.class)
+        raise IncompatibleArgumentsError,
+          "Cannot compute the separation between different reference frames " \
+          "(#{self.class} and #{other.class}); both frames must be at the " \
+          "same stage of the reference frame chain"
+      end
+
+      unless instant == other.instant
+        raise IncompatibleArgumentsError,
+          "Cannot compute the separation between frames at different instants"
+      end
+
+      unless center == other.center
+        raise IncompatibleArgumentsError,
+          "Cannot compute the separation between frames with different centers"
+      end
+    end
   end
 end

data/lib/astronoby/reference_frames/apparent.rb

@@ -1,7 +1,19 @@
 # frozen_string_literal: true
 
 module Astronoby
+  # Apparent reference frame. Represents a body's geocentric position as it
+  # appears from Earth, corrected for aberration, precession, and nutation.
   class Apparent < ReferenceFrame
+    # Builds an apparent frame from an astrometric frame by applying
+    # aberration in GCRS, then rotating by nutation * precession (with ICRS
+    # frame bias).
+    #
+    # @param instant [Astronoby::Instant] the time instant
+    # @param target_astrometric [Astronoby::Astrometric] target's astrometric
+    #   frame
+    # @param earth_geometric [Astronoby::Geometric] Earth's geometric frame
+    # @param target_body [Astronoby::Body, nil] the target body
+    # @return [Astronoby::Apparent] a new apparent frame
     def self.build_from_astrometric(
       instant:,
       target_astrometric:,
@@ -13,37 +25,44 @@ module Astronoby
       precession_matrix = Precession.matrix_for(instant)
       nutation_matrix = Nutation.matrix_for(instant)
 
-      corrected_position = Distance.vector_from_meters(
-        precession_matrix * nutation_matrix * position.map(&:m)
-      )
       corrected_position = Aberration.new(
-        astrometric_position: corrected_position,
+        astrometric_position: position,
         observer_velocity: earth_geometric.velocity
       ).corrected_position
+
       # In theory, here we should also apply light deflection. However, so far
       # the deflection algorithm hasn't shown any significant changes to the
       # apparent position. Therefore, for now, we are saving some computation
       # time by not applying it, and we will investigate if the algorithm is
       # correct or if the deflection is indeed negligible.
 
+      corrected_position = Distance.vector_from_meters(
+        nutation_matrix * precession_matrix * corrected_position.map(&:m)
+      )
+
       corrected_velocity = Velocity.vector_from_mps(
-        precession_matrix * nutation_matrix * velocity.map(&:mps)
+        nutation_matrix * precession_matrix * velocity.map(&:mps)
       )
 
       new(
         position: corrected_position,
         velocity: corrected_velocity,
         instant: instant,
-        center_identifier: SolarSystemBody::EARTH,
+        center: Center.geocentric,
         target_body: target_body
       )
     end
 
+    # @return [Astronoby::Coordinates::Ecliptic] ecliptic coordinates at the
+    #   current instant (true ecliptic and equinox of date)
     def ecliptic
       @ecliptic ||= begin
         return Coordinates::Ecliptic.zero if distance.zero?
 
-        equatorial.to_ecliptic(instant: @instant)
+        equatorial.to_ecliptic(
+          instant: @instant,
+          obliquity: TrueObliquity.at(@instant)
+        )
       end
     end
   end

data/lib/astronoby/reference_frames/astrometric.rb

@@ -1,7 +1,20 @@
 # frozen_string_literal: true
 
 module Astronoby
+  # Astrometric reference frame (GCRS). Represents a body's position relative
+  # to the Earth, corrected for light-time delay.
   class Astrometric < ReferenceFrame
+    # Builds an astrometric frame from geometric frames with light-time
+    # correction.
+    #
+    # @param instant [Astronoby::Instant] the time instant
+    # @param earth_geometric [Astronoby::Geometric] Earth's geometric frame
+    # @param light_time_corrected_position [Astronoby::Vector<Astronoby::Distance>]
+    #   target position corrected for light-time delay
+    # @param light_time_corrected_velocity [Astronoby::Vector<Astronoby::Velocity>]
+    #   target velocity corrected for light-time delay
+    # @param target_body [Astronoby::Body, nil] the target body
+    # @return [Astronoby::Astrometric] a new astrometric frame
     def self.build_from_geometric(
       instant:,
       earth_geometric:,
@@ -13,7 +26,7 @@ module Astronoby
         position: light_time_corrected_position - earth_geometric.position,
         velocity: light_time_corrected_velocity - earth_geometric.velocity,
         instant: instant,
-        center_identifier: SolarSystemBody::EARTH,
+        center: Center.geocentric,
         target_body: target_body
       )
     end