astronoby 0.6.0 → 0.7.0

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
-        )
+    attr_reader :phase_angle
 
-      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
-
-    # @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,204 +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
-
-    # @return [Float] Phase fraction, from 0 to 1
-    def current_phase_fraction
-      mean_elongation.degrees / Constants::DEGREES_PER_CIRCLE
-    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

data/lib/astronoby/bodies/saturn.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Astronoby
+  class Saturn < SolarSystemBody
+    EQUATORIAL_RADIUS = Distance.from_meters(60_268_000)
+
+    def self.ephemeris_segments(_ephem_source)
+      [[SOLAR_SYSTEM_BARYCENTER, SATURN_BARYCENTER]]
+    end
+  end
+end

data/lib/astronoby/bodies/solar_system_body.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Astronoby
+  class SolarSystemBody
+    SOLAR_SYSTEM_BARYCENTER = 0
+    SUN = 10
+    MERCURY_BARYCENTER = 1
+    MERCURY = 199
+    VENUS_BARYCENTER = 2
+    VENUS = 299
+    EARTH_MOON_BARYCENTER = 3
+    EARTH = 399
+    MOON = 301
+    MARS_BARYCENTER = 4
+    JUPITER_BARYCENTER = 5
+    SATURN_BARYCENTER = 6
+    URANUS_BARYCENTER = 7
+    NEPTUNE_BARYCENTER = 8
+
+    attr_reader :geometric, :instant
+
+    def self.geometric(ephem:, instant:)
+      compute_geometric(ephem: ephem, instant: instant)
+    end
+
+    def self.compute_geometric(ephem:, instant:)
+      segments = ephemeris_segments(ephem.type)
+      segment1 = segments[0]
+      segment2 = segments[1] if segments.size == 2
+
+      state1 = ephem[*segment1].state_at(instant.terrestrial_time)
+
+      if segment2
+        state2 = ephem[*segment2].state_at(instant.terrestrial_time)
+        position = state1.position + state2.position
+        velocity = state1.velocity + state2.velocity
+      else
+        position = state1.position
+        velocity = state1.velocity
+      end
+
+      position_vector = Vector[
+        Distance.from_kilometers(position.x),
+        Distance.from_kilometers(position.y),
+        Distance.from_kilometers(position.z)
+      ]
+
+      velocity_vector = Vector[
+        Velocity.from_kilometers_per_day(velocity.x),
+        Velocity.from_kilometers_per_day(velocity.y),
+        Velocity.from_kilometers_per_day(velocity.z)
+      ]
+
+      Geometric.new(
+        position: position_vector,
+        velocity: velocity_vector,
+        instant: instant,
+        target_body: self
+      )
+    end
+
+    def self.ephemeris_segments(_ephem_source)
+      raise NotImplementedError
+    end
+
+    def initialize(ephem:, instant:)
+      @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
+        )
+    end
+
+    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
+      )
+    end
+
+    def mean_of_date
+      @mean_of_date ||= MeanOfDate.build_from_geometric(
+        instant: @instant,
+        target_geometric: @geometric,
+        earth_geometric: @earth_geometric,
+        target_body: self
+      )
+    end
+
+    def apparent
+      @apparent ||= Apparent.build_from_astrometric(
+        instant: @instant,
+        target_astrometric: astrometric,
+        earth_geometric: @earth_geometric,
+        target_body: self
+      )
+    end
+
+    def observed_by(observer)
+      Topocentric.build_from_apparent(
+        apparent: apparent,
+        observer: observer,
+        instant: @instant,
+        target_body: self
+      )
+    end
+
+    private
+
+    def compute_geometric(ephem)
+      self.class.compute_geometric(ephem: ephem, instant: @instant)
+    end
+  end
+end