astronoby 0.6.0 → 0.7.0

data/lib/astronoby/bodies/sun.rb

@@ -1,29 +1,12 @@
 # frozen_string_literal: true
 
 module Astronoby
-  class Sun
-    SEMI_MAJOR_AXIS_IN_METERS = 149_598_500_000
-    ANGULAR_DIAMETER = Angle.from_degrees(0.533128)
-    INTERPOLATION_FACTOR = 24.07
+  class Sun < SolarSystemBody
+    EQUATORIAL_RADIUS = Distance.from_meters(695_700_000)
 
-    TWILIGHTS = [
-      CIVIL = :civil,
-      NAUTICAL = :nautical,
-      ASTRONOMICAL = :astronomical
-    ].freeze
-
-    TWILIGHT_ANGLES = {
-      CIVIL => Angle.from_degrees(96),
-      NAUTICAL => Angle.from_degrees(102),
-      ASTRONOMICAL => Angle.from_degrees(108)
-    }.freeze
-
-    PERIODS_OF_THE_DAY = [
-      MORNING = :morning,
-      EVENING = :evening
-    ].freeze
-
-    attr_reader :time
+    def self.ephemeris_segments(_ephem_source)
+      [[SOLAR_SYSTEM_BARYCENTER, SUN]]
+    end
 
     # Source:
     #  Title: Astronomical Algorithms
@@ -31,215 +14,28 @@ module Astronoby
     #  Edition: 2nd edition
     #  Chapter: 28 - Equation of Time
 
-    # @param date_or_time [Date, Time] Requested date
     # @return [Integer] Equation of time in seconds
-    def self.equation_of_time(date_or_time:)
-      noon = Time.utc(date_or_time.year, date_or_time.month, date_or_time.day, 12)
-      time = date_or_time.is_a?(Time) ? date_or_time : noon
-      epoch = Epoch.from_time(time)
-      sun = new(time: time)
-      right_ascension = sun
-        .apparent_ecliptic_coordinates
-        .to_apparent_equatorial(epoch: epoch)
-        .right_ascension
-      t = (epoch - Epoch::J2000) / Constants::DAYS_PER_JULIAN_MILLENIA
+    def equation_of_time
+      right_ascension = apparent.equatorial.right_ascension
+      t = (@instant.julian_date - Epoch::J2000) / Constants::DAYS_PER_JULIAN_MILLENIA
       l0 = (280.4664567 +
         360_007.6982779 * t +
         0.03032028 * t**2 +
         t**3 / 49_931 -
         t**4 / 15_300 -
         t**5 / 2_000_000) % Constants::DEGREES_PER_CIRCLE
-      nutation = Nutation.for_ecliptic_longitude(epoch: epoch)
-      obliquity = TrueObliquity.for_epoch(epoch)
+      nutation = Nutation.new(instant: instant).nutation_in_longitude
+      obliquity = TrueObliquity.for_epoch(@instant.julian_date)
 
       (
         Angle
-         .from_degrees(
-           l0 -
-           Constants::EQUATION_OF_TIME_CONSTANT -
-           right_ascension.degrees +
-           nutation.degrees * obliquity.cos
-         ).hours * Constants::SECONDS_PER_HOUR
+          .from_degrees(
+            l0 -
+              Constants::EQUATION_OF_TIME_CONSTANT -
+              right_ascension.degrees +
+              nutation.degrees * obliquity.cos
+          ).hours * Constants::SECONDS_PER_HOUR
       ).round
     end
-
-    # Source:
-    #  Title: Celestial Calculations
-    #  Author: J. L. Lawrence
-    #  Edition: MIT Press
-    #  Chapter: 6 - The Sun
-
-    # @param time [Time] Considered time
-    def initialize(time:)
-      @time = time
-    end
-
-    def epoch
-      @epoch ||= Epoch.from_time(@time)
-    end
-
-    def true_ecliptic_coordinates
-      Coordinates::Ecliptic.new(
-        latitude: Angle.zero,
-        longitude: true_longitude
-      )
-    end
-
-    def apparent_ecliptic_coordinates
-      nutation = Nutation.for_ecliptic_longitude(epoch: epoch)
-      longitude_with_aberration = Aberration.for_ecliptic_coordinates(
-        coordinates: true_ecliptic_coordinates,
-        epoch: epoch
-      ).longitude
-      apparent_longitude = nutation + longitude_with_aberration
-
-      Coordinates::Ecliptic.new(
-        latitude: Angle.zero,
-        longitude: apparent_longitude
-      )
-    end
-
-    # Computes the Sun's horizontal coordinates
-    #
-    # @param observer [Astronoby::Observer] Observer of the event
-    # @return [Astronoby::Coordinates::Horizontal] Sun's horizontal coordinates
-    def horizontal_coordinates(observer:)
-      apparent_ecliptic_coordinates
-        .to_apparent_equatorial(epoch: epoch)
-        .to_horizontal(time: @time, observer: observer)
-    end
-
-    # @param observer [Astronoby::Observer] Observer of the event
-    # @return [Astronoby::Events::ObservationEvents] Sun'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
-      yesterday_epoch = Epoch.from_time(yesterday_midnight_terrestrial_time)
-      today_midnight_terrestrial_time =
-        Time.utc(today.year, today.month, today.day) - leap_seconds
-      today_epoch = Epoch.from_time(today_midnight_terrestrial_time)
-      tomorrow = today.next_day
-      tomorrow_midnight_terrestrial_time =
-        Time.utc(tomorrow.year, tomorrow.month, tomorrow.day) - leap_seconds
-      tomorrow_epoch = Epoch.from_time(tomorrow_midnight_terrestrial_time)
-
-      coordinates_of_the_previous_day = self.class
-        .new(time: yesterday_midnight_terrestrial_time)
-        .apparent_ecliptic_coordinates
-        .to_apparent_equatorial(epoch: yesterday_epoch)
-      coordinates_of_the_day = self.class
-        .new(time: today_midnight_terrestrial_time)
-        .apparent_ecliptic_coordinates
-        .to_apparent_equatorial(epoch: today_epoch)
-      coordinates_of_the_next_day = self.class
-        .new(time: tomorrow_midnight_terrestrial_time)
-        .apparent_ecliptic_coordinates
-        .to_apparent_equatorial(epoch: tomorrow_epoch)
-
-      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: Angle.from_degrees(angular_size.degrees / 2)
-      )
-    end
-
-    # @param observer [Astronoby::Observer] Observer of the events
-    # @return [Astronoby::Events::TwilightEvents] Sun's twilight events
-    def twilight_events(observer:)
-      Events::TwilightEvents.new(sun: self, observer: observer)
-    end
-
-    # @return [Astronoby::Distance] Earth-Sun distance
-    def earth_distance
-      Distance.from_meters(
-        SEMI_MAJOR_AXIS_IN_METERS / distance_angular_size_factor
-      )
-    end
-
-    # @return [Astronoby::Angle] Apparent Sun's angular size
-    def angular_size
-      Angle.from_degrees(
-        ANGULAR_DIAMETER.degrees * distance_angular_size_factor
-      )
-    end
-
-    # @return [Astronoby::Angle] Sun's true anomaly
-    def true_anomaly
-      eccentric_anomaly = Util::Astrodynamics.eccentric_anomaly_newton_raphson(
-        mean_anomaly,
-        orbital_eccentricity.degrees,
-        2e-06,
-        10
-      )
-
-      tan = Math.sqrt(
-        (1 + orbital_eccentricity.degrees) / (1 - orbital_eccentricity.degrees)
-      ) * Math.tan(eccentric_anomaly.radians / 2)
-
-      Angle.from_degrees(
-        (Angle.atan(tan).degrees * 2) % Constants::DEGREES_PER_CIRCLE
-      )
-    end
-
-    # @return [Astronoby::Angle] Sun's mean anomaly
-    def mean_anomaly
-      Angle.from_degrees(
-        (longitude_at_base_epoch - longitude_at_perigee).degrees %
-          Constants::DEGREES_PER_CIRCLE
-      )
-    end
-
-    # @return [Astronoby::Angle] Sun's longitude at perigee
-    def longitude_at_perigee
-      Angle.from_degrees(
-        (281.2208444 + 1.719175 * centuries + 0.000452778 * centuries**2) %
-          Constants::DEGREES_PER_CIRCLE
-      )
-    end
-
-    # @return [Astronoby::Angle] Sun's orbital eccentricity
-    def orbital_eccentricity
-      Angle.from_degrees(
-        (0.01675104 - 0.0000418 * centuries - 0.000000126 * centuries**2) %
-          Constants::DEGREES_PER_CIRCLE
-      )
-    end
-
-    private
-
-    def true_longitude
-      Angle.from_degrees(
-        (true_anomaly + longitude_at_perigee).degrees %
-          Constants::DEGREES_PER_CIRCLE
-      )
-    end
-
-    def days_since_epoch
-      Epoch::DEFAULT_EPOCH - epoch
-    end
-
-    def centuries
-      @centuries ||= (epoch - Epoch::J1900) / Constants::DAYS_PER_JULIAN_CENTURY
-    end
-
-    def longitude_at_base_epoch
-      Angle.from_degrees(
-        (279.6966778 + 36000.76892 * centuries + 0.0003025 * centuries**2) %
-          Constants::DEGREES_PER_CIRCLE
-      )
-    end
-
-    def distance_angular_size_factor
-      term1 = 1 + orbital_eccentricity.degrees * true_anomaly.cos
-      term2 = 1 - orbital_eccentricity.degrees**2
-
-      term1 / term2
-    end
   end
 end

data/lib/astronoby/bodies/uranus.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Astronoby
+  class Uranus < SolarSystemBody
+    EQUATORIAL_RADIUS = Distance.from_meters(25_559_000)
+
+    def self.ephemeris_segments(_ephem_source)
+      [[SOLAR_SYSTEM_BARYCENTER, URANUS_BARYCENTER]]
+    end
+  end
+end

data/lib/astronoby/bodies/venus.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Astronoby
+  class Venus < SolarSystemBody
+    EQUATORIAL_RADIUS = Distance.from_meters(6_051_800)
+
+    def self.ephemeris_segments(_ephem_source)
+      [[SOLAR_SYSTEM_BARYCENTER, VENUS_BARYCENTER]]
+    end
+  end
+end

data/lib/astronoby/constants.rb

@@ -15,8 +15,8 @@ module Astronoby
 
     SECONDS_PER_HOUR = SECONDS_PER_MINUTE * MINUTES_PER_HOUR
     SECONDS_PER_DAY = SECONDS_PER_HOUR * HOURS_PER_DAY
-    SECONDS_PER_DEGREE = SECONDS_PER_MINUTE * MINUTES_PER_DEGREE
     RADIAN_PER_HOUR = Math::PI / 12.0
+    MICROSECOND_IN_DAYS = 1.0 / SECONDS_PER_DAY / 1e6
 
     PI_IN_DEGREES = 180.0
 
@@ -26,6 +26,18 @@ module Astronoby
     ASTRONOMICAL_UNIT_IN_METERS = 149_597_870_700
     EARTH_EQUATORIAL_RADIUS_IN_METERS = 6378140
 
+    # WGS84 Earth Constants
+    WGS84_EARTH_EQUATORIAL_RADIUS_IN_METERS = 6378137
+    WGS84_INVERSE_FLATTENING = 298.257223563
+    WGS84_FLATTENING = 1.0 / WGS84_INVERSE_FLATTENING
+    WGS84_ECCENTICITY_SQUARED = 2.0 * WGS84_FLATTENING - WGS84_FLATTENING * WGS84_FLATTENING
+
+    LIGHT_SPEED_M_PER_S = 299_792_458
+
     EARTH_FLATTENING_CORRECTION = 0.996647
+
+    EARTH_ANGULAR_VELOCITY_RAD_PER_S = 7.2921159e-5
+
+    TAI_TT_OFFSET = 32.184
   end
 end

data/lib/astronoby/coordinates/ecliptic.rb

@@ -10,43 +10,8 @@ module Astronoby
         @longitude = longitude
       end
 
-      # Source:
-      #  Title: Celestial Calculations
-      #  Author: J. L. Lawrence
-      #  Edition: MIT Press
-      #  Chapter: 4 - Orbits and Coordinate Systems
-
-      def to_true_equatorial(epoch:)
-        mean_obliquity = MeanObliquity.for_epoch(epoch)
-        to_equatorial(obliquity: mean_obliquity, epoch: epoch)
-      end
-
-      def to_apparent_equatorial(epoch:)
-        apparent_obliquity = TrueObliquity.for_epoch(epoch)
-        to_equatorial(obliquity: apparent_obliquity, epoch: epoch)
-      end
-
-      private
-
-      def to_equatorial(obliquity:, epoch:)
-        y = Angle.from_radians(
-          @longitude.sin * obliquity.cos -
-            @latitude.tan * obliquity.sin
-        )
-        x = Angle.from_radians(@longitude.cos)
-        r = Angle.atan(y.radians / x.radians)
-        right_ascension = Util::Trigonometry.adjustement_for_arctangent(y, x, r)
-
-        declination = Angle.asin(
-          @latitude.sin * obliquity.cos +
-            @latitude.cos * obliquity.sin * @longitude.sin
-        )
-
-        Equatorial.new(
-          right_ascension: right_ascension,
-          declination: declination,
-          epoch: epoch
-        )
+      def self.zero
+        new(latitude: Angle.zero, longitude: Angle.zero)
       end
     end
   end

data/lib/astronoby/coordinates/equatorial.rb

@@ -17,6 +17,30 @@ module Astronoby
         @epoch = epoch
       end
 
+      def self.zero
+        new(declination: Angle.zero, right_ascension: Angle.zero)
+      end
+
+      def self.from_position_vector(position)
+        return zero if position.zero?
+
+        term1 = position.z.m
+        term2 = position.magnitude.m
+        declination = Angle.asin(term1 / term2)
+
+        term1 = position.y.m
+        term2 = position.x.m
+        angle = Angle.atan(term1 / term2)
+        right_ascension =
+          Astronoby::Util::Trigonometry.adjustement_for_arctangent(
+            term1,
+            term2,
+            angle
+          )
+
+        new(declination: declination, right_ascension: right_ascension)
+      end
+
       def compute_hour_angle(time:, longitude:)
         lst = GreenwichSiderealTime
           .from_utc(time.utc)
@@ -38,6 +62,7 @@ module Astronoby
 
         t1 = @declination.sin - latitude.sin * altitude.sin
         t2 = t1 / (latitude.cos * altitude.cos)
+        t2 = t2.clamp(-1, 1)
         azimuth = Angle.acos(t2)
 
         if ha.sin.positive?
@@ -78,13 +103,6 @@ module Astronoby
           longitude: longitude
         )
       end
-
-      def to_epoch(epoch)
-        Precession.for_equatorial_coordinates(
-          coordinates: self,
-          epoch: epoch
-        )
-      end
     end
   end
 end

data/lib/astronoby/coordinates/horizontal.rb

@@ -14,52 +14,6 @@ module Astronoby
         @altitude = altitude
         @observer = observer
       end
-
-      def to_equatorial(time:)
-        t0 = @altitude.sin * latitude.sin +
-          @altitude.cos * latitude.cos * @azimuth.cos
-
-        declination = Angle.asin(t0)
-
-        t1 = @altitude.sin - latitude.sin * declination.sin
-
-        hour_angle_degrees = Angle
-          .acos(t1 / (latitude.cos * declination.cos))
-          .degrees
-
-        if @azimuth.sin.positive?
-          hour_angle_degrees = Angle
-            .from_degrees(Constants::DEGREES_PER_CIRCLE - hour_angle_degrees)
-            .degrees
-        end
-
-        hour_angle_hours = Angle.from_degrees(hour_angle_degrees).hours
-        lst = GreenwichSiderealTime
-          .from_utc(time.utc)
-          .to_lst(longitude: longitude)
-        right_ascension_decimal = lst.time - hour_angle_hours
-
-        if right_ascension_decimal.negative?
-          right_ascension_decimal += Constants::HOURS_PER_DAY
-        end
-
-        right_ascension = Angle.from_hours(right_ascension_decimal)
-
-        Equatorial.new(
-          right_ascension: right_ascension,
-          declination: declination
-        )
-      end
-
-      private
-
-      def latitude
-        @observer.latitude
-      end
-
-      def longitude
-        @observer.longitude
-      end
     end
   end
 end

data/lib/astronoby/corrections/light_time_delay.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Astronoby
+  module Correction
+    class LightTimeDelay
+      LIGHT_SPEED_CORRECTION_MAXIMUM_ITERATIONS = 10
+      LIGHT_SPEED_CORRECTION_PRECISION = 1e-12
+
+      def self.compute(center:, target:, ephem:)
+        new(center: center, target: target, ephem: ephem).compute
+      end
+
+      def initialize(center:, target:, ephem:)
+        @center = center
+        @target = target
+        @ephem = ephem
+      end
+
+      def delay
+        @_delay ||= begin
+          compute
+          @delay
+        end
+      end
+
+      def compute
+        @corrected_position ||= begin
+          corrected_position = Vector[
+            Distance.zero,
+            Distance.zero,
+            Distance.zero
+          ]
+          corrected_velocity = Vector[
+            Velocity.zero,
+            Velocity.zero,
+            Velocity.zero
+          ]
+          @delay = initial_delta_in_seconds
+
+          LIGHT_SPEED_CORRECTION_MAXIMUM_ITERATIONS.times do
+            new_instant = Instant.from_terrestrial_time(
+              instant.tt - @delay / Constants::SECONDS_PER_DAY
+            )
+            corrected = @target
+              .target_body
+              .geometric(ephem: @ephem, instant: new_instant)
+            corrected_position = corrected.position
+            corrected_velocity = corrected.velocity
+
+            corrected_distance_in_km = Math.sqrt(
+              (corrected_position.x.km - position.x.km)**2 +
+                (corrected_position.y.km - position.y.km)**2 +
+                (corrected_position.z.km - position.z.km)**2
+            )
+
+            new_delay = corrected_distance_in_km / Velocity.light_speed.kmps
+
+            break if (new_delay - @delay).abs < LIGHT_SPEED_CORRECTION_PRECISION
+
+            @delay = new_delay
+          end
+
+          [corrected_position, corrected_velocity]
+        end
+      end
+
+      private
+
+      def position
+        @position ||= @center.position
+      end
+
+      def instant
+        @center.instant
+      end
+
+      def initial_delta_in_seconds
+        distance_between_bodies_in_km / Velocity.light_speed.kmps
+      end
+
+      def distance_between_bodies_in_km
+        Math.sqrt(
+          (@target.position.x.km - position.x.km)**2 +
+            (@target.position.y.km - position.y.km)**2 +
+            (@target.position.z.km - position.z.km)**2
+        )
+      end
+    end
+  end
+end