astronoby 0.3.0 → 0.5.0

data/lib/astronoby/events/rise_transit_set_iteration.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+module Astronoby
+  class RiseTransitSetIteration
+    EARTH_SIDEREAL_ROTATION_RATE = 360.98564736629
+
+    # Source:
+    #  Title: Astronomical Algorithms
+    #  Author: Jean Meeus
+    #  Edition: 2nd edition
+    #  Chapter: 15 - Rising, Transit, and Setting
+
+    # @param observer [Astronoby::Observer] Observer
+    # @param date [Date] Date of the event
+    # @param coordinates_of_the_previous_day [Astronoby::Coordinates::Equatorial]
+    #  Coordinates of the body of the previous day
+    # @param coordinates_of_the_day [Astronoby::Coordinates::Equatorial]
+    #   Coordinates of the body of the day
+    # @param coordinates_of_the_next_day [Astronoby::Coordinates::Equatorial]
+    #   Coordinates of the body of the next day
+    # @param shift [Astronoby::Angle] Altitude shift
+    # @param initial_rising [Float] Initial rising
+    # @param initial_transit [Float] Initial transit
+    # @param initial_setting [Float] Initial setting
+    def initialize(
+      observer:,
+      date:,
+      coordinates_of_the_previous_day:,
+      coordinates_of_the_day:,
+      coordinates_of_the_next_day:,
+      shift:,
+      initial_rising:,
+      initial_transit:,
+      initial_setting:
+    )
+      @observer = observer
+      @date = date
+      @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
+      @shift = shift
+      @initial_rising = initial_rising
+      @initial_transit = initial_transit
+      @initial_setting = initial_setting
+    end
+
+    # @return [Array<Float>] Iteration results
+    def iterate
+      [
+        delta_m_rising,
+        delta_m_transit,
+        delta_m_setting
+      ]
+    end
+
+    private
+
+    def delta_m_rising
+      (local_horizontal_altitude_rising - @shift).degrees./(
+        Constants::DEGREES_PER_CIRCLE *
+          declination_rising.cos *
+          @observer.latitude.cos *
+          local_hour_angle_rising.sin
+      )
+    end
+
+    def delta_m_transit
+      -local_hour_angle_transit.degrees / Constants::DEGREES_PER_CIRCLE
+    end
+
+    def delta_m_setting
+      (local_horizontal_altitude_setting - @shift).degrees./(
+        Constants::DEGREES_PER_CIRCLE *
+          declination_setting.cos *
+          @observer.latitude.cos *
+          local_hour_angle_setting.sin
+      )
+    end
+
+    def observer_longitude
+      # Longitude must be treated positively westwards from the meridian of
+      # Greenwich, and negatively to the east
+      @observer_longitude ||= -@observer.longitude
+    end
+
+    def apparent_gst_at_midnight
+      @apparent_gst_at_midnight ||= Angle.from_hours(
+        GreenwichSiderealTime.from_utc(
+          Time.utc(@date.year, @date.month, @date.day)
+        ).time
+      )
+    end
+
+    def gst_rising
+      @gst_rising ||= Angle.from_degrees(
+        apparent_gst_at_midnight.degrees +
+          EARTH_SIDEREAL_ROTATION_RATE * @initial_rising
+      )
+    end
+
+    def gst_transit
+      @gst_transit ||= Angle.from_degrees(
+        apparent_gst_at_midnight.degrees +
+          EARTH_SIDEREAL_ROTATION_RATE * @initial_transit
+      )
+    end
+
+    def gst_setting
+      @gst_setting ||= Angle.from_degrees(
+        apparent_gst_at_midnight.degrees +
+          EARTH_SIDEREAL_ROTATION_RATE * @initial_setting
+      )
+    end
+
+    def leap_day_portion
+      @leap_day_portion ||= begin
+        leap_seconds = Util::Time.terrestrial_universal_time_delta(@date)
+        leap_seconds / Constants::SECONDS_PER_DAY
+      end
+    end
+
+    def local_hour_angle_rising
+      @local_hour_angle_rising ||=
+        gst_rising - observer_longitude - right_ascension_rising
+    end
+
+    def local_hour_angle_transit
+      gst_transit - observer_longitude - right_ascension_transit
+    end
+
+    def local_hour_angle_setting
+      @local_hour_angle_setting ||=
+        gst_setting - observer_longitude - right_ascension_setting
+    end
+
+    def local_horizontal_altitude_rising
+      Angle.asin(
+        @observer.latitude.sin * declination_rising.sin +
+          @observer.latitude.cos * declination_rising.cos * local_hour_angle_rising.cos
+      )
+    end
+
+    def local_horizontal_altitude_setting
+      Angle.asin(
+        @observer.latitude.sin * declination_setting.sin +
+          @observer.latitude.cos * declination_setting.cos * local_hour_angle_setting.cos
+      )
+    end
+
+    def right_ascension_rising
+      Angle.from_degrees(
+        Util::Maths.interpolate(
+          [
+            @coordinates_of_the_previous_day.right_ascension.degrees,
+            @coordinates_of_the_day.right_ascension.degrees,
+            @coordinates_of_the_next_day.right_ascension.degrees
+          ],
+          @initial_rising + leap_day_portion
+        )
+      )
+    end
+
+    def right_ascension_transit
+      Angle.from_degrees(
+        Util::Maths.interpolate(
+          [
+            @coordinates_of_the_previous_day.right_ascension.degrees,
+            @coordinates_of_the_day.right_ascension.degrees,
+            @coordinates_of_the_next_day.right_ascension.degrees
+          ],
+          @initial_transit + leap_day_portion
+        )
+      )
+    end
+
+    def right_ascension_setting
+      Angle.from_degrees(
+        Util::Maths.interpolate(
+          [
+            @coordinates_of_the_previous_day.right_ascension.degrees,
+            @coordinates_of_the_day.right_ascension.degrees,
+            @coordinates_of_the_next_day.right_ascension.degrees
+          ],
+          @initial_setting + leap_day_portion
+        )
+      )
+    end
+
+    def declination_rising
+      Angle.from_degrees(
+        Util::Maths.interpolate(
+          [
+            @coordinates_of_the_previous_day.declination.degrees,
+            @coordinates_of_the_day.declination.degrees,
+            @coordinates_of_the_next_day.declination.degrees
+          ],
+          @initial_rising + leap_day_portion
+        )
+      )
+    end
+
+    def declination_setting
+      Angle.from_degrees(
+        Util::Maths.interpolate(
+          [
+            @coordinates_of_the_previous_day.declination.degrees,
+            @coordinates_of_the_day.declination.degrees,
+            @coordinates_of_the_next_day.declination.degrees
+          ],
+          @initial_setting + leap_day_portion
+        )
+      )
+    end
+  end
+end

data/lib/astronoby/events/twilight_events.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Astronoby
+  module Events
+    class TwilightEvents
+      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 :morning_civil_twilight_time,
+        :evening_civil_twilight_time,
+        :morning_nautical_twilight_time,
+        :evening_nautical_twilight_time,
+        :morning_astronomical_twilight_time,
+        :evening_astronomical_twilight_time
+
+      def initialize(observer:, sun:)
+        @observer = observer
+        @sun = sun
+        PERIODS_OF_THE_DAY.each do |period_of_the_day|
+          TWILIGHT_ANGLES.each do |twilight, _|
+            zenith_angle = TWILIGHT_ANGLES[twilight]
+            instance_variable_set(
+              :"@#{period_of_the_day}_#{twilight}_twilight_time",
+              compute(period_of_the_day, zenith_angle)
+            )
+          end
+        end
+      end
+
+      # @param period_of_the_day [Symbol] :morning or :evening
+      # @param zenith_angle [Angle] The zenith angle of the twilight
+      def time_for_zenith_angle(period_of_the_day:, zenith_angle:)
+        unless PERIODS_OF_THE_DAY.include?(period_of_the_day)
+          raise IncompatibleArgumentsError,
+            "Only #{PERIODS_OF_THE_DAY.join(" or ")} are allowed as period_of_the_day, got #{period_of_the_day}"
+        end
+
+        compute(period_of_the_day, zenith_angle)
+      end
+
+      private
+
+      # Source:
+      #  Title: Practical Astronomy with your Calculator or Spreadsheet
+      #  Authors: Peter Duffett-Smith and Jonathan Zwart
+      #  Edition: Cambridge University Press
+      #  Chapter: 50 - Twilight
+      def compute(period_of_the_day, zenith_angle)
+        period_time = if period_of_the_day == MORNING
+          observation_events.rising_time
+        else
+          observation_events.setting_time
+        end
+
+        hour_angle_at_period = equatorial_coordinates_at_midday
+          .compute_hour_angle(time: period_time, longitude: @observer.longitude)
+
+        term1 = zenith_angle.cos -
+          @observer.latitude.sin *
+            @equatorial_coordinates_at_midday.declination.sin
+        term2 = @observer.latitude.cos *
+          equatorial_coordinates_at_midday.declination.cos
+        hour_angle_ratio_at_twilight = term1 / term2
+
+        return unless hour_angle_ratio_at_twilight.between?(-1, 1)
+
+        hour_angle_at_twilight = Angle.acos(hour_angle_ratio_at_twilight)
+        time_sign = -1
+
+        if period_of_the_day == MORNING
+          hour_angle_at_twilight = Angle.from_degrees(
+            Constants::DEGREES_PER_CIRCLE - hour_angle_at_twilight.degrees
+          )
+          time_sign = 1
+        end
+
+        twilight_in_hours =
+          time_sign * (hour_angle_at_twilight - hour_angle_at_period).hours *
+          GreenwichSiderealTime::SIDEREAL_MINUTE_IN_UT_MINUTE
+        twilight_in_seconds = time_sign *
+          twilight_in_hours *
+          Constants::SECONDS_PER_HOUR
+
+        (period_time + twilight_in_seconds).round
+      end
+
+      def observation_events
+        @observation_events ||= @sun.observation_events(observer: @observer)
+      end
+
+      def midday
+        date = @sun.time.to_date
+        Time.utc(date.year, date.month, date.day, 12)
+      end
+
+      def sun_at_midday
+        Sun.new(time: midday)
+      end
+
+      def equatorial_coordinates_at_midday
+        @equatorial_coordinates_at_midday ||= sun_at_midday
+          .apparent_ecliptic_coordinates
+          .to_apparent_equatorial(epoch: Epoch.from_time(midday))
+      end
+    end
+  end
+end

data/lib/astronoby/geocentric_parallax.rb

@@ -8,104 +8,82 @@ module Astronoby
     #  Edition: Cambridge University Press
     #  Chapter: 39 - Calculating correction for parallax
 
-    ASTRONOMICAL_UNIT_IN_METERS = 149_597_870_700
-    EARTH_FLATTENING_CORRECTION = BigDecimal("0.996647")
-    EARTH_EQUATORIAL_RADIUS = BigDecimal("6378140")
-
     # Equatorial horizontal parallax
-    # @param distance [Numeric] Distance of the body from the center of the
-    #   Earth, in meters
+    # @param distance [Astronoby::Distance] Distance of the body from the center
+    #   of the Earth
     # @return [Astronoby::Angle] Equatorial horizontal parallax angle
     def self.angle(distance:)
-      distance_in_earth_radius = distance / EARTH_EQUATORIAL_RADIUS
-      Angle.asin(1 / distance_in_earth_radius)
+      Angle.from_radians(Angle.from_dms(0, 0, 8.794).sin / distance.au)
     end
 
     # Correct equatorial coordinates with the equatorial horizontal parallax
-    # @param latitude [Astronoby::Angle] Observer's latitude
-    # @param longitude [Astronoby::Angle] Observer's longitude
-    # @param elevation [Numeric] Observer's elevation above sea level in meters
+    # @param observer [Astronoby::Observer] Observer
     # @param time [Time] Date-time of the observation
     # @param coordinates [Astronoby::Coordinates::Equatorial]
     #   Equatorial coordinates of the observed body
-    # @param distance [Numeric] Distance of the observed body from the center of
-    #   the Earth, in meters
+    # @param distance [Astronoby::Distance] Distance of the observed body from
+    #   the center of the Earth
     # @return [Astronoby::Coordinates::Equatorial] Apparent equatorial
     #   coordinates with equatorial horizontal parallax
     def self.for_equatorial_coordinates(
-      latitude:,
-      longitude:,
-      elevation:,
+      observer:,
       time:,
       coordinates:,
       distance:
     )
       new(
-        latitude,
-        longitude,
-        elevation,
+        observer,
         time,
         coordinates,
         distance
       ).apply
     end
 
-    # @param latitude [Astronoby::Angle] Observer's latitude
-    # @param longitude [Astronoby::Angle] Observer's longitude
-    # @param elevation [Numeric] Observer's elevation above sea level in meters
+    # @param observer [Astronoby::Observer] Observer
     # @param time [Time] Date-time of the observation
     # @param coordinates [Astronoby::Coordinates::Equatorial] Equatorial
     #   coordinates of the observed body
-    # @param distance [Numeric] Distance of the observed body from the center of
-    #   the Earth, in meters
+    # @param distance [Astronoby::Distance] Distance of the observed body from
+    #   the center of the Earth
     def initialize(
-      latitude,
-      longitude,
-      elevation,
+      observer,
       time,
       coordinates,
       distance
     )
-      @latitude = latitude
-      @longitude = longitude
-      @elevation = elevation
+      @observer = observer
       @time = time
       @coordinates = coordinates
       @distance = distance
     end
 
     def apply
-      term1 = Angle.atan(EARTH_FLATTENING_CORRECTION * @latitude.tan)
-      quantity1 = term1.cos + elevation_ratio * @latitude.cos
-      quantity2 = EARTH_FLATTENING_CORRECTION * term1.sin +
-        elevation_ratio * @latitude.sin
-
-      term2 = quantity1 * hour_angle.sin
-      term3 = distance_in_earth_radius * declination.cos -
-        quantity1 * hour_angle.cos
+      term1 = Angle.atan(Constants::EARTH_FLATTENING_CORRECTION * latitude.tan)
+      quantity1 = term1.cos + elevation_ratio * latitude.cos
+      quantity2 = Constants::EARTH_FLATTENING_CORRECTION * term1.sin +
+        elevation_ratio * latitude.sin
 
-      delta = Angle.atan(term2 / term3)
+      term1 = -quantity1 * equatorial_horizontal_parallax.sin * hour_angle.sin
+      term2 = declination.cos - quantity1 * equatorial_horizontal_parallax.sin * hour_angle.cos
+      delta_right_ascension = Angle.atan(term1 / term2)
 
-      apparent_hour_angle = hour_angle + delta
-      apparent_right_ascension = right_ascension - delta
-      apparent_declination = Angle.atan(
-        (
-          apparent_hour_angle.cos *
-            (distance_in_earth_radius * declination.sin - quantity2)
-        ) / (
-          distance_in_earth_radius * declination.cos * hour_angle.cos - quantity1
-        )
-      )
+      term1 = (declination.sin - quantity2 * equatorial_horizontal_parallax.sin) * delta_right_ascension.cos
+      term2 = declination.cos - quantity1 * equatorial_horizontal_parallax.sin * hour_angle.cos
+      new_declination = Angle.atan(term1 / term2)
 
       Coordinates::Equatorial.new(
-        right_ascension: apparent_right_ascension,
-        declination: apparent_declination,
+        right_ascension: delta_right_ascension + right_ascension,
+        declination: new_declination,
         epoch: @coordinates.epoch
       )
     end
 
     private
 
+    def latitude
+      @observer.latitude
+    end
+
     def right_ascension
       @coordinates.right_ascension
     end
@@ -115,16 +93,18 @@ module Astronoby
     end
 
     def hour_angle
-      @_hour_angle ||=
-        @coordinates.compute_hour_angle(time: @time, longitude: @longitude)
+      @_hour_angle ||= @coordinates.compute_hour_angle(
+        time: @time,
+        longitude: @observer.longitude
+      )
     end
 
     def elevation_ratio
-      @elevation / EARTH_EQUATORIAL_RADIUS
+      @observer.elevation.meters / Constants::EARTH_EQUATORIAL_RADIUS_IN_METERS.to_f
     end
 
-    def distance_in_earth_radius
-      @distance / EARTH_EQUATORIAL_RADIUS
+    def equatorial_horizontal_parallax
+      self.class.angle(distance: @distance)
     end
   end
 end

data/lib/astronoby/mean_obliquity.rb

@@ -14,14 +14,14 @@ module Astronoby
     def self.for_epoch(epoch)
       return obliquity_of_reference if epoch == EPOCH_OF_REFERENCE
 
-      t = (epoch - EPOCH_OF_REFERENCE) / Epoch::DAYS_PER_JULIAN_CENTURY
+      t = (epoch - EPOCH_OF_REFERENCE) / Constants::DAYS_PER_JULIAN_CENTURY
 
       Angle.from_degrees(
         obliquity_of_reference.degrees - (
           46.815 * t -
           0.0006 * t * t +
           0.00181 * t * t * t
-        ) / 3600
+        ) / Constants::SECONDS_PER_DEGREE
       )
     end
 

data/lib/astronoby/moon_phase.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Astronoby
+  class MoonPhase
+    NEW_MOON = :new_moon
+    FIRST_QUARTER = :first_quarter
+    FULL_MOON = :full_moon
+    LAST_QUARTER = :last_quarter
+
+    attr_reader :time, :phase
+
+    # @param time [Time] Time of the Moon phase
+    # @return [Astronoby::MoonPhase] New Moon phase
+    def self.new_moon(time)
+      new(time: time, phase: NEW_MOON)
+    end
+
+    # @param time [Time] Time of the Moon phase
+    # @return [Astronoby::MoonPhase] First quarter Moon phase
+    def self.first_quarter(time)
+      new(time: time, phase: FIRST_QUARTER)
+    end
+
+    # @param time [Time] Time of the Moon phase
+    # @return [Astronoby::MoonPhase] Full Moon phase
+    def self.full_moon(time)
+      new(time: time, phase: FULL_MOON)
+    end
+
+    # @param time [Time] Time of the Moon phase
+    # @return [Astronoby::MoonPhase] Last quarter Moon phase
+    def self.last_quarter(time)
+      new(time: time, phase: LAST_QUARTER)
+    end
+
+    # @param time [Time] Time of the Moon phase
+    # @param phase [Symbol] Moon phase
+    def initialize(time:, phase:)
+      @time = time
+      @phase = phase
+    end
+  end
+end

data/lib/astronoby/nutation.rb

@@ -45,18 +45,20 @@ module Astronoby
     private
 
     def julian_centuries
-      (@epoch - Epoch::J1900) / Epoch::DAYS_PER_JULIAN_CENTURY
+      (@epoch - Epoch::J1900) / Constants::DAYS_PER_JULIAN_CENTURY
     end
 
     def sun_mean_longitude
       Angle.from_degrees(
-        (279.6967 + 360.0 * (centuries_a - centuries_a.to_i)) % 360
+        (279.6967 + Constants::DEGREES_PER_CIRCLE * (centuries_a - centuries_a.to_i)) %
+          Constants::DEGREES_PER_CIRCLE
       )
     end
 
     def moon_ascending_node_longitude
       Angle.from_degrees(
-        (259.1833 - 360.0 * (centuries_b - centuries_b.to_i)) % 360
+        (259.1833 - Constants::DEGREES_PER_CIRCLE * (centuries_b - centuries_b.to_i)) %
+          Constants::DEGREES_PER_CIRCLE
       )
     end
 

data/lib/astronoby/observer.rb

@@ -2,20 +2,20 @@
 
 module Astronoby
   class Observer
-    DEFAULT_ELEVATION = 0
-    DEFAULT_TEMPERATURE = BigDecimal("283.15")
-    PRESSURE_AT_SEA_LEVEL = BigDecimal("1013.25")
-    PASCAL_PER_MILLIBAR = BigDecimal("0.01")
-    EARTH_GRAVITATIONAL_ACCELERATION = BigDecimal("9.80665")
-    MOLAR_MASS_OF_AIR = BigDecimal("0.0289644")
-    UNIVERSAL_GAS_CONSTANT = BigDecimal("8.31432")
+    DEFAULT_ELEVATION = Distance.zero
+    DEFAULT_TEMPERATURE = 283.15
+    PRESSURE_AT_SEA_LEVEL = 1013.25
+    PASCAL_PER_MILLIBAR = 0.01
+    EARTH_GRAVITATIONAL_ACCELERATION = 9.80665
+    MOLAR_MASS_OF_AIR = 0.0289644
+    UNIVERSAL_GAS_CONSTANT = 8.31432
 
-    attr_reader :latitude, :longitude, :elevation, :temperature
+    attr_reader :latitude, :longitude, :elevation, :temperature, :pressure
 
     # @param latitude [Angle] geographic latitude of the observer
     # @param longitude [Angle] geographic longitude of the observer
-    # @param elevation [Numeric] geographic elevation (or altitude) of the
-    #   observer above sea level in meters
+    # @param elevation [Astronoby::Distance] geographic elevation (or altitude)
+    #   of the observer above sea level
     # @param temperature [Numeric] temperature at the observer's location in
     #   kelvins
     # @param pressure [Numeric] atmospheric pressure at the observer's
@@ -31,24 +31,45 @@ module Astronoby
       @longitude = longitude
       @elevation = elevation
       @temperature = temperature
-      @pressure = pressure
+      @pressure = pressure || compute_pressure
     end
 
-    # Compute an estimation of the atmospheric pressure based on the elevation
-    # and temperature
-    #
-    # @return [BigDecimal] the atmospheric pressure in millibars.
-    def pressure
-      @pressure ||= PRESSURE_AT_SEA_LEVEL * pressure_ratio
+    def ==(other)
+      return false unless other.is_a?(self.class)
+
+      @latitude == other.latitude &&
+        @longitude == other.longitude &&
+        @elevation == other.elevation &&
+        @temperature == other.temperature &&
+        @pressure == other.pressure
+    end
+    alias_method :eql?, :==
+
+    def hash
+      [
+        self.class,
+        @latitude,
+        @longitude,
+        @elevation,
+        @temperature,
+        @pressure
+      ].hash
     end
 
     private
 
+    # @return [Float] the atmospheric pressure in millibars.
+    def compute_pressure
+      @pressure ||= PRESSURE_AT_SEA_LEVEL * pressure_ratio
+    end
+
     # Source:
     # Barometric formula
     # https://en.wikipedia.org/wiki/Barometric_formula
     def pressure_ratio
-      term1 = EARTH_GRAVITATIONAL_ACCELERATION * MOLAR_MASS_OF_AIR * @elevation
+      term1 = EARTH_GRAVITATIONAL_ACCELERATION *
+        MOLAR_MASS_OF_AIR *
+        @elevation.meters
       term2 = UNIVERSAL_GAS_CONSTANT * @temperature
 
       Math.exp(-term1 / term2)

data/lib/astronoby/precession.rb

@@ -45,7 +45,7 @@ module Astronoby
     private
 
     def matrix_for_epoch(epoch)
-      t = (epoch - Epoch::DEFAULT_EPOCH) / Epoch::DAYS_PER_JULIAN_CENTURY
+      t = (epoch - Epoch::DEFAULT_EPOCH) / Constants::DAYS_PER_JULIAN_CENTURY
 
       zeta = Angle.from_degrees(
         0.6406161 * t + 0.0000839 * t * t + 0.000005 * t * t * t