astronoby 0.0.1 → 0.1.0

data/lib/astronoby/bodies/sun.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Astronoby
+  class Sun
+    # Source:
+    #  Title: Celestial Calculations
+    #  Author: J. L. Lawrence
+    #  Edition: MIT Press
+    #  Chapter: 6 - The Sun
+
+    def initialize(epoch:)
+      @epoch = epoch
+    end
+
+    def ecliptic_coordinates
+      Coordinates::Ecliptic.new(
+        latitude: Angle.zero,
+        longitude: Angle.as_degrees(
+          (true_anomaly + longitude_at_perigee).degrees % 360
+        )
+      )
+    end
+
+    def horizontal_coordinates(latitude:, longitude:)
+      time = Epoch.to_utc(@epoch)
+
+      ecliptic_coordinates
+        .to_equatorial(epoch: @epoch)
+        .to_horizontal(time: time, latitude: latitude, longitude: longitude)
+    end
+
+    private
+
+    def mean_anomaly
+      Angle.as_degrees(
+        (longitude_at_base_epoch - longitude_at_perigee).degrees % 360
+      )
+    end
+
+    def true_anomaly
+      eccentric_anomaly = Util::Astrodynamics.eccentric_anomaly_newton_raphson(
+        mean_anomaly,
+        orbital_eccentricity.degrees,
+        2e-06,
+        10
+      )
+
+      tan = Math.sqrt(
+        (1 + orbital_eccentricity.degrees) / (1 - orbital_eccentricity.degrees)
+      ) * Math.tan(eccentric_anomaly.radians / 2)
+
+      Angle.as_degrees((Angle.atan(tan).degrees * 2) % 360)
+    end
+
+    def days_since_epoch
+      Epoch::DEFAULT_EPOCH - @epoch
+    end
+
+    def centuries
+      @centuries ||= (@epoch - Epoch::J1900) / Epoch::DAYS_PER_JULIAN_CENTURY
+    end
+
+    def longitude_at_base_epoch
+      Angle.as_degrees(
+        (279.6966778 + 36000.76892 * centuries + 0.0003025 * centuries**2) % 360
+      )
+    end
+
+    def longitude_at_perigee
+      Angle.as_degrees(
+        (281.2208444 + 1.719175 * centuries + 0.000452778 * centuries**2) % 360
+      )
+    end
+
+    def orbital_eccentricity
+      Angle.as_degrees(
+        (0.01675104 - 0.0000418 * centuries - 0.000000126 * centuries**2) % 360
+      )
+    end
+  end
+end

data/lib/astronoby/body.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Astronoby
+  class Body
+    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)
+    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)
+    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)
+    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)
+    end
+
+    private
+
+    def azimuth_component(latitude:)
+      @equatorial_coordinates.declination.sin / latitude.cos
+    end
+
+    def h2(latitude:)
+      ar = azimuth_component(latitude: latitude)
+      return nil if ar >= 1
+
+      h1 = latitude.tan * @equatorial_coordinates.declination.tan
+      return nil if h1.abs > 1
+
+      Angle.as_radians(Math.acos(-h1) / 15.0)
+    end
+  end
+end

data/lib/astronoby/coordinates/ecliptic.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Astronoby
+  module Coordinates
+    class Ecliptic
+      attr_reader :latitude, :longitude
+
+      def initialize(latitude:, longitude:)
+        @latitude = latitude
+        @longitude = longitude
+      end
+
+      # Source:
+      #  Title: Celestial Calculations
+      #  Author: J. L. Lawrence
+      #  Edition: MIT Press
+      #  Chapter: 4 - Orbits and Coordinate Systems
+      def to_equatorial(epoch:)
+        mean_obliquity = MeanObliquity.for_epoch(epoch)
+
+        y = Angle.as_radians(
+          @longitude.sin * mean_obliquity.cos -
+          @latitude.tan * mean_obliquity.sin
+        )
+        x = Angle.as_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
+        )
+
+        Equatorial.new(
+          right_ascension: right_ascension,
+          declination: declination,
+          epoch: epoch
+        )
+      end
+    end
+  end
+end

data/lib/astronoby/coordinates/equatorial.rb

@@ -0,0 +1,89 @@
+# 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 = Util::Time.local_sidereal_time(
+          time: time,
+          longitude: longitude
+        )
+
+        ha = (lst - @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
+        right_ascension_decimal = Util::Time.local_sidereal_time(
+          time: time,
+          longitude: @longitude
+        ) - 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/errors.rb

@@ -0,0 +1,5 @@
+module Astronoby
+  class IncompatibleArgumentsError < ArgumentError; end
+
+  class UnsupportedFormatError < ArgumentError; 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/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

data/lib/astronoby/refraction.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Astronoby
+  class Refraction
+    DEFAULT_PRESSURE = 1000
+    DEFAULT_TEMPERATURE = 25
+
+    def self.for_horizontal_coordinates(
+      coordinates:,
+      pressure: DEFAULT_PRESSURE,
+      temperature: DEFAULT_TEMPERATURE
+    )
+      new(coordinates, pressure, temperature).refract
+    end
+
+    def initialize(coordinates, pressure, temperature)
+      @coordinates = coordinates
+      @pressure = pressure
+      @temperature = temperature
+    end
+
+    # Source:
+    #  Title: Practical Astronomy with your Calculator or Spreadsheet
+    #  Authors: Peter Duffett-Smith and Jonathan Zwart
+    #  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,
+        latitude: @coordinates.latitude,
+        longitude: @coordinates.longitude
+      )
+    end
+  end
+end

data/lib/astronoby/true_obliquity.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Astronoby
+  class TrueObliquity
+    def self.for_epoch(epoch)
+      mean_obliquity = MeanObliquity.for_epoch(epoch)
+      nutation = Nutation.for_obliquity_of_the_ecliptic(epoch: epoch)
+
+      mean_obliquity + nutation
+    end
+  end
+end

data/lib/astronoby/util/astrodynamics.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Astronoby
+  module Util
+    module Astrodynamics
+      class << self
+        # Source:
+        #  Title: Celestial Calculations
+        #  Author: J. L. Lawrence
+        #  Edition: MIT Press
+        #  Chapter: 4 - Orbits and Coordinate Systems
+        def eccentric_anomaly_newton_raphson(
+          mean_anomaly,
+          orbital_eccentricity,
+          precision,
+          maximum_iteration_count,
+          current_iteration = 0,
+          solution_on_previous_interation = nil
+        )
+          previous_solution = solution_on_previous_interation&.radians
+
+          solution = if previous_solution.nil?
+            if orbital_eccentricity <= 0.75
+              mean_anomaly.radians
+            else
+              Math::PI
+            end
+          else
+            previous_solution - (
+              (
+                previous_solution -
+                orbital_eccentricity * Math.sin(previous_solution) -
+                mean_anomaly.radians
+              ) / (
+                1 - orbital_eccentricity * Math.cos(previous_solution)
+              )
+            )
+          end
+
+          if current_iteration >= maximum_iteration_count ||
+              (
+                previous_solution &&
+                (solution - previous_solution).abs <= precision
+              )
+            return Angle.as_radians(solution)
+          end
+
+          eccentric_anomaly_newton_raphson(
+            mean_anomaly,
+            orbital_eccentricity,
+            precision,
+            maximum_iteration_count,
+            current_iteration + 1,
+            Angle.as_radians(solution)
+          )
+        end
+      end
+    end
+  end
+end