astronoby 0.9.0 → 0.10.0

data/lib/astronoby/bodies/moon.rb

@@ -1,11 +1,16 @@
 # frozen_string_literal: true
 
 module Astronoby
+  # Represents the Moon. Provides phase events, apoapsis/periapsis events,
+  # and phase fraction.
   class Moon < SolarSystemBody
     SEMIDIAMETER_VARIATION = 0.7275
     EQUATORIAL_RADIUS = Distance.from_meters(1_737_400)
     ABSOLUTE_MAGNITUDE = 0.28
+    ORBITAL_PERIOD = 27.504339
 
+    # @param ephem_source [Symbol] the ephemeris source type
+    # @return [Array<Array>] ephemeris segment identifiers
     def self.ephemeris_segments(ephem_source)
       if ephem_source == ::Ephem::SPK::JPL_DE
         [
@@ -33,38 +38,155 @@ module Astronoby
       Events::MoonPhases.phases_for(year: year, month: month)
     end
 
+    # @return [Float] absolute magnitude
     def self.absolute_magnitude
       ABSOLUTE_MAGNITUDE
     end
 
+    # Finds all apoapsis events between two times
+    # @param ephem [::Ephem::SPK] Ephemeris data source
+    # @param start_time [Time] Start time
+    # @param end_time [Time] End time
+    # @return [Array<Astronoby::ExtremumEvent>] Array of apoapsis events
+    def self.apoapsis_events(
+      ephem:,
+      start_time:,
+      end_time:,
+      samples_per_period: 60
+    )
+      ExtremumCalculator.new(
+        body: self,
+        primary_body: Earth,
+        ephem: ephem,
+        samples_per_period: samples_per_period
+      ).apoapsis_events_between(start_time, end_time)
+    end
+
+    # Finds all periapsis events between two times
+    # @param ephem [::Ephem::SPK] Ephemeris data source
+    # @param start_time [Time] Start time
+    # @param end_time [Time] End time
+    # @return [Array<Astronoby::ExtremumEvent>] Array of periapsis events
+    def self.periapsis_events(
+      ephem:,
+      start_time:,
+      end_time:,
+      samples_per_period: 60
+    )
+      ExtremumCalculator.new(
+        body: self,
+        primary_body: Earth,
+        ephem: ephem,
+        samples_per_period: samples_per_period
+      ).periapsis_events_between(start_time, end_time)
+    end
+
+    # Finds all lunar eclipses whose greatest instant falls between two times
+    # @param ephem [::Ephem::SPK] Ephemeris data source
+    # @param start_time [Time] Start time
+    # @param end_time [Time] End time
+    # @return [Array<Astronoby::LunarEclipse>] Lunar eclipses in the range
+    def self.eclipse_events(ephem:, start_time:, end_time:)
+      LunarEclipseCalculator
+        .new(ephem: ephem)
+        .events_between(start_time, end_time)
+    end
+
     # @return [Float] Phase fraction, from 0 to 1
     def current_phase_fraction
       mean_elongation.degrees / Constants::DEGREES_PER_CIRCLE
     end
 
-    # @return [Boolean] True if the body is approaching the primary
-    #   body (Earth), false otherwise.
-    def approaching_primary?
-      relative_position =
-        (geometric.position - @earth_geometric.position).map(&:m)
-      relative_velocity =
-        (geometric.velocity - @earth_geometric.velocity).map(&:mps)
-      radial_velocity_component = Astronoby::Util::Maths
-        .dot_product(relative_position, relative_velocity)
-      distance = Math.sqrt(
-        Astronoby::Util::Maths.dot_product(relative_position, relative_position)
-      )
-      radial_velocity_component / distance < 0
+    # Total geocentric libration of the Moon, in longitude and latitude.
+    #
+    # With an orientation kernel (see +orientation:+ on the constructor), this
+    # is the sub-Earth point from the integrated DE orientation, accurate to
+    # better than an arcsecond. Without one, it is the analytic optical plus
+    # physical libration (Meeus, Astronomical Algorithms, 2nd ed., chapter 53).
+    #
+    # @return [Astronoby::Libration] Libration in longitude and latitude
+    def libration
+      lunar_ephemeris.libration
+    end
+
+    # Position angle of the Moon's axis of rotation, measured eastward from the
+    # north point of the disk.
+    #
+    # With an orientation kernel this comes from the integrated DE orientation;
+    # without one, from the analytic series (Meeus, Astronomical Algorithms,
+    # 2nd ed., chapter 53).
+    #
+    # @return [Astronoby::Angle] Position angle of the axis
+    def position_angle_of_axis
+      lunar_ephemeris.position_angle_of_axis
     end
 
-    # @return [Boolean] True if the body is receding from the primary
-    #   body (Earth), false otherwise.
-    def receding_from_primary?
-      !approaching_primary?
+    # Position angle of the Moon's bright limb: the position angle of the
+    # midpoint of the illuminated limb, measured eastward from the north point
+    # of the disk. Geocentric, from the apparent equatorial coordinates of the
+    # Moon and the Sun.
+    #
+    # Source:
+    #  Title: Astronomical Algorithms
+    #  Author: Jean Meeus
+    #  Edition: 2nd edition
+    #  Chapter: 48 - Illuminated Fraction of the Moon's Disk
+    # @return [Astronoby::Angle, nil] Position angle of the bright limb, between
+    #   0 and 360 degrees
+    def bright_limb_position_angle
+      return unless sun
+
+      @bright_limb_position_angle ||= begin
+        angle = apparent.equatorial.position_angle_to(sun.apparent.equatorial)
+        Angle.from_degrees(angle.degrees % Constants::DEGREES_PER_CIRCLE)
+      end
+    end
+
+    # Parallactic angle of the Moon for a given observer: the angle at the Moon
+    # between the direction of the north celestial pole and the direction of
+    # the observer's zenith. Computed from the topocentric place, where lunar
+    # parallax is significant.
+    #
+    # Source:
+    #  Title: Astronomical Algorithms
+    #  Author: Jean Meeus
+    #  Edition: 2nd edition
+    #  Chapter: 14 - The Parallactic Angle
+    # @param observer [Astronoby::Observer] Observer for whom to compute the
+    #   parallactic angle
+    # @return [Astronoby::Angle] Parallactic angle
+    def parallactic_angle(observer:)
+      equatorial = observed_by(observer).equatorial
+      declination = equatorial.declination
+      hour_angle = equatorial.compute_hour_angle(
+        time: @instant.to_time,
+        longitude: observer.longitude
+      )
+
+      Angle.from_radians(
+        Math.atan2(
+          hour_angle.sin,
+          observer.latitude.tan * declination.cos -
+            declination.sin * hour_angle.cos
+        )
+      )
     end
 
     private
 
+    def lunar_ephemeris
+      @lunar_ephemeris ||=
+        if orientation
+          MoonOrientationEphemeris.new(self)
+        else
+          MoonPhysicalEphemeris.new(self)
+        end
+    end
+
+    def primary_body_geometric
+      earth_geometric
+    end
+
     # Source:
     #  Title: Astronomical Algorithms
     #  Author: Jean Meeus
@@ -86,29 +208,33 @@ module Astronoby
       (@instant.tt - JulianDate::DEFAULT_EPOCH) / Constants::DAYS_PER_JULIAN_CENTURY
     end
 
-    private
-
     # Source:
     #  Title: Computing Apparent Planetary Magnitudes for The Astronomical
     #    Almanac (2018)
     #  Authors: Anthony Mallama and James L. Hilton
     def magnitude_correction_term
       phase_angle_degrees = phase_angle.degrees
-      if phase_angle_degrees <= 150 && current_phase_fraction <= 0.5
-        2.9994 * 10**-2 * phase_angle_degrees -
-          1.6057 * 10**-4 * phase_angle_degrees**2 +
-          3.1543 * 10**-6 * phase_angle_degrees**3 -
-          2.0667 * 10**-8 * phase_angle_degrees**4 +
-          6.2553 * 10**-11 * phase_angle_degrees**5
-      elsif phase_angle_degrees <= 150 && current_phase_fraction > 0.5
-        3.3234 * 10**-2 * phase_angle_degrees -
-          3.0725 * 10**-4 * phase_angle_degrees**2 +
-          6.1575 * 10**-6 * phase_angle_degrees**3 -
-          4.7723 * 10**-8 * phase_angle_degrees**4 +
-          1.4681 * 10**-10 * phase_angle_degrees**5
+      if phase_angle_degrees <= 150 && current_phase_fraction > 0.5
+        waning_magnitude_correction(phase_angle_degrees)
       else
-        super
+        waxing_magnitude_correction(phase_angle_degrees)
       end
     end
+
+    def waxing_magnitude_correction(phase_angle_degrees)
+      2.9994 * 10**-2 * phase_angle_degrees -
+        1.6057 * 10**-4 * phase_angle_degrees**2 +
+        3.1543 * 10**-6 * phase_angle_degrees**3 -
+        2.0667 * 10**-8 * phase_angle_degrees**4 +
+        6.2553 * 10**-11 * phase_angle_degrees**5
+    end
+
+    def waning_magnitude_correction(phase_angle_degrees)
+      3.3234 * 10**-2 * phase_angle_degrees -
+        3.0725 * 10**-4 * phase_angle_degrees**2 +
+        6.1575 * 10**-6 * phase_angle_degrees**3 -
+        4.7723 * 10**-8 * phase_angle_degrees**4 +
+        1.4681 * 10**-10 * phase_angle_degrees**5
+    end
   end
 end

data/lib/astronoby/bodies/neptune.rb

@@ -1,14 +1,24 @@
 # frozen_string_literal: true
 
 module Astronoby
+  # Represents Neptune.
   class Neptune < SolarSystemBody
     EQUATORIAL_RADIUS = Distance.from_meters(24_764_000)
     ABSOLUTE_MAGNITUDE = -7.0
+    ORBITAL_PERIOD = 60182.0
 
+    # @return [Boolean] true; Neptune is a superior planet
+    def self.superior_planet?
+      true
+    end
+
+    # @param _ephem_source [Symbol] the ephemeris source type
+    # @return [Array<Array>] ephemeris segment identifiers
     def self.ephemeris_segments(_ephem_source)
       [[SOLAR_SYSTEM_BARYCENTER, NEPTUNE_BARYCENTER]]
     end
 
+    # @return [Float] absolute magnitude
     def self.absolute_magnitude
       ABSOLUTE_MAGNITUDE
     end

data/lib/astronoby/bodies/saturn.rb

@@ -1,14 +1,24 @@
 # frozen_string_literal: true
 
 module Astronoby
+  # Represents Saturn.
   class Saturn < SolarSystemBody
     EQUATORIAL_RADIUS = Distance.from_meters(60_268_000)
     ABSOLUTE_MAGNITUDE = -8.914
+    ORBITAL_PERIOD = 10759.22
 
+    # @return [Boolean] true; Saturn is a superior planet
+    def self.superior_planet?
+      true
+    end
+
+    # @param _ephem_source [Symbol] the ephemeris source type
+    # @return [Array<Array>] ephemeris segment identifiers
     def self.ephemeris_segments(_ephem_source)
       [[SOLAR_SYSTEM_BARYCENTER, SATURN_BARYCENTER]]
     end
 
+    # @return [Float] absolute magnitude
     def self.absolute_magnitude
       ABSOLUTE_MAGNITUDE
     end

data/lib/astronoby/bodies/solar_system_body.rb

@@ -1,7 +1,13 @@
 # frozen_string_literal: true
 
 module Astronoby
+  # Base class for solar system bodies. Provides the reference frame chain
+  # (geometric -> astrometric -> mean-of-date -> apparent -> topocentric)
+  # and common observational properties (phase angle, magnitude, etc.).
   class SolarSystemBody
+    include Position
+    extend Body
+
     SOLAR_SYSTEM_BARYCENTER = 0
     SUN = 10
     MERCURY_BARYCENTER = 1
@@ -17,16 +23,37 @@ module Astronoby
     URANUS_BARYCENTER = 7
     NEPTUNE_BARYCENTER = 8
 
-    attr_reader :geometric, :instant
+    # @return [Astronoby::Instant] the time instant
+    attr_reader :instant
+
+    # @return [::Ephem::SPK] the ephemeris data source
+    attr_reader :ephem
 
-    def self.at(instant, ephem:)
-      new(ephem: ephem, instant: instant)
+    # @return [Astronoby::Orientation, nil] the orientation kernel, if provided
+    attr_reader :orientation
+
+    # Creates a new body instance at the given instant.
+    #
+    # @param instant [Astronoby::Instant] the time instant
+    # @param ephem [::Ephem::SPK] ephemeris data source
+    # @param orientation [Astronoby::Orientation, nil] orientation kernel
+    # @return [Astronoby::SolarSystemBody] a new body instance
+    def self.at(instant, ephem:, orientation: nil)
+      new(ephem: ephem, instant: instant, orientation: orientation)
     end
 
+    # Computes the geometric reference frame for this body.
+    #
+    # @param ephem [::Ephem::SPK] ephemeris data source
+    # @param instant [Astronoby::Instant] the time instant
+    # @return [Astronoby::Geometric] the geometric frame
     def self.geometric(ephem:, instant:)
       compute_geometric(ephem: ephem, instant: instant)
     end
 
+    # @param ephem [::Ephem::SPK] ephemeris data source
+    # @param instant [Astronoby::Instant] the time instant
+    # @return [Astronoby::Geometric] the geometric frame
     def self.compute_geometric(ephem:, instant:)
       segments = ephemeris_segments(ephem.type)
       segment1 = segments[0]
@@ -66,63 +93,196 @@ module Astronoby
       end
     end
 
+    # @param _ephem_source [Symbol] the ephemeris source type
+    # @return [Array<Array>] ephemeris segment identifiers
+    # @raise [NotImplementedError] must be implemented by subclasses
     def self.ephemeris_segments(_ephem_source)
       raise NotImplementedError
     end
 
+    # @return [Float, nil] absolute magnitude of the body
     def self.absolute_magnitude
       nil
     end
 
-    def initialize(ephem:, instant:)
+    # @return [Boolean] true for an inferior planet (Mercury, Venus)
+    def self.inferior_planet?
+      false
+    end
+
+    # @return [Boolean] true for a superior planet (Mars through Neptune)
+    def self.superior_planet?
+      false
+    end
+
+    # @return [Boolean] true for a planet (excludes the Sun, Earth and Moon)
+    def self.planet?
+      inferior_planet? || superior_planet?
+    end
+
+    # @param observer [Astronoby::Observer] Observer for whom to calculate rise,
+    #   transit, and set events
+    # @param ephem [::Ephem::SPK] Ephemeris data source
+    # @param date [Date] Date for which to calculate rise, transit, and set
+    #   events (optional)
+    # @param start_time [Time] Start time for rise, transit, and set event
+    #   calculation (optional)
+    # @param end_time [Time] End time for rise, transit, and set event
+    #   calculation (optional)
+    # @param utc_offset [String] UTC offset for the given date (e.g., "+02:00")
+    # @return [Astronoby::RiseTransitSetEvent,
+    #   Array<Astronoby::RiseTransitSetEvent>] Rise, transit, and set events for
+    #   the given date or time range.
+    def self.rise_transit_set_events(
+      observer:,
+      ephem:,
+      date: nil,
+      start_time: nil,
+      end_time: nil,
+      utc_offset: 0
+    )
+      calculator = RiseTransitSetCalculator.new(
+        body: self,
+        observer: observer,
+        ephem: ephem
+      )
+      if date
+        calculator.events_on(date, utc_offset: utc_offset)
+      else
+        calculator.events_between(start_time, end_time)
+      end
+    end
+
+    # @param ephem [::Ephem::SPK] ephemeris data source
+    # @param start_time [Time] start time
+    # @param end_time [Time] end time
+    # @param samples_per_period [Integer] number of samples per synodic period
+    # @return [Array<Astronoby::Conjunction>] conjunctions with the Sun
+    # @raise [Astronoby::UnsupportedEventError] unless the body is a planet
+    def self.conjunction_events(
+      ephem:,
+      start_time:,
+      end_time:,
+      samples_per_period: 60
+    )
+      unless planet?
+        raise UnsupportedEventError, "#{self} has no conjunctions with the Sun"
+      end
+
+      ConjunctionOppositionCalculator.new(
+        body: self,
+        ephem: ephem,
+        samples_per_period: samples_per_period
+      ).conjunction_events_between(start_time, end_time)
+    end
+
+    # @param ephem [::Ephem::SPK] ephemeris data source
+    # @param start_time [Time] start time
+    # @param end_time [Time] end time
+    # @param samples_per_period [Integer] number of samples per synodic period
+    # @return [Array<Astronoby::Opposition>] oppositions with the Sun
+    # @raise [Astronoby::UnsupportedEventError] unless the body is a superior
+    #   planet
+    def self.opposition_events(
+      ephem:,
+      start_time:,
+      end_time:,
+      samples_per_period: 60
+    )
+      unless superior_planet?
+        raise UnsupportedEventError, "#{self} has no oppositions with the Sun"
+      end
+
+      ConjunctionOppositionCalculator.new(
+        body: self,
+        ephem: ephem,
+        samples_per_period: samples_per_period
+      ).opposition_events_between(start_time, end_time)
+    end
+
+    # @param ephem [::Ephem::SPK] ephemeris data source
+    # @param start_time [Time] start time
+    # @param end_time [Time] end time
+    # @param samples_per_period [Integer] number of samples per synodic period
+    # @return [Array<Astronoby::GreatestElongation>] greatest elongations
+    # @raise [Astronoby::UnsupportedEventError] unless the body is an inferior
+    #   planet
+    def self.greatest_elongation_events(
+      ephem:,
+      start_time:,
+      end_time:,
+      samples_per_period: 60
+    )
+      unless inferior_planet?
+        raise UnsupportedEventError,
+          "#{self} has no greatest elongations from the Sun"
+      end
+
+      GreatestElongationCalculator.new(
+        body: self,
+        ephem: ephem,
+        samples_per_period: samples_per_period
+      ).greatest_elongation_events_between(start_time, end_time)
+    end
+
+    # @param ephem [::Ephem::SPK] Ephemeris data source
+    # @param instant [Astronoby::Instant] Instant for which to calculate the
+    #   phase angle
+    # @param orientation [Astronoby::Orientation, nil] Orientation kernel,
+    #   enabling arcsecond-accurate lunar libration and axis position angle
+    def initialize(ephem:, instant:, orientation: nil)
+      @ephem = ephem
       @instant = instant
-      @geometric = compute_geometric(ephem)
-      @earth_geometric = Earth.geometric(ephem: ephem, instant: instant)
-      @light_time_corrected_position,
-        @light_time_corrected_velocity =
-        Correction::LightTimeDelay.compute(
-          center: @earth_geometric,
-          target: @geometric,
-          ephem: ephem
-        )
-      compute_sun(ephem) if requires_sun_data?
+      @orientation = orientation
+    end
+
+    # @return [Astronoby::Geometric] the geometric reference frame (BCRS)
+    def geometric
+      @geometric ||= self.class.compute_geometric(
+        ephem: @ephem,
+        instant: @instant
+      )
+    end
+
+    # @return [Astronoby::Geometric] Earth's geometric reference frame
+    def earth_geometric
+      @earth_geometric ||= Earth.geometric(ephem: @ephem, instant: @instant)
     end
 
+    # @return [Astronoby::Astrometric] the astrometric reference frame (GCRS)
     def astrometric
       @astrometric ||= Astrometric.build_from_geometric(
         instant: @instant,
-        earth_geometric: @earth_geometric,
-        light_time_corrected_position: @light_time_corrected_position,
-        light_time_corrected_velocity: @light_time_corrected_velocity,
-        target_body: self
+        earth_geometric: earth_geometric,
+        light_time_corrected_position: light_time_corrected_position,
+        light_time_corrected_velocity: light_time_corrected_velocity,
+        target_body: body
       )
     end
 
+    # @return [Astronoby::MeanOfDate] the mean-of-date reference frame
     def mean_of_date
       @mean_of_date ||= MeanOfDate.build_from_geometric(
         instant: @instant,
-        target_geometric: @geometric,
-        earth_geometric: @earth_geometric,
-        target_body: self
+        target_geometric: geometric,
+        earth_geometric: earth_geometric,
+        target_body: body
       )
     end
 
+    # @return [Astronoby::Apparent] the apparent reference frame
     def apparent
       @apparent ||= Apparent.build_from_astrometric(
         instant: @instant,
         target_astrometric: astrometric,
-        earth_geometric: @earth_geometric,
-        target_body: self
+        earth_geometric: earth_geometric,
+        target_body: body
       )
     end
 
-    def observed_by(observer)
-      Topocentric.build_from_apparent(
-        apparent: apparent,
-        observer: observer,
-        instant: @instant,
-        target_body: self
-      )
+    # @return [Astronoby::Body] the body definition (the class itself)
+    def body
+      self.class
     end
 
     # Returns the constellation of the body
@@ -136,6 +296,25 @@ module Astronoby
       )
     end
 
+    # Apparent geocentric Sun-Earth-body angle
+    # @return [Astronoby::Angle, nil] Elongation of the body
+    def elongation
+      return unless sun
+
+      @elongation ||= sun.apparent.separation_from(apparent)
+    end
+
+    # @return [Boolean] true when the body is east of the Sun
+    def eastern?
+      (apparent.ecliptic.longitude - sun.apparent.ecliptic.longitude)
+        .sin.positive?
+    end
+
+    # @return [Boolean] true when the body is west of the Sun
+    def western?
+      !eastern?
+    end
+
     # Source:
     #  Title: Astronomical Algorithms
     #  Author: Jean Meeus
@@ -143,23 +322,12 @@ module Astronoby
     #  Chapter: 48 - Illuminated Fraction of the Moon's Disk
     # @return [Astronoby::Angle, nil] Phase angle of the body
     def phase_angle
-      return unless @sun
+      return unless sun
 
       @phase_angle ||= begin
-        geocentric_elongation = Angle.acos(
-          @sun.apparent.equatorial.declination.sin *
-          apparent.equatorial.declination.sin +
-          @sun.apparent.equatorial.declination.cos *
-          apparent.equatorial.declination.cos *
-          (
-            @sun.apparent.equatorial.right_ascension -
-              apparent.equatorial.right_ascension
-          ).cos
-        )
-
-        term1 = @sun.astrometric.distance.km * geocentric_elongation.sin
+        term1 = sun.astrometric.distance.km * elongation.sin
         term2 = astrometric.distance.km -
-          @sun.astrometric.distance.km * geocentric_elongation.cos
+          sun.astrometric.distance.km * elongation.cos
         angle = Angle.atan(term1 / term2)
         Astronoby::Util::Trigonometry
           .adjustement_for_arctangent(term1, term2, angle)
@@ -186,7 +354,7 @@ module Astronoby
 
       @apparent_magnitude ||= begin
         body_sun_distance =
-          (astrometric.position - @sun.astrometric.position).magnitude
+          (astrometric.position - sun.astrometric.position).magnitude
         self.class.absolute_magnitude +
           5 * Math.log10(body_sun_distance.au * astrometric.distance.au) +
           magnitude_correction_term
@@ -206,13 +374,13 @@ module Astronoby
       end
     end
 
-    # @return [Boolean] True if the body is approaching the primary
-    #   body (Sun), false otherwise.
+    # @return [Boolean] True if the body is approaching its primary
+    #   body, false otherwise.
     def approaching_primary?
       relative_position =
-        (geometric.position - @sun.geometric.position).map(&:m)
+        (geometric.position - primary_body_geometric.position).map(&:m)
       relative_velocity =
-        (geometric.velocity - @sun.geometric.velocity).map(&:mps)
+        (geometric.velocity - primary_body_geometric.velocity).map(&:mps)
       radial_velocity_component = Astronoby::Util::Maths
         .dot_product(relative_position, relative_velocity)
       distance = Math.sqrt(
@@ -221,28 +389,39 @@ module Astronoby
       radial_velocity_component / distance < 0
     end
 
-    # @return [Boolean] True if the body is receding from the primary
-    #   body (Sun), false otherwise.
+    # @return [Boolean] True if the body is receding from its primary
+    #   body, false otherwise.
     def receding_from_primary?
       !approaching_primary?
     end
 
     private
 
-    # By default, Solar System bodies expose attributes that are dependent on
-    # the Sun's position, such as phase angle and illuminated fraction.
-    # If a body does not require Sun data, it should override this method to
-    # return false.
-    def requires_sun_data?
-      true
+    def sun
+      @sun ||= Sun.new(instant: @instant, ephem: @ephem)
     end
 
-    def compute_geometric(ephem)
-      self.class.compute_geometric(ephem: ephem, instant: @instant)
+    def primary_body_geometric
+      sun.geometric
     end
 
-    def compute_sun(ephem)
-      @sun ||= Sun.new(instant: @instant, ephem: ephem)
+    def light_time_corrected_position
+      compute_light_time_correction unless @light_time_corrected_position
+      @light_time_corrected_position
+    end
+
+    def light_time_corrected_velocity
+      compute_light_time_correction unless @light_time_corrected_velocity
+      @light_time_corrected_velocity
+    end
+
+    def compute_light_time_correction
+      @light_time_corrected_position, @light_time_corrected_velocity =
+        Correction::LightTimeDelay.compute(
+          center: earth_geometric,
+          target: geometric,
+          ephem: @ephem
+        )
     end
 
     # Source: