astronoby 0.2.0 → 0.4.0

data/lib/astronoby/bodies/sun.rb

@@ -3,31 +3,64 @@
 module Astronoby
   class Sun
     SEMI_MAJOR_AXIS_IN_METERS = 149_598_500_000
-    ANGULAR_DIAMETER = Angle.as_degrees(0.533128)
-    INTERPOLATION_FACTOR = BigDecimal("24.07")
+    ANGULAR_DIAMETER = Angle.from_degrees(0.533128)
+    INTERPOLATION_FACTOR = 24.07
+
+    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
 
     # Source:
-    #  Title: Practical Astronomy with your Calculator or Spreadsheet
-    #  Authors: Peter Duffett-Smith and Jonathan Zwart
-    #  Edition: Cambridge University Press
-    #  Chapter: 51 - The equation of time
+    #  Title: Astronomical Algorithms
+    #  Author: Jean Meeus
+    #  Edition: 2nd edition
+    #  Chapter: 28 - Equation of Time
 
-    # @param date [Date] Requested date
+    # @param date_or_time [Date, Time] Requested date
     # @return [Integer] Equation of time in seconds
-    def self.equation_of_time(date:)
-      noon = Time.utc(date.year, date.month, date.day, 12)
-      epoch_at_noon = Epoch.from_time(noon)
-      sun_at_noon = new(epoch: epoch_at_noon)
-      equatorial_hours = sun_at_noon
-        .ecliptic_coordinates
-        .to_equatorial(epoch: epoch_at_noon)
+    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
-        .hours
-      gst = GreenwichSiderealTime
-        .new(date: date, time: equatorial_hours)
-        .to_utc
-
-      (noon - gst).to_i
+      t = (epoch - 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)
+
+      (
+        Angle
+         .from_degrees(
+           l0 -
+           Constants::EQUATION_OF_TIME_CONSTANT -
+           right_ascension.degrees +
+           nutation.degrees * obliquity.cos
+         ).hours * Constants::SECONDS_PER_HOUR
+      ).round
     end
 
     # Source:
@@ -36,18 +69,33 @@ module Astronoby
     #  Edition: MIT Press
     #  Chapter: 6 - The Sun
 
-    # @param epoch [Numeric] Considered epoch, in Julian days
-    def initialize(epoch:)
-      @epoch = epoch
+    # @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
 
-    # @return [Astronoby::Coordinates::Ecliptic] Sun's ecliptic coordinates
-    def ecliptic_coordinates
+    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: Angle.as_degrees(
-          (true_anomaly + longitude_at_perigee).degrees % 360
-        )
+        longitude: apparent_longitude
       )
     end
 
@@ -57,63 +105,55 @@ module Astronoby
     # @param longitude [Astronoby::Angle] Longitude of the observer
     # @return [Astronoby::Coordinates::Horizontal] Sun's horizontal coordinates
     def horizontal_coordinates(latitude:, longitude:)
-      time = Epoch.to_utc(@epoch)
-
-      ecliptic_coordinates
-        .to_equatorial(epoch: @epoch)
-        .to_horizontal(time: time, latitude: latitude, longitude: longitude)
+      apparent_ecliptic_coordinates
+        .to_apparent_equatorial(epoch: epoch)
+        .to_horizontal(time: @time, latitude: latitude, longitude: longitude)
     end
 
     # @param observer [Astronoby::Observer] Observer of the event
-    # @return [Time] Time of sunrise
-    def rising_time(observer:)
-      event_date = Epoch.to_utc(@epoch).to_date
-      lst1 = event_local_sidereal_time_for_date(event_date, observer, :rising)
-      next_day = event_date.next_day(1)
-      lst2 = event_local_sidereal_time_for_date(next_day, observer, :rising)
-      time = (INTERPOLATION_FACTOR * lst1) / (INTERPOLATION_FACTOR + lst1 - lst2)
-
-      LocalSiderealTime.new(
-        date: event_date,
-        time: time,
-        longitude: observer.longitude
-      ).to_gst.to_utc
-    end
-
-    # @param observer [Astronoby::Observer] Observer of the event
-    # @return [Astronoby::Angle, nil] Azimuth of sunrise
-    def rising_azimuth(observer:)
-      equatorial_coordinates = ecliptic_coordinates.to_equatorial(epoch: @epoch)
-      Body.new(equatorial_coordinates).rising_azimuth(
-        latitude: observer.latitude,
-        vertical_shift: vertical_shift
+    # @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 event
-    # @return [Time] Time of sunset
-    def setting_time(observer:)
-      event_date = Epoch.to_utc(@epoch).to_date
-      lst1 = event_local_sidereal_time_for_date(event_date, observer, :setting)
-      next_day = event_date.next_day(1)
-      lst2 = event_local_sidereal_time_for_date(next_day, observer, :setting)
-      time = (INTERPOLATION_FACTOR * lst1) / (INTERPOLATION_FACTOR + lst1 - lst2)
-
-      LocalSiderealTime.new(
-        date: event_date,
-        time: time,
-        longitude: observer.longitude
-      ).to_gst.to_utc
-    end
-
-    # @param observer [Astronoby::Observer] Observer of the event
-    # @return [Astronoby::Angle, nil] Azimuth of sunset
-    def setting_azimuth(observer:)
-      equatorial_coordinates = ecliptic_coordinates.to_equatorial(epoch: @epoch)
-      Body.new(equatorial_coordinates).setting_azimuth(
-        latitude: observer.latitude,
-        vertical_shift: vertical_shift
-      )
+    # @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 [Numeric] Earth-Sun distance in meters
@@ -123,7 +163,9 @@ module Astronoby
 
     # @return [Astronoby::Angle] Apparent Sun's angular size
     def angular_size
-      Angle.as_degrees(ANGULAR_DIAMETER.degrees * distance_angular_size_factor)
+      Angle.from_degrees(
+        ANGULAR_DIAMETER.degrees * distance_angular_size_factor
+      )
     end
 
     # @return [Astronoby::Angle] Sun's true anomaly
@@ -139,42 +181,55 @@ module Astronoby
         (1 + orbital_eccentricity.degrees) / (1 - orbital_eccentricity.degrees)
       ) * Math.tan(eccentric_anomaly.radians / 2)
 
-      Angle.as_degrees((Angle.atan(tan).degrees * 2) % 360)
+      Angle.from_degrees(
+        (Angle.atan(tan).degrees * 2) % Constants::DEGREES_PER_CIRCLE
+      )
     end
 
     # @return [Astronoby::Angle] Sun's longitude at perigee
     def longitude_at_perigee
-      Angle.as_degrees(
-        (281.2208444 + 1.719175 * centuries + 0.000452778 * centuries**2) % 360
+      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.as_degrees(
-        (0.01675104 - 0.0000418 * centuries - 0.000000126 * centuries**2) % 360
+      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 mean_anomaly
-      Angle.as_degrees(
-        (longitude_at_base_epoch - longitude_at_perigee).degrees % 360
+      Angle.from_degrees(
+        (longitude_at_base_epoch - longitude_at_perigee).degrees %
+          Constants::DEGREES_PER_CIRCLE
       )
     end
 
     def days_since_epoch
-      Epoch::DEFAULT_EPOCH - @epoch
+      Epoch::DEFAULT_EPOCH - epoch
     end
 
     def centuries
-      @centuries ||= (@epoch - Epoch::J1900) / Epoch::DAYS_PER_JULIAN_CENTURY
+      @centuries ||= (epoch - Epoch::J1900) / Constants::DAYS_PER_JULIAN_CENTURY
     end
 
     def longitude_at_base_epoch
-      Angle.as_degrees(
-        (279.6966778 + 36000.76892 * centuries + 0.0003025 * centuries**2) % 360
+      Angle.from_degrees(
+        (279.6966778 + 36000.76892 * centuries + 0.0003025 * centuries**2) %
+          Constants::DEGREES_PER_CIRCLE
       )
     end
 
@@ -184,43 +239,5 @@ module Astronoby
 
       term1 / term2
     end
-
-    def event_local_sidereal_time_for_date(date, observer, event)
-      midnight_utc = Time.utc(date.year, date.month, date.day)
-      epoch = Epoch.from_time(midnight_utc)
-      sun_at_midnight = self.class.new(epoch: epoch)
-      shift = Body::DEFAULT_REFRACTION_VERTICAL_SHIFT +
-        GeocentricParallax.angle(distance: sun_at_midnight.earth_distance) +
-        Angle.as_degrees(sun_at_midnight.angular_size.degrees / 2)
-      ecliptic_coordinates = sun_at_midnight.ecliptic_coordinates
-      equatorial_coordinates = ecliptic_coordinates.to_equatorial(epoch: epoch)
-
-      event_time = if event == :rising
-        Body.new(equatorial_coordinates).rising_time(
-          latitude: observer.latitude,
-          longitude: observer.longitude,
-          date: midnight_utc.to_date,
-          vertical_shift: shift
-        )
-      else
-        Body.new(equatorial_coordinates).setting_time(
-          latitude: observer.latitude,
-          longitude: observer.longitude,
-          date: midnight_utc.to_date,
-          vertical_shift: shift
-        )
-      end
-
-      GreenwichSiderealTime
-        .from_utc(event_time.utc)
-        .to_lst(longitude: observer.longitude)
-        .time
-    end
-
-    def vertical_shift
-      Astronoby::Body::DEFAULT_REFRACTION_VERTICAL_SHIFT +
-        Astronoby::GeocentricParallax.angle(distance: earth_distance) +
-        Astronoby::Angle.as_degrees(angular_size.degrees / 2)
-    end
   end
 end

data/lib/astronoby/constants.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Astronoby
+  class Constants
+    DAYS_PER_JULIAN_CENTURY = 36525.0
+    DAYS_PER_JULIAN_MILLENIA = DAYS_PER_JULIAN_CENTURY * 10
+
+    HOURS_PER_DAY = 24.0
+    DEGREES_PER_CIRCLE = 360.0
+    RADIANS_PER_CIRCLE = 2 * Math::PI
+
+    SECONDS_PER_MINUTE = 60.0
+    MINUTES_PER_HOUR = 60.0
+    MINUTES_PER_DEGREE = 60.0
+
+    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
+
+    PI_IN_DEGREES = 180.0
+
+    EQUATION_OF_TIME_CONSTANT = 0.0057183
+  end
+end

data/lib/astronoby/coordinates/ecliptic.rb

@@ -15,20 +15,31 @@ module Astronoby
       #  Author: J. L. Lawrence
       #  Edition: MIT Press
       #  Chapter: 4 - Orbits and Coordinate Systems
-      def to_equatorial(epoch:)
+
+      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
 
-        y = Angle.as_radians(
-          @longitude.sin * mean_obliquity.cos -
-          @latitude.tan * mean_obliquity.sin
+      def to_equatorial(obliquity:, epoch:)
+        y = Angle.from_radians(
+          @longitude.sin * obliquity.cos -
+            @latitude.tan * obliquity.sin
         )
-        x = Angle.as_radians(@longitude.cos)
+        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 * mean_obliquity.cos +
-          @latitude.cos * mean_obliquity.sin * @longitude.sin
+          @latitude.sin * obliquity.cos +
+            @latitude.cos * obliquity.sin * @longitude.sin
         )
 
         Equatorial.new(

data/lib/astronoby/coordinates/equatorial.rb

@@ -23,9 +23,9 @@ module Astronoby
           .to_lst(longitude: longitude)
 
         ha = (lst.time - @right_ascension.hours)
-        ha += 24 if ha.negative?
+        ha += Constants::HOURS_PER_DAY if ha.negative?
 
-        Angle.as_hours(ha)
+        Angle.from_hours(ha)
       end
 
       def to_horizontal(time:, latitude:, longitude:)
@@ -39,7 +39,8 @@ module Astronoby
         azimuth = Angle.acos(t2)
 
         if ha.sin.positive?
-          azimuth = Angle.as_degrees(BigDecimal("360") - azimuth.degrees)
+          azimuth =
+            Angle.from_degrees(Constants::DEGREES_PER_CIRCLE - azimuth.degrees)
         end
 
         Horizontal.new(
@@ -58,11 +59,11 @@ module Astronoby
       def to_ecliptic(epoch:)
         mean_obliquity = MeanObliquity.for_epoch(epoch)
 
-        y = Angle.as_radians(
+        y = Angle.from_radians(
           @right_ascension.sin * mean_obliquity.cos +
           @declination.tan * mean_obliquity.sin
         )
-        x = Angle.as_radians(@right_ascension.cos)
+        x = Angle.from_radians(@right_ascension.cos)
         r = Angle.atan(y.radians / x.radians)
         longitude = Util::Trigonometry.adjustement_for_arctangent(y, x, r)
 

data/lib/astronoby/coordinates/horizontal.rb

@@ -31,17 +31,21 @@ module Astronoby
 
         if @azimuth.sin.positive?
           hour_angle_degrees = Angle
-            .as_degrees(BigDecimal("360") - hour_angle_degrees)
+            .from_degrees(Constants::DEGREES_PER_CIRCLE - hour_angle_degrees)
             .degrees
         end
 
-        hour_angle_hours = Angle.as_degrees(hour_angle_degrees).hours
+        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
-        right_ascension_decimal += 24 if right_ascension_decimal.negative?
-        right_ascension = Angle.as_hours(right_ascension_decimal)
+
+        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,

data/lib/astronoby/epoch.rb

@@ -9,8 +9,6 @@ module Astronoby
     J2000 = 2451545.0
 
     DEFAULT_EPOCH = J2000
-    DAYS_PER_JULIAN_CENTURY = 36525.0
-
     JULIAN_DAY_NUMBER_OFFSET = 0.5
 
     def self.from_time(time)

data/lib/astronoby/equinox_solstice.rb

@@ -101,14 +101,14 @@ module Astronoby
     end
 
     def compute
-      t = (julian_day - Epoch::J2000) / Epoch::DAYS_PER_JULIAN_CENTURY
-      w = Angle.as_degrees(35999.373 * t) - Angle.as_degrees(2.47)
+      t = (julian_day - Epoch::J2000) / Constants::DAYS_PER_JULIAN_CENTURY
+      w = Angle.from_degrees(35999.373 * t) - Angle.from_degrees(2.47)
       delta = 1 +
         0.0334 * w.cos +
-        0.0007 * Angle.as_degrees(w.degrees * 2).cos
+        0.0007 * Angle.from_degrees(w.degrees * 2).cos
 
       s = PERIODIC_TERMS.sum do |a, b, c|
-        a * (Angle.as_degrees(b) + Angle.as_degrees(c * t)).cos
+        a * (Angle.from_degrees(b) + Angle.from_degrees(c * t)).cos
       end
 
       delta_days = 0.00001 * s / delta
@@ -130,24 +130,11 @@ module Astronoby
     end
 
     def correction(epoch)
-      sun = Sun.new(epoch: epoch)
+      time = Epoch.to_utc(epoch)
+      sun = Sun.new(time: time)
+      longitude = sun.apparent_ecliptic_coordinates.longitude
 
-      nutation = Nutation.for_ecliptic_longitude(epoch: epoch)
-
-      earth_radius_vector = 1 / (
-        1 +
-          sun.orbital_eccentricity.degrees *
-            (sun.true_anomaly - sun.longitude_at_perigee).cos
-      )
-      aberration = Angle.as_degrees(
-        Angle.as_dms(0, 0, 20.4898).degrees / -earth_radius_vector
-      )
-
-      corrected_longitude = sun.ecliptic_coordinates.longitude +
-        nutation +
-        aberration
-
-      58 * Angle.as_degrees(@event * 90 - corrected_longitude.degrees).sin
+      58 * Angle.from_degrees(@event * 90 - longitude.degrees).sin
     end
   end
 end