astronoby 0.0.1 → 0.2.0

data/lib/astronoby/coordinates/equatorial.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Astronoby
+  module Coordinates
+    class Equatorial
+      attr_reader :declination, :right_ascension, :hour_angle, :epoch
+
+      def initialize(
+        declination:,
+        right_ascension:,
+        hour_angle: nil,
+        epoch: Epoch::DEFAULT_EPOCH
+      )
+        @right_ascension = right_ascension
+        @declination = declination
+        @hour_angle = hour_angle
+        @epoch = epoch
+      end
+
+      def compute_hour_angle(time:, longitude:)
+        lst = GreenwichSiderealTime
+          .from_utc(time.utc)
+          .to_lst(longitude: longitude)
+
+        ha = (lst.time - @right_ascension.hours)
+        ha += 24 if ha.negative?
+
+        Angle.as_hours(ha)
+      end
+
+      def to_horizontal(time:, latitude:, longitude:)
+        ha = @hour_angle || compute_hour_angle(time: time, longitude: longitude)
+        t0 = @declination.sin * latitude.sin +
+          @declination.cos * latitude.cos * ha.cos
+        altitude = Angle.asin(t0)
+
+        t1 = @declination.sin - latitude.sin * altitude.sin
+        t2 = t1 / (latitude.cos * altitude.cos)
+        azimuth = Angle.acos(t2)
+
+        if ha.sin.positive?
+          azimuth = Angle.as_degrees(BigDecimal("360") - azimuth.degrees)
+        end
+
+        Horizontal.new(
+          azimuth: azimuth,
+          altitude: altitude,
+          latitude: latitude,
+          longitude: longitude
+        )
+      end
+
+      # Source:
+      #  Title: Celestial Calculations
+      #  Author: J. L. Lawrence
+      #  Edition: MIT Press
+      #  Chapter: 4 - Orbits and Coordinate Systems
+      def to_ecliptic(epoch:)
+        mean_obliquity = MeanObliquity.for_epoch(epoch)
+
+        y = Angle.as_radians(
+          @right_ascension.sin * mean_obliquity.cos +
+          @declination.tan * mean_obliquity.sin
+        )
+        x = Angle.as_radians(@right_ascension.cos)
+        r = Angle.atan(y.radians / x.radians)
+        longitude = Util::Trigonometry.adjustement_for_arctangent(y, x, r)
+
+        latitude = Angle.asin(
+          @declination.sin * mean_obliquity.cos -
+          @declination.cos * mean_obliquity.sin * @right_ascension.sin
+        )
+
+        Ecliptic.new(
+          latitude: latitude,
+          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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Astronoby
+  module Coordinates
+    class Horizontal
+      attr_reader :azimuth, :altitude, :latitude, :longitude
+
+      def initialize(
+        azimuth:,
+        altitude:,
+        latitude:,
+        longitude:
+      )
+        @azimuth = azimuth
+        @altitude = altitude
+        @latitude = latitude
+        @longitude = longitude
+      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
+            .as_degrees(BigDecimal("360") - hour_angle_degrees)
+            .degrees
+        end
+
+        hour_angle_hours = Angle.as_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)
+
+        Equatorial.new(
+          right_ascension: right_ascension,
+          declination: declination
+        )
+      end
+    end
+  end
+end

data/lib/astronoby/epoch.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Astronoby
+  class Epoch
+    B1900 = 2415020.3135
+    J1900 = 2415020.0
+    B1950 = 2433282.4235
+    J1950 = 2433282.5
+    J2000 = 2451545.0
+
+    DEFAULT_EPOCH = J2000
+    DAYS_PER_JULIAN_CENTURY = 36525.0
+
+    JULIAN_DAY_NUMBER_OFFSET = 0.5
+
+    def self.from_time(time)
+      time.to_datetime.ajd
+    end
+
+    def self.to_utc(epoch)
+      DateTime.jd(epoch + JULIAN_DAY_NUMBER_OFFSET).to_time.utc
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+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/mean_obliquity.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Astronoby
+  class MeanObliquity
+    # Source:
+    #  IAU resolution in 2006 in favor of the P03 astronomical model
+    #  The Astronomical Almanac for 2010
+
+    EPOCH_OF_REFERENCE = Epoch::DEFAULT_EPOCH
+    OBLIQUITY_OF_REFERENCE = 23.4392794
+
+    def self.for_epoch(epoch)
+      return obliquity_of_reference if epoch == EPOCH_OF_REFERENCE
+
+      t = (epoch - EPOCH_OF_REFERENCE) / Epoch::DAYS_PER_JULIAN_CENTURY
+
+      Angle.as_degrees(
+        obliquity_of_reference.degrees - (
+          46.815 * t -
+          0.0006 * t * t +
+          0.00181 * t * t * t
+        ) / 3600
+      )
+    end
+
+    def self.obliquity_of_reference
+      Angle.as_dms(23, 26, 21.45)
+    end
+  end
+end

data/lib/astronoby/nutation.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Astronoby
+  class Nutation
+    # Source:
+    #  Title: Practical Astronomy with your Calculator or Spreadsheet
+    #  Authors: Peter Duffett-Smith and Jonathan Zwart
+    #  Edition: Cambridge University Press
+    #  Chapter: 35 - Nutation
+
+    def initialize(epoch)
+      @epoch = epoch
+    end
+
+    def self.for_ecliptic_longitude(epoch:)
+      new(epoch).for_ecliptic_longitude
+    end
+
+    def self.for_obliquity_of_the_ecliptic(epoch:)
+      new(epoch).for_obliquity_of_the_ecliptic
+    end
+
+    def for_ecliptic_longitude
+      Angle.as_dms(
+        0,
+        0,
+        (
+          -17.2 * moon_ascending_node_longitude.sin -
+          1.3 * Math.sin(2 * sun_mean_longitude.radians)
+        )
+      )
+    end
+
+    def for_obliquity_of_the_ecliptic
+      Angle.as_dms(
+        0,
+        0,
+        (
+          9.2 * moon_ascending_node_longitude.cos +
+          0.5 * Math.cos(2 * sun_mean_longitude.radians)
+        )
+      )
+    end
+
+    private
+
+    def julian_centuries
+      (@epoch - Epoch::J1900) / Epoch::DAYS_PER_JULIAN_CENTURY
+    end
+
+    def sun_mean_longitude
+      Angle.as_degrees(
+        (279.6967 + 360.0 * (centuries_a - centuries_a.to_i)) % 360
+      )
+    end
+
+    def moon_ascending_node_longitude
+      Angle.as_degrees(
+        (259.1833 - 360.0 * (centuries_b - centuries_b.to_i)) % 360
+      )
+    end
+
+    def centuries_a
+      100.002136 * julian_centuries
+    end
+
+    def centuries_b
+      5.372617 * julian_centuries
+    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/precession.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "matrix"
+
+module Astronoby
+  class Precession
+    def self.for_equatorial_coordinates(coordinates:, epoch:)
+      new(coordinates, epoch).precess
+    end
+
+    def initialize(coordinates, epoch)
+      @coordinates = coordinates
+      @epoch = epoch
+    end
+
+    # Source:
+    #  Title: Practical Astronomy with your Calculator or Spreadsheet
+    #  Authors: Peter Duffett-Smith and Jonathan Zwart
+    #  Edition: Cambridge University Press
+    #  Chapter: 34 - Precession
+    def precess
+      matrix_a = matrix_for_epoch(@coordinates.epoch)
+      matrix_b = matrix_for_epoch(@epoch).transpose
+
+      vector = Vector[
+        @coordinates.right_ascension.cos * @coordinates.declination.cos,
+        @coordinates.right_ascension.sin * @coordinates.declination.cos,
+        @coordinates.declination.sin
+      ]
+
+      s = matrix_a * vector
+      w = matrix_b * s
+
+      Coordinates::Equatorial.new(
+        right_ascension: Util::Trigonometry.adjustement_for_arctangent(
+          Angle.as_radians(w[1]),
+          Angle.as_radians(w[0]),
+          Angle.atan(w[1] / w[0])
+        ),
+        declination: Angle.asin(w[2]),
+        epoch: @epoch
+      )
+    end
+
+    private
+
+    def matrix_for_epoch(epoch)
+      t = (epoch - Epoch::DEFAULT_EPOCH) / Epoch::DAYS_PER_JULIAN_CENTURY
+
+      zeta = Angle.as_degrees(
+        0.6406161 * t + 0.0000839 * t * t + 0.000005 * t * t * t
+      )
+      z = Angle.as_degrees(
+        0.6406161 * t + 0.0003041 * t * t + 0.0000051 * t * t * t
+      )
+      theta = Angle.as_degrees(
+        0.5567530 * t - 0.0001185 * t * t - 0.0000116 * t * t * t
+      )
+
+      cx = zeta.cos
+      sx = zeta.sin
+      cz = z.cos
+      sz = z.sin
+      ct = theta.cos
+      st = theta.sin
+
+      Matrix[
+        [
+          cx * ct * cz - sx * sz,
+          cx * ct * sz + sx * cz,
+          cx * st
+        ],
+        [
+          -sx * ct * cz - cx * sz,
+          -sx * ct * sz + cx * cz,
+          -sx * st
+        ],
+        [
+          -st * cz,
+          -st * sz,
+          ct
+        ]
+      ]
+    end
+  end
+end