astronoby 0.1.0 → 0.2.0

data/lib/astronoby/body.rb

@@ -2,79 +2,154 @@
 
 module Astronoby
   class Body
+    DEFAULT_REFRACTION_VERTICAL_SHIFT = Angle.as_dms(0, 34, 0)
+    RISING_SETTING_HOUR_ANGLE_RATIO_RANGE = (-1..1)
+
     def initialize(equatorial_coordinates)
       @equatorial_coordinates = equatorial_coordinates
     end
 
     # Source:
-    #  Title: Celestial Calculations
-    #  Author: J. L. Lawrence
-    #  Edition: MIT Press
-    #  Chapter: 5 - Stars in the Nighttime Sky
-    def rising_time(latitude:, longitude:, date:)
-      h2_component = h2(latitude: latitude)
-      return nil if h2_component.nil?
-
-      rising_lst = 24 +
-        @equatorial_coordinates.right_ascension.hours - h2_component.degrees
-      rising_lst -= 24 if rising_lst > 24
-
-      Util::Time.lst_to_ut(date: date, longitude: longitude, lst: rising_lst)
+    #  Title: Practical Astronomy with your Calculator or Spreadsheet
+    #  Authors: Peter Duffett-Smith and Jonathan Zwart
+    #  Edition: Cambridge University Press
+    #  Chapter: 33 - Rising and setting
+
+    # @param latitude [Astronoby::Angle] Latitude of the observer
+    # @param longitude [Astronoby::Angle] Longitude of the observer
+    # @param date [Date] Date of the event
+    # @param apparent [Boolean] Compute apparent or true data
+    # @param vertical_shift [Astronoby::Angle] Vertical shift correction angle
+    # @return [Time, nil] Sunrise time
+    def rising_time(
+      latitude:,
+      longitude:,
+      date:,
+      apparent: true,
+      vertical_shift: nil
+    )
+      time_ratio = time_ratio(latitude, apparent, vertical_shift)
+      return nil unless RISING_SETTING_HOUR_ANGLE_RATIO_RANGE.cover?(time_ratio)
+
+      hour_angle = Angle.acos(time_ratio)
+      local_sidereal_time = LocalSiderealTime.new(
+        date: date,
+        time: right_ascension.hours - hour_angle.hours,
+        longitude: longitude
+      )
+
+      local_sidereal_time.to_gst.to_utc
     end
 
     # Source:
-    #  Title: Celestial Calculations
-    #  Author: J. L. Lawrence
-    #  Edition: MIT Press
-    #  Chapter: 5 - Stars in the Nighttime Sky
-    def rising_azimuth(latitude:)
-      ar = azimuth_component(latitude: latitude)
-      return nil if ar >= 1
-
-      Angle.acos(ar)
+    #  Title: Practical Astronomy with your Calculator or Spreadsheet
+    #  Authors: Peter Duffett-Smith and Jonathan Zwart
+    #  Edition: Cambridge University Press
+    #  Chapter: 33 - Rising and setting
+
+    # @param latitude [Astronoby::Angle] Latitude of the observer
+    # @param apparent [Boolean] Compute apparent or true data
+    # @param vertical_shift [Astronoby::Angle] Vertical shift correction angle
+    # @return [Astronoby::Angle, nil] Sunrise azimuth
+    def rising_azimuth(latitude:, apparent: true, vertical_shift: nil)
+      time_ratio = time_ratio(latitude, apparent, vertical_shift)
+      return nil unless RISING_SETTING_HOUR_ANGLE_RATIO_RANGE.cover?(time_ratio)
+
+      azimuth_ratio = azimuth_ratio(latitude, apparent, vertical_shift)
+
+      Angle.acos(azimuth_ratio)
     end
 
     # Source:
-    #  Title: Celestial Calculations
-    #  Author: J. L. Lawrence
-    #  Edition: MIT Press
-    #  Chapter: 5 - Stars in the Nighttime Sky
-    def setting_time(latitude:, longitude:, date:)
-      h2_component = h2(latitude: latitude)
-      return nil if h2_component.nil?
-
-      setting_lst = @equatorial_coordinates.right_ascension.hours + h2_component.degrees
-      setting_lst -= 24 if setting_lst > 24
-
-      Util::Time.lst_to_ut(date: date, longitude: longitude, lst: setting_lst)
+    #  Title: Practical Astronomy with your Calculator or Spreadsheet
+    #  Authors: Peter Duffett-Smith and Jonathan Zwart
+    #  Edition: Cambridge University Press
+    #  Chapter: 33 - Rising and setting
+
+    # @param latitude [Astronoby::Angle] Latitude of the observer
+    # @param longitude [Astronoby::Angle] Longitude of the observer
+    # @param date [Date] Date of the event
+    # @param apparent [Boolean] Compute apparent or true data
+    # @param vertical_shift [Astronoby::Angle] Vertical shift correction angle
+    # @return [Time, nil] Sunset time
+    def setting_time(
+      latitude:,
+      longitude:,
+      date:,
+      apparent: true,
+      vertical_shift: nil
+    )
+      time_ratio = time_ratio(latitude, apparent, vertical_shift)
+      return nil unless RISING_SETTING_HOUR_ANGLE_RATIO_RANGE.cover?(time_ratio)
+
+      hour_angle = Angle.acos(time_ratio)
+      local_sidereal_time = LocalSiderealTime.new(
+        date: date,
+        time: right_ascension.hours + hour_angle.hours,
+        longitude: longitude
+      )
+
+      local_sidereal_time.to_gst.to_utc
     end
 
     # Source:
-    #  Title: Celestial Calculations
-    #  Author: J. L. Lawrence
-    #  Edition: MIT Press
-    #  Chapter: 5 - Stars in the Nighttime Sky
-    def setting_azimuth(latitude:)
-      rising_az = rising_azimuth(latitude: latitude)
-      return nil if rising_az.nil?
-
-      Angle.as_degrees(360 - rising_az.degrees)
+    #  Title: Practical Astronomy with your Calculator or Spreadsheet
+    #  Authors: Peter Duffett-Smith and Jonathan Zwart
+    #  Edition: Cambridge University Press
+    #  Chapter: 33 - Rising and setting
+
+    # @param latitude [Astronoby::Angle] Latitude of the observer
+    # @param apparent [Boolean] Compute apparent or true data
+    # @param vertical_shift [Astronoby::Angle] Vertical shift correction angle
+    # @return [Astronoby::Angle, nil] Sunset azimuth
+    def setting_azimuth(latitude:, apparent: true, vertical_shift: nil)
+      time_ratio = time_ratio(latitude, apparent, vertical_shift)
+      return nil unless RISING_SETTING_HOUR_ANGLE_RATIO_RANGE.cover?(time_ratio)
+
+      azimuth_ratio = azimuth_ratio(latitude, apparent, vertical_shift)
+
+      Angle.as_degrees(360 - Angle.acos(azimuth_ratio).degrees)
     end
 
     private
 
-    def azimuth_component(latitude:)
-      @equatorial_coordinates.declination.sin / latitude.cos
+    def time_ratio(latitude, apparent, vertical_shift)
+      shift = if vertical_shift
+        vertical_shift
+      elsif apparent
+        DEFAULT_REFRACTION_VERTICAL_SHIFT
+      else
+        Angle.zero
+      end
+
+      term1 = shift.sin + latitude.sin * declination.sin
+      term2 = latitude.cos * declination.cos
+
+      -term1 / term2
+    end
+
+    def azimuth_ratio(latitude, apparent, vertical_shift)
+      shift = if vertical_shift
+        vertical_shift
+      elsif apparent
+        DEFAULT_REFRACTION_VERTICAL_SHIFT
+      else
+        Angle.zero
+      end
+
+      (declination.sin + shift.sin * latitude.cos) / (shift.cos * latitude.cos)
     end
 
-    def h2(latitude:)
-      ar = azimuth_component(latitude: latitude)
-      return nil if ar >= 1
+    def azimuth_component(latitude)
+      declination.sin / latitude.cos
+    end
 
-      h1 = latitude.tan * @equatorial_coordinates.declination.tan
-      return nil if h1.abs > 1
+    def right_ascension
+      @equatorial_coordinates.right_ascension
+    end
 
-      Angle.as_radians(Math.acos(-h1) / 15.0)
+    def declination
+      @equatorial_coordinates.declination
     end
   end
 end

data/lib/astronoby/coordinates/equatorial.rb

@@ -18,12 +18,11 @@ module Astronoby
       end
 
       def compute_hour_angle(time:, longitude:)
-        lst = Util::Time.local_sidereal_time(
-          time: time,
-          longitude: longitude
-        )
+        lst = GreenwichSiderealTime
+          .from_utc(time.utc)
+          .to_lst(longitude: longitude)
 
-        ha = (lst - @right_ascension.hours)
+        ha = (lst.time - @right_ascension.hours)
         ha += 24 if ha.negative?
 
         Angle.as_hours(ha)

data/lib/astronoby/coordinates/horizontal.rb

@@ -36,10 +36,10 @@ module Astronoby
         end
 
         hour_angle_hours = Angle.as_degrees(hour_angle_degrees).hours
-        right_ascension_decimal = Util::Time.local_sidereal_time(
-          time: time,
-          longitude: @longitude
-        ) - hour_angle_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)
 

data/lib/astronoby/equinox_solstice.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Astronoby
+  class EquinoxSolstice
+    # Source:
+    #  Title: Astronomical Algorithms
+    #  Author: Jean Meeus
+    #  Edition: 2nd edition
+    #  Chapter: 27 - Equinoxes and Soltices
+
+    EVENTS = [
+      MARCH_EQUINOX = 0,
+      JUNE_SOLSTICE = 1,
+      SEPTEMBER_EQUINOX = 2,
+      DECEMBER_SOLSTICE = 3
+    ].freeze
+
+    JDE_COMPONENTS = {
+      MARCH_EQUINOX => [
+        2451623.80984,
+        365242.37404,
+        0.05169,
+        -0.00411,
+        -0.00057
+      ],
+      JUNE_SOLSTICE => [
+        2451716.56767,
+        365241.62603,
+        0.00325,
+        0.00888,
+        -0.00030
+      ],
+      SEPTEMBER_EQUINOX => [
+        2451810.21715,
+        365242.01767,
+        -0.11575,
+        0.00337,
+        0.00078
+      ],
+      DECEMBER_SOLSTICE => [
+        2451900.05952,
+        365242.74049,
+        -0.06223,
+        -0.00823,
+        0.00032
+      ]
+    }
+
+    PERIODIC_TERMS = [
+      [485, 324.96, 1934.136],
+      [203, 337.23, 32964.467],
+      [199, 342.08, 20.186],
+      [182, 27.85, 445267.112],
+      [156, 73.14, 45036.886],
+      [136, 171.52, 22518.443],
+      [77, 222.54, 65928.934],
+      [74, 296.72, 3034.906],
+      [70, 243.58, 9037.513],
+      [58, 119.81, 33718.147],
+      [52, 297.17, 150.678],
+      [50, 21.02, 2281.226],
+      [45, 247.54, 29929.562],
+      [44, 325.15, 31555.956],
+      [29, 60.93, 4443.417],
+      [18, 155.12, 67555.328],
+      [17, 288.79, 4562.452],
+      [16, 198.04, 62894.029],
+      [14, 199.76, 31436.921],
+      [12, 95.39, 14577.848],
+      [12, 287.11, 31931.756],
+      [12, 320.81, 34777.259],
+      [9, 227.73, 1222.114],
+      [8, 15.45, 16859.074]
+    ].freeze
+
+    def self.march_equinox(year)
+      new(year, MARCH_EQUINOX).compute
+    end
+
+    def self.june_solstice(year)
+      new(year, JUNE_SOLSTICE).compute
+    end
+
+    def self.september_equinox(year)
+      new(year, SEPTEMBER_EQUINOX).compute
+    end
+
+    def self.december_solstice(year)
+      new(year, DECEMBER_SOLSTICE).compute
+    end
+
+    def initialize(year, event)
+      unless EVENTS.include?(event)
+        raise UnsupportedEventError.new(
+          "Expected a format between #{EVENTS.join(", ")}, got #{event}"
+        )
+      end
+
+      @event = event
+      @year = (year.to_i - 2000) / 1000.0
+    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)
+      delta = 1 +
+        0.0334 * w.cos +
+        0.0007 * Angle.as_degrees(w.degrees * 2).cos
+
+      s = PERIODIC_TERMS.sum do |a, b, c|
+        a * (Angle.as_degrees(b) + Angle.as_degrees(c * t)).cos
+      end
+
+      delta_days = 0.00001 * s / delta
+      epoch = julian_day + delta_days
+      epoch += correction(epoch)
+
+      Epoch.to_utc(epoch).round
+    end
+
+    private
+
+    def julian_day
+      component = JDE_COMPONENTS[@event]
+      component[0] +
+        component[1] * @year +
+        component[2] * @year**2 +
+        component[3] * @year**3 +
+        component[4] * @year**4
+    end
+
+    def correction(epoch)
+      sun = Sun.new(epoch: epoch)
+
+      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
+    end
+  end
+end

data/lib/astronoby/errors.rb

@@ -2,4 +2,6 @@ module Astronoby
   class IncompatibleArgumentsError < ArgumentError; end
 
   class UnsupportedFormatError < ArgumentError; end
+
+  class UnsupportedEventError < ArgumentError; end
 end

data/lib/astronoby/geocentric_parallax.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Astronoby
+  class GeocentricParallax
+    # Source:
+    #  Title: Practical Astronomy with your Calculator or Spreadsheet
+    #  Authors: Peter Duffett-Smith and Jonathan Zwart
+    #  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
+    # @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)
+    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 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
+    # @return [Astronoby::Coordinates::Equatorial] Apparent equatorial
+    #   coordinates with equatorial horizontal parallax
+    def self.for_equatorial_coordinates(
+      latitude:,
+      longitude:,
+      elevation:,
+      time:,
+      coordinates:,
+      distance:
+    )
+      new(
+        latitude,
+        longitude,
+        elevation,
+        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 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
+    def initialize(
+      latitude,
+      longitude,
+      elevation,
+      time,
+      coordinates,
+      distance
+    )
+      @latitude = latitude
+      @longitude = longitude
+      @elevation = elevation
+      @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
+
+      delta = Angle.atan(term2 / term3)
+
+      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
+        )
+      )
+
+      Coordinates::Equatorial.new(
+        right_ascension: apparent_right_ascension,
+        declination: apparent_declination,
+        epoch: @coordinates.epoch
+      )
+    end
+
+    private
+
+    def right_ascension
+      @coordinates.right_ascension
+    end
+
+    def declination
+      @coordinates.declination
+    end
+
+    def hour_angle
+      @_hour_angle ||=
+        @coordinates.compute_hour_angle(time: @time, longitude: @longitude)
+    end
+
+    def elevation_ratio
+      @elevation / EARTH_EQUATORIAL_RADIUS
+    end
+
+    def distance_in_earth_radius
+      @distance / EARTH_EQUATORIAL_RADIUS
+    end
+  end
+end

data/lib/astronoby/observer.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+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")
+
+    attr_reader :latitude, :longitude, :elevation, :temperature
+
+    # @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 temperature [Numeric] temperature at the observer's location in
+    #   kelvins
+    # @param pressure [Numeric] atmospheric pressure at the observer's
+    #   location in millibars
+    def initialize(
+      latitude:,
+      longitude:,
+      elevation: DEFAULT_ELEVATION,
+      temperature: DEFAULT_TEMPERATURE,
+      pressure: nil
+    )
+      @latitude = latitude
+      @longitude = longitude
+      @elevation = elevation
+      @temperature = temperature
+      @pressure = 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
+    end
+
+    private
+
+    # Source:
+    # Barometric formula
+    # https://en.wikipedia.org/wiki/Barometric_formula
+    def pressure_ratio
+      term1 = EARTH_GRAVITATIONAL_ACCELERATION * MOLAR_MASS_OF_AIR * @elevation
+      term2 = UNIVERSAL_GAS_CONSTANT * @temperature
+
+      Math.exp(-term1 / term2)
+    end
+  end
+end

data/lib/astronoby/refraction.rb

@@ -2,21 +2,20 @@
 
 module Astronoby
   class Refraction
-    DEFAULT_PRESSURE = 1000
-    DEFAULT_TEMPERATURE = 25
+    LOW_ALTITUDE_BODY_ANGLE = Angle.as_degrees(15)
+    ZENITH = Angle.as_degrees(90)
 
-    def self.for_horizontal_coordinates(
-      coordinates:,
-      pressure: DEFAULT_PRESSURE,
-      temperature: DEFAULT_TEMPERATURE
-    )
-      new(coordinates, pressure, temperature).refract
+    def self.angle(coordinates:, observer:)
+      new(coordinates, observer).refraction_angle
     end
 
-    def initialize(coordinates, pressure, temperature)
+    def self.correct_horizontal_coordinates(coordinates:, observer:)
+      new(coordinates, observer).refract
+    end
+
+    def initialize(coordinates, observer)
       @coordinates = coordinates
-      @pressure = pressure
-      @temperature = temperature
+      @observer = observer
     end
 
     # Source:
@@ -25,31 +24,6 @@ module Astronoby
     #  Edition: Cambridge University Press
     #  Chapter: 37 - Refraction
     def refract
-      altitude_in_degrees = @coordinates.altitude.degrees
-
-      refraction_angle = Angle.as_degrees(
-        if altitude_in_degrees > 15
-          zenith_angle = Angle.as_degrees(90 - @coordinates.altitude.degrees)
-          0.00452 * @pressure * zenith_angle.tan / (273 + @temperature)
-        else
-          (
-            @pressure *
-            (
-              0.1594 +
-              0.0196 * altitude_in_degrees +
-              0.00002 * altitude_in_degrees * altitude_in_degrees
-            )
-          )./(
-            (273 + @temperature) *
-            (
-              1 +
-              0.505 * altitude_in_degrees +
-              0.0845 * altitude_in_degrees * altitude_in_degrees
-            )
-          )
-        end
-      )
-
       Coordinates::Horizontal.new(
         azimuth: @coordinates.azimuth,
         altitude: @coordinates.altitude + refraction_angle,
@@ -57,5 +31,43 @@ module Astronoby
         longitude: @coordinates.longitude
       )
     end
+
+    def refraction_angle
+      if @coordinates.altitude > LOW_ALTITUDE_BODY_ANGLE
+        high_altitude_angle
+      else
+        low_altitude_angle
+      end
+    end
+
+    private
+
+    def pressure
+      @_pressure ||= @observer.pressure
+    end
+
+    def temperature
+      @_temperature ||= @observer.temperature
+    end
+
+    def altitude_in_degrees
+      @_altitude_in_degrees ||= @coordinates.altitude.degrees
+    end
+
+    def high_altitude_angle
+      zenith_angle = ZENITH - @coordinates.altitude
+      Angle.as_degrees(0.00452 * pressure * zenith_angle.tan / temperature)
+    end
+
+    def low_altitude_angle
+      term1 = pressure * (
+        0.1594 + 0.0196 * altitude_in_degrees + 0.00002 * altitude_in_degrees**2
+      )
+      term2 = temperature * (
+        1 + 0.505 * altitude_in_degrees + 0.0845 * altitude_in_degrees**2
+      )
+
+      Angle.as_degrees(term1 / term2)
+    end
   end
 end