astronoby 0.3.0 → 0.5.0

data/lib/astronoby/bodies/moon.rb

@@ -0,0 +1,335 @@
+# frozen_string_literal: true
+
+module Astronoby
+  class Moon
+    SEMIDIAMETER_VARIATION = 0.7275
+    MEAN_GEOCENTRIC_DISTANCE = Astronoby::Distance.from_meters(385_000_560)
+
+    # Source:
+    #  Title: Astronomical Algorithms
+    #  Author: Jean Meeus
+    #  Edition: 2nd edition
+    #  Chapter: 49 - Phases of the Moon
+
+    # @param year [Integer] Requested year
+    # @param month [Integer] Requested month
+    # @return [Array<Astronoby::MoonPhase>] Moon phases for the requested year
+    def self.monthly_phase_events(year:, month:)
+      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
+
+    # @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
+      )
+    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
+      )
+    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
+      )
+    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
+
+    # Source:
+    #  Title: Astronomical Algorithms
+    #  Author: Jean Meeus
+    #  Edition: 2nd edition
+    #  Chapter: 48 - Illuminated Fraction of the Moon's Disk
+
+    # @return [Angle] Moon's phase angle
+    def phase_angle
+      @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
+        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
+        )
+
+        term1 = sun.earth_distance.km * geocentric_elongation.sin
+        term2 = distance.km - sun.earth_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
+      )
+    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)
+    end
+  end
+end

data/lib/astronoby/bodies/sun.rb

@@ -4,30 +4,63 @@ module Astronoby
   class Sun
     SEMI_MAJOR_AXIS_IN_METERS = 149_598_500_000
     ANGULAR_DIAMETER = Angle.from_degrees(0.533128)
-    INTERPOLATION_FACTOR = BigDecimal("24.07")
+    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
+    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_at_noon)
+        .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,9 +69,13 @@ 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
@@ -49,10 +86,10 @@ module Astronoby
     end
 
     def apparent_ecliptic_coordinates
-      nutation = Nutation.for_ecliptic_longitude(epoch: @epoch)
+      nutation = Nutation.for_ecliptic_longitude(epoch: epoch)
       longitude_with_aberration = Aberration.for_ecliptic_coordinates(
         coordinates: true_ecliptic_coordinates,
-        epoch: @epoch
+        epoch: epoch
       ).longitude
       apparent_longitude = nutation + longitude_with_aberration
 
@@ -64,74 +101,65 @@ module Astronoby
 
     # Computes the Sun's horizontal coordinates
     #
-    # @param latitude [Astronoby::Angle] Latitude of the observer
-    # @param longitude [Astronoby::Angle] Longitude of the observer
+    # @param observer [Astronoby::Observer] Observer of the event
     # @return [Astronoby::Coordinates::Horizontal] Sun's horizontal coordinates
-    def horizontal_coordinates(latitude:, longitude:)
-      time = Epoch.to_utc(@epoch)
-
+    def horizontal_coordinates(observer:)
       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
+        .to_apparent_equatorial(epoch: epoch)
+        .to_horizontal(time: @time, observer: observer)
     end
 
     # @param observer [Astronoby::Observer] Observer of the event
-    # @return [Astronoby::Angle, nil] Azimuth of sunrise
-    def rising_azimuth(observer:)
-      equatorial_coordinates = apparent_ecliptic_coordinates
-        .to_apparent_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
+    # @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
 
-    # @param observer [Astronoby::Observer] Observer of the event
-    # @return [Astronoby::Angle, nil] Azimuth of sunset
-    def setting_azimuth(observer:)
-      equatorial_coordinates = apparent_ecliptic_coordinates
-        .to_apparent_equatorial(epoch: @epoch)
-      Body.new(equatorial_coordinates).setting_azimuth(
-        latitude: observer.latitude,
-        vertical_shift: vertical_shift
-      )
-    end
-
-    # @return [Numeric] Earth-Sun distance in meters
+    # @return [Astronoby::Distance] Earth-Sun distance
     def earth_distance
-      SEMI_MAJOR_AXIS_IN_METERS / distance_angular_size_factor
+      Distance.from_meters(
+        SEMI_MAJOR_AXIS_IN_METERS / distance_angular_size_factor
+      )
     end
 
     # @return [Astronoby::Angle] Apparent Sun's angular size
@@ -154,20 +182,32 @@ module Astronoby
         (1 + orbital_eccentricity.degrees) / (1 - orbital_eccentricity.degrees)
       ) * Math.tan(eccentric_anomaly.radians / 2)
 
-      Angle.from_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 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) % 360
+        (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) % 360
+        (0.01675104 - 0.0000418 * centuries - 0.000000126 * centuries**2) %
+          Constants::DEGREES_PER_CIRCLE
       )
     end
 
@@ -175,27 +215,23 @@ module Astronoby
 
     def true_longitude
       Angle.from_degrees(
-        (true_anomaly + longitude_at_perigee).degrees % 360
-      )
-    end
-
-    def mean_anomaly
-      Angle.from_degrees(
-        (longitude_at_base_epoch - longitude_at_perigee).degrees % 360
+        (true_anomaly + 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.from_degrees(
-        (279.6966778 + 36000.76892 * centuries + 0.0003025 * centuries**2) % 360
+        (279.6966778 + 36000.76892 * centuries + 0.0003025 * centuries**2) %
+          Constants::DEGREES_PER_CIRCLE
       )
     end
 
@@ -205,44 +241,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.from_degrees(sun_at_midnight.angular_size.degrees / 2)
-      ecliptic_coordinates = sun_at_midnight.apparent_ecliptic_coordinates
-      equatorial_coordinates = ecliptic_coordinates
-        .to_apparent_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.from_degrees(angular_size.degrees / 2)
-    end
   end
 end