astronoby 0.5.0 → 0.7.0

data/lib/astronoby/aberration.rb

@@ -1,47 +1,72 @@
 # frozen_string_literal: true
 
 module Astronoby
+  # Applies relativistic aberration corrections to an astrometric position based
+  # on observer velocity.
   class Aberration
-    MAXIMUM_SHIFT = Angle.from_degrees(20.5)
+    # Source:
+    #  Title: Explanatory Supplement to the Astronomical Almanac
+    #  Authors: Sean E. Urban and P. Kenneth Seidelmann
+    #  Edition: University Science Books
+    #  Chapter: 7.2.3 - Aberration
 
-    def self.for_ecliptic_coordinates(coordinates:, epoch:)
-      new(coordinates, epoch).apply
-    end
+    LIGHT_SPEED = Astronoby::Velocity.light_speed.mps
 
-    def initialize(coordinates, epoch)
-      @coordinates = coordinates
-      @epoch = epoch
+    # Initializes the aberration correction with position and observer velocity.
+    #
+    # @param astrometric_position [Astronoby::Vector<Astronoby::Distance>] The
+    #   astrometric position vector.
+    # @param observer_velocity [Astronoby::Vector<Astronoby::Velocity>] The
+    #   velocity vector of the observer.
+    def initialize(astrometric_position:, observer_velocity:)
+      @position = astrometric_position
+      @velocity = observer_velocity
+      @distance_meters = @position.norm.m
+      @observer_speed = @velocity.norm.mps
     end
 
-    # Source:
-    #  Title: Practical Astronomy with your Calculator or Spreadsheet
-    #  Authors: Peter Duffett-Smith and Jonathan Zwart
-    #  Edition: Cambridge University Press
-    #  Chapter: 36 - Aberration
-    def apply
-      delta_longitude = Angle.from_degrees(
-        -MAXIMUM_SHIFT.degrees * (
-          sun_longitude - @coordinates.longitude
-        ).cos / @coordinates.latitude.cos / Constants::SECONDS_PER_DEGREE
-      )
+    # Computes the aberration-corrected position.
+    #
+    # @return [Astronoby::Vector<Astronoby::Distance>] The corrected position
+    #   vector.
+    def corrected_position
+      beta = @observer_speed / LIGHT_SPEED
+      projected_velocity = beta * aberration_angle_cos
+      lorentz_factor_inv = lorentz_factor_inverse(beta)
 
-      delta_latitude = Angle.from_degrees(
-        -MAXIMUM_SHIFT.degrees *
-        (sun_longitude - @coordinates.longitude).sin *
-        @coordinates.latitude.sin / Constants::SECONDS_PER_DEGREE
-      )
+      velocity_correction =
+        velocity_correction_factor(projected_velocity) * velocity_mps
+      normalization_factor = 1.0 + projected_velocity
+      position_scaled = position_meters * lorentz_factor_inv
 
-      Coordinates::Ecliptic.new(
-        latitude: @coordinates.latitude + delta_latitude,
-        longitude: @coordinates.longitude + delta_longitude
+      Distance.vector_from_meters(
+        (position_scaled + velocity_correction) / normalization_factor
       )
     end
 
-    def sun_longitude
-      @_sun_longitude ||= Sun
-        .new(time: Epoch.to_utc(@epoch))
-        .true_ecliptic_coordinates
-        .longitude
+    private
+
+    def aberration_angle_cos
+      denominator = [@distance_meters * @observer_speed, 1e-20].max
+      Util::Maths.dot_product(position_meters, velocity_mps) / denominator
+    end
+
+    def position_meters
+      @position.map(&:meters)
+    end
+
+    def velocity_mps
+      @velocity.map(&:mps)
+    end
+
+    def lorentz_factor_inverse(beta)
+      Math.sqrt(1.0 - beta**2)
+    end
+
+    def velocity_correction_factor(projected_velocity)
+      lorentz_inv = lorentz_factor_inverse(projected_velocity)
+      (1.0 + projected_velocity / (1.0 + lorentz_inv)) *
+        (@distance_meters / LIGHT_SPEED)
     end
   end
 end

data/lib/astronoby/angle.rb

@@ -22,6 +22,10 @@ module Astronoby
         from_radians(radians)
       end
 
+      def from_degree_arcseconds(arcseconds)
+        from_dms(0, 0, arcseconds)
+      end
+
       def from_hours(hours)
         radians = hours * Constants::RADIAN_PER_HOUR
         from_radians(radians)
@@ -120,10 +124,10 @@ module Astronoby
     end
     alias_method :eql?, :==
 
-    def str(format)
+    def str(format, precision: 4)
       case format
-      when :dms then to_dms(degrees).format
-      when :hms then to_hms(hours).format
+      when :dms then to_dms.format(precision: precision)
+      when :hms then to_hms.format(precision: precision)
       else
         raise UnsupportedFormatError.new(
           "Expected a format between #{FORMATS.join(", ")}, got #{format}"
@@ -131,36 +135,36 @@ module Astronoby
       end
     end
 
-    def to_dms(deg)
-      sign = deg.negative? ? "-" : "+"
-      absolute_degrees = deg.abs
-      degrees = absolute_degrees.floor
+    def to_dms
+      sign = degrees.negative? ? "-" : "+"
+      absolute_degrees = degrees.abs
+      deg = absolute_degrees.floor
       decimal_minutes = Constants::MINUTES_PER_DEGREE *
-        (absolute_degrees - degrees)
+        (absolute_degrees - deg)
       absolute_decimal_minutes = (
-        Constants::MINUTES_PER_DEGREE * (absolute_degrees - degrees)
+        Constants::MINUTES_PER_DEGREE * (absolute_degrees - deg)
       ).abs
       minutes = decimal_minutes.floor
       seconds = Constants::SECONDS_PER_MINUTE * (
         absolute_decimal_minutes - absolute_decimal_minutes.floor
       )
 
-      Dms.new(sign, degrees, minutes, seconds.floor(4))
+      Dms.new(sign, deg, minutes, seconds)
     end
 
-    def to_hms(hrs)
-      absolute_hours = hrs.abs
-      hours = absolute_hours.floor
-      decimal_minutes = Constants::MINUTES_PER_HOUR * (absolute_hours - hours)
+    def to_hms
+      absolute_hours = hours.abs
+      hrs = absolute_hours.floor
+      decimal_minutes = Constants::MINUTES_PER_HOUR * (absolute_hours - hrs)
       absolute_decimal_minutes = (
-        Constants::MINUTES_PER_HOUR * (absolute_hours - hours)
+        Constants::MINUTES_PER_HOUR * (absolute_hours - hrs)
       ).abs
       minutes = decimal_minutes.floor
       seconds = Constants::SECONDS_PER_MINUTE * (
         absolute_decimal_minutes - absolute_decimal_minutes.floor
       )
 
-      Hms.new(hours, minutes, seconds.floor(4))
+      Hms.new(hrs, minutes, seconds)
     end
   end
 end

data/lib/astronoby/angles/dms.rb

@@ -11,8 +11,8 @@ module Astronoby
       @seconds = seconds
     end
 
-    def format
-      "#{sign}#{degrees}° #{minutes}′ #{seconds}″"
+    def format(precision: 4)
+      "#{sign}#{degrees}° #{minutes}′ #{seconds.floor(precision)}″"
     end
   end
 end

data/lib/astronoby/angles/hms.rb

@@ -10,8 +10,8 @@ module Astronoby
       @seconds = seconds
     end
 
-    def format
-      "#{hours}h #{minutes}m #{seconds}s"
+    def format(precision: 4)
+      "#{hours}h #{minutes}m #{seconds.floor(precision)}s"
     end
   end
 end

data/lib/astronoby/bodies/earth.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Astronoby
+  class Earth < SolarSystemBody
+    def self.ephemeris_segments(ephem_source)
+      if ephem_source == ::Ephem::SPK::JPL_DE
+        [
+          [SOLAR_SYSTEM_BARYCENTER, EARTH_MOON_BARYCENTER],
+          [EARTH_MOON_BARYCENTER, EARTH]
+        ]
+      elsif ephem_source == ::Ephem::SPK::INPOP
+        [
+          [SOLAR_SYSTEM_BARYCENTER, EARTH]
+        ]
+      end
+    end
+
+    private
+
+    def compute_astrometric(ephem)
+      Astrometric.new(
+        position: Vector[
+          Distance.zero,
+          Distance.zero,
+          Distance.zero
+        ],
+        velocity: Vector[
+          Velocity.zero,
+          Velocity.zero,
+          Velocity.zero
+        ],
+        instant: @instant,
+        center_identifier: EARTH,
+        target_body: self.class
+      )
+    end
+
+    def compute_mean_of_date(ephem)
+      MeanOfDate.new(
+        position: Vector[
+          Distance.zero,
+          Distance.zero,
+          Distance.zero
+        ],
+        velocity: Vector[
+          Velocity.zero,
+          Velocity.zero,
+          Velocity.zero
+        ],
+        instant: @instant,
+        center_identifier: EARTH,
+        target_body: self.class
+      )
+    end
+  end
+end

data/lib/astronoby/bodies/jupiter.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Astronoby
+  class Jupiter < SolarSystemBody
+    EQUATORIAL_RADIUS = Distance.from_meters(71_492_000)
+
+    def self.ephemeris_segments(_ephem_source)
+      [[SOLAR_SYSTEM_BARYCENTER, JUPITER_BARYCENTER]]
+    end
+  end
+end

data/lib/astronoby/bodies/mars.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Astronoby
+  class Mars < SolarSystemBody
+    EQUATORIAL_RADIUS = Distance.from_meters(3_396_200)
+
+    def self.ephemeris_segments(_ephem_source)
+      [[SOLAR_SYSTEM_BARYCENTER, MARS_BARYCENTER]]
+    end
+  end
+end

data/lib/astronoby/bodies/mercury.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Astronoby
+  class Mercury < SolarSystemBody
+    EQUATORIAL_RADIUS = Distance.from_meters(2_439_700)
+
+    def self.ephemeris_segments(_ephem_source)
+      [[SOLAR_SYSTEM_BARYCENTER, MERCURY_BARYCENTER]]
+    end
+  end
+end

data/lib/astronoby/bodies/moon.rb

@@ -1,9 +1,23 @@
 # frozen_string_literal: true
 
 module Astronoby
-  class Moon
+  class Moon < SolarSystemBody
     SEMIDIAMETER_VARIATION = 0.7275
-    MEAN_GEOCENTRIC_DISTANCE = Astronoby::Distance.from_meters(385_000_560)
+    EQUATORIAL_RADIUS = Distance.from_meters(1_737_400)
+
+    def self.ephemeris_segments(ephem_source)
+      if ephem_source == ::Ephem::SPK::JPL_DE
+        [
+          [SOLAR_SYSTEM_BARYCENTER, EARTH_MOON_BARYCENTER],
+          [EARTH_MOON_BARYCENTER, MOON]
+        ]
+      elsif ephem_source == ::Ephem::SPK::INPOP
+        [
+          [SOLAR_SYSTEM_BARYCENTER, EARTH],
+          [EARTH, MOON]
+        ]
+      end
+    end
 
     # Source:
     #  Title: Astronomical Algorithms
@@ -18,117 +32,24 @@ module Astronoby
       Events::MoonPhases.phases_for(year: year, month: month)
     end
 
-    def initialize(time:)
-      @time = time
-    end
-
-    # @return [Astronoby::Coordinates::Ecliptic] Apparent ecliptic coordinates
-    #   of the Moon
-    def apparent_ecliptic_coordinates
-      @ecliptic_coordinates ||= begin
-        latitude = Astronoby::Angle.from_degrees(
-          (latitude_terms + additive_latitude_terms) *
-            EphemerideLunaireParisienne::DEGREES_UNIT
-        )
-
-        longitude = mean_longitude + Astronoby::Angle.from_degrees(
-          (longitude_terms + additive_longitude_terms) *
-            EphemerideLunaireParisienne::DEGREES_UNIT
-        ) + nutation
-
-        Coordinates::Ecliptic.new(
-          latitude: latitude,
-          longitude: longitude
-        )
-      end
-    end
-
-    # Source:
-    #  Title: Astronomical Algorithms
-    #  Author: Jean Meeus
-    #  Edition: 2nd edition
-    #  Chapter: 47 - Position of the Moon
-
-    # @return [Astronoby::Coordinates::Equatorial] Apparent geocentric
-    #   equatorial coordinates of the Moon
-    def apparent_equatorial_coordinates
-      @apparent_equatorial_coordinates ||=
-        apparent_ecliptic_coordinates
-          .to_apparent_equatorial(epoch: Epoch.from_time(@time))
-    end
-
-    def horizontal_coordinates(observer:)
-      apparent_topocentric_equatorial_coordinates =
-        Astronoby::GeocentricParallax.for_equatorial_coordinates(
-          observer: observer,
-          time: @time,
-          coordinates: apparent_equatorial_coordinates,
-          distance: distance
-        )
-
-      apparent_topocentric_equatorial_coordinates.to_horizontal(
-        observer: observer,
-        time: @time
-      )
-    end
-
-    # @return [Astronoby::Distance] Distance between the Earth and the Moon centers
-    def distance
-      @distance ||= Astronoby::Distance.from_meters(
-        (MEAN_GEOCENTRIC_DISTANCE.meters + distance_terms).round
-      )
-    end
+    attr_reader :phase_angle
 
-    # @return [Angle] Moon's mean longitude
-    def mean_longitude
-      @mean_longitude ||= Angle.from_degrees(
-        (
-          218.3164477 +
-          481267.88123421 * elapsed_centuries -
-          0.0015786 * elapsed_centuries**2 +
-          elapsed_centuries**3 / 538841 -
-          elapsed_centuries**4 / 65194000
-        ) % 360
-      )
+    def initialize(instant:, ephem:)
+      super
+      @phase_angle = compute_phase_angle(ephem)
     end
 
-    # @return [Angle] Moon's mean elongation
-    def mean_elongation
-      @mean_elongation ||= Angle.from_degrees(
-        (
-          297.8501921 +
-          445267.1114034 * elapsed_centuries -
-          0.0018819 * elapsed_centuries**2 +
-          elapsed_centuries**3 / 545868 -
-          elapsed_centuries**4 / 113065000
-        ) % 360
-      )
+    # @return [Float] Moon's illuminated fraction
+    def illuminated_fraction
+      @illuminated_fraction ||= (1 + phase_angle.cos) / 2.0
     end
 
-    # @return [Angle] Moon's mean anomaly
-    def mean_anomaly
-      @mean_anomaly ||= Angle.from_degrees(
-        (
-          134.9633964 +
-          477198.8675055 * elapsed_centuries +
-          0.0087414 * elapsed_centuries**2 +
-          elapsed_centuries**3 / 69699 -
-          elapsed_centuries**4 / 14712000
-        ) % 360
-      )
+    # @return [Float] Phase fraction, from 0 to 1
+    def current_phase_fraction
+      mean_elongation.degrees / Constants::DEGREES_PER_CIRCLE
     end
 
-    # @return [Angle] Moon's argument of latitude
-    def argument_of_latitude
-      @argument_of_latitude ||= Angle.from_degrees(
-        (
-          93.2720950 +
-          483202.0175233 * elapsed_centuries -
-          0.0036539 * elapsed_centuries**2 -
-          elapsed_centuries**3 / 3526000
-        ) % 360
-      )
-    end
+    private
 
     # Source:
     #  Title: Astronomical Algorithms
@@ -137,199 +58,43 @@ module Astronoby
     #  Chapter: 48 - Illuminated Fraction of the Moon's Disk
 
     # @return [Angle] Moon's phase angle
-    def phase_angle
+    def compute_phase_angle(ephem)
       @phase_angle ||= begin
-        sun_apparent_equatorial_coordinates = sun
-          .apparent_ecliptic_coordinates
-          .to_apparent_equatorial(epoch: Epoch.from_time(@time))
-        moon_apparent_equatorial_coordinates = apparent_equatorial_coordinates
+        sun = Sun.new(instant: @instant, ephem: ephem)
         geocentric_elongation = Angle.acos(
-          sun_apparent_equatorial_coordinates.declination.sin *
-            moon_apparent_equatorial_coordinates.declination.sin +
-            sun_apparent_equatorial_coordinates.declination.cos *
-            moon_apparent_equatorial_coordinates.declination.cos *
-            (
-              sun_apparent_equatorial_coordinates.right_ascension -
-              moon_apparent_equatorial_coordinates.right_ascension
-            ).cos
+          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.earth_distance.km * geocentric_elongation.sin
-        term2 = distance.km - sun.earth_distance.km * geocentric_elongation.cos
+        term1 = sun.astrometric.distance.km * geocentric_elongation.sin
+        term2 = astrometric.distance.km -
+          sun.astrometric.distance.km * geocentric_elongation.cos
         angle = Angle.atan(term1 / term2)
         Astronoby::Util::Trigonometry
           .adjustement_for_arctangent(term1, term2, angle)
       end
     end
 
-    # @return [Float] Moon's illuminated fraction
-    def illuminated_fraction
-      @illuminated_fraction ||= (1 + phase_angle.cos) / 2
-    end
-
-    # @param observer [Astronoby::Observer] Observer of the event
-    # @return [Astronoby::Events::ObservationEvents] Moon's observation events
-    def observation_events(observer:)
-      today = @time.to_date
-      leap_seconds = Util::Time.terrestrial_universal_time_delta(today)
-      yesterday = today.prev_day
-      yesterday_midnight_terrestrial_time =
-        Time.utc(yesterday.year, yesterday.month, yesterday.day) - leap_seconds
-      today_midnight_terrestrial_time =
-        Time.utc(today.year, today.month, today.day) - leap_seconds
-      tomorrow = today.next_day
-      tomorrow_midnight_terrestrial_time =
-        Time.utc(tomorrow.year, tomorrow.month, tomorrow.day) - leap_seconds
-
-      coordinates_of_the_previous_day = self.class
-        .new(time: yesterday_midnight_terrestrial_time)
-        .apparent_equatorial_coordinates
-      coordinates_of_the_day = self.class
-        .new(time: today_midnight_terrestrial_time)
-        .apparent_equatorial_coordinates
-      coordinates_of_the_next_day = self.class
-        .new(time: tomorrow_midnight_terrestrial_time)
-        .apparent_equatorial_coordinates
-      additional_altitude = -Angle.from_degrees(
-        SEMIDIAMETER_VARIATION *
-          GeocentricParallax.angle(distance: distance).degrees
-      )
-
-      Events::ObservationEvents.new(
-        observer: observer,
-        date: today,
-        coordinates_of_the_previous_day: coordinates_of_the_previous_day,
-        coordinates_of_the_day: coordinates_of_the_day,
-        coordinates_of_the_next_day: coordinates_of_the_next_day,
-        additional_altitude: additional_altitude
+    def mean_elongation
+      @mean_elongation ||= Angle.from_degrees(
+        (
+          297.8501921 +
+            445267.1114034 * elapsed_centuries -
+            0.0018819 * elapsed_centuries**2 +
+            elapsed_centuries**3 / 545868 -
+            elapsed_centuries**4 / 113065000
+        ) % 360
       )
     end
 
-    private
-
-    def terrestrial_time
-      @terrestrial_time ||= begin
-        delta = Util::Time.terrestrial_universal_time_delta(@time)
-        @time + delta
-      end
-    end
-
-    def julian_date
-      Epoch.from_time(terrestrial_time)
-    end
-
     def elapsed_centuries
-      (julian_date - Epoch::DEFAULT_EPOCH) / Constants::DAYS_PER_JULIAN_CENTURY
-    end
-
-    def sun
-      @sun ||= Sun.new(time: @time)
-    end
-
-    def sun_mean_anomaly
-      @sun_mean_anomaly ||= sun.mean_anomaly
-    end
-
-    def a1
-      @a1 ||= Angle.from_degrees(
-        (119.75 + 131.849 * elapsed_centuries) % 360
-      )
-    end
-
-    def a2
-      @a2 ||= Angle.from_degrees(
-        (53.09 + 479264.290 * elapsed_centuries) % 360
-      )
-    end
-
-    def a3
-      @a3 ||= Angle.from_degrees(
-        (313.45 + 481266.484 * elapsed_centuries) % 360
-      )
-    end
-
-    def eccentricity_correction
-      @eccentricity_correction ||=
-        1 - 0.002516 * elapsed_centuries - 0.0000074 * elapsed_centuries**2
-    end
-
-    def latitude_terms
-      @latitude_terms ||=
-        Astronoby::EphemerideLunaireParisienne
-          .periodic_terms_for_moon_latitude
-          .inject(0) do |sum, terms|
-            value = terms[4] * Math.sin(
-              terms[0] * mean_elongation.radians +
-              terms[1] * sun_mean_anomaly.radians +
-              terms[2] * mean_anomaly.radians +
-              terms[3] * argument_of_latitude.radians
-            )
-
-            value *= eccentricity_correction if terms[1].abs == 1
-            value *= eccentricity_correction**2 if terms[1].abs == 2
-
-            sum + value
-          end
-    end
-
-    def additive_latitude_terms
-      @additive_latitude_terms ||=
-        -2235 * mean_longitude.sin +
-        382 * a3.sin +
-        175 * (a1 - argument_of_latitude).sin +
-        175 * (a1 + argument_of_latitude).sin +
-        127 * (mean_longitude - mean_anomaly).sin -
-        115 * (mean_longitude + mean_anomaly).sin
-    end
-
-    def longitude_terms
-      @longitude_terms ||=
-        Astronoby::EphemerideLunaireParisienne
-          .periodic_terms_for_moon_longitude_and_distance
-          .inject(0) do |sum, terms|
-            value = terms[4] * Math.sin(
-              terms[0] * mean_elongation.radians +
-              terms[1] * sun_mean_anomaly.radians +
-              terms[2] * mean_anomaly.radians +
-              terms[3] * argument_of_latitude.radians
-            )
-
-            value *= eccentricity_correction if terms[1].abs == 1
-            value *= eccentricity_correction**2 if terms[1].abs == 2
-
-            sum + value
-          end
-    end
-
-    def additive_longitude_terms
-      @additive_longitude_terms ||=
-        3958 * a1.sin +
-        1962 * (mean_longitude - argument_of_latitude).sin +
-        318 * a2.sin
-    end
-
-    def distance_terms
-      @distance_terms ||=
-        EphemerideLunaireParisienne
-          .periodic_terms_for_moon_longitude_and_distance
-          .inject(0) do |sum, terms|
-            value = terms[5] * Math.cos(
-              terms[0] * mean_elongation.radians +
-              terms[1] * sun_mean_anomaly.radians +
-              terms[2] * mean_anomaly.radians +
-              terms[3] * argument_of_latitude.radians
-            )
-
-            value *= eccentricity_correction if terms[1].abs == 1
-            value *= eccentricity_correction**2 if terms[1].abs == 2
-
-            sum + value
-          end
-    end
-
-    def nutation
-      @nutation ||=
-        Astronoby::Nutation.for_ecliptic_longitude(epoch: julian_date)
+      (@instant.tt - Epoch::DEFAULT_EPOCH) / Constants::DAYS_PER_JULIAN_CENTURY
     end
   end
 end

data/lib/astronoby/bodies/neptune.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Astronoby
+  class Neptune < SolarSystemBody
+    EQUATORIAL_RADIUS = Distance.from_meters(24_764_000)
+
+    def self.ephemeris_segments(_ephem_source)
+      [[SOLAR_SYSTEM_BARYCENTER, NEPTUNE_BARYCENTER]]
+    end
+  end
+end