astronoby 0.6.0 → 0.8.0

data/lib/astronoby/bodies/saturn.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Astronoby
+  class Saturn < SolarSystemBody
+    EQUATORIAL_RADIUS = Distance.from_meters(60_268_000)
+    ABSOLUTE_MAGNITUDE = -8.914
+
+    def self.ephemeris_segments(_ephem_source)
+      [[SOLAR_SYSTEM_BARYCENTER, SATURN_BARYCENTER]]
+    end
+
+    def self.absolute_magnitude
+      ABSOLUTE_MAGNITUDE
+    end
+
+    private
+
+    # Source:
+    #  Title: Computing Apparent Planetary Magnitudes for The Astronomical
+    #    Almanac (2018)
+    #  Authors: Anthony Mallama and James L. Hilton
+    def magnitude_correction_term
+      phase_angle_degrees = phase_angle.degrees
+      if phase_angle_degrees <= 6
+        -0.036 -
+          3.7 * 10**-4 * phase_angle_degrees +
+          6.16 * 10**-4 * phase_angle_degrees * phase_angle_degrees
+      else
+        0.026 +
+          2.446 * 10**-4 * phase_angle_degrees +
+          2.672 * 10**-4 * phase_angle_degrees * phase_angle_degrees -
+          1.505 * 10**-6 * phase_angle_degrees**3 +
+          4.767 * 10**-9 * phase_angle_degrees**4
+      end
+    end
+  end
+end

data/lib/astronoby/bodies/solar_system_body.rb

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+module Astronoby
+  class SolarSystemBody
+    SOLAR_SYSTEM_BARYCENTER = 0
+    SUN = 10
+    MERCURY_BARYCENTER = 1
+    MERCURY = 199
+    VENUS_BARYCENTER = 2
+    VENUS = 299
+    EARTH_MOON_BARYCENTER = 3
+    EARTH = 399
+    MOON = 301
+    MARS_BARYCENTER = 4
+    JUPITER_BARYCENTER = 5
+    SATURN_BARYCENTER = 6
+    URANUS_BARYCENTER = 7
+    NEPTUNE_BARYCENTER = 8
+
+    attr_reader :geometric, :instant
+
+    def self.geometric(ephem:, instant:)
+      compute_geometric(ephem: ephem, instant: instant)
+    end
+
+    def self.compute_geometric(ephem:, instant:)
+      segments = ephemeris_segments(ephem.type)
+      segment1 = segments[0]
+      segment2 = segments[1] if segments.size == 2
+      cache_key = CacheKey.generate(:geometric, instant, segment1, segment2)
+
+      Astronoby.cache.fetch(cache_key) do
+        state1 = ephem[*segment1].state_at(instant.tt)
+
+        if segment2
+          state2 = ephem[*segment2].state_at(instant.tt)
+          position = state1.position + state2.position
+          velocity = state1.velocity + state2.velocity
+        else
+          position = state1.position
+          velocity = state1.velocity
+        end
+
+        position_vector = Vector[
+          Distance.from_kilometers(position.x),
+          Distance.from_kilometers(position.y),
+          Distance.from_kilometers(position.z)
+        ]
+
+        velocity_vector = Vector[
+          Velocity.from_kilometers_per_day(velocity.x),
+          Velocity.from_kilometers_per_day(velocity.y),
+          Velocity.from_kilometers_per_day(velocity.z)
+        ]
+
+        Geometric.new(
+          position: position_vector,
+          velocity: velocity_vector,
+          instant: instant,
+          target_body: self
+        )
+      end
+    end
+
+    def self.ephemeris_segments(_ephem_source)
+      raise NotImplementedError
+    end
+
+    def self.absolute_magnitude
+      nil
+    end
+
+    def initialize(ephem:, instant:)
+      @instant = instant
+      @geometric = compute_geometric(ephem)
+      @earth_geometric = Earth.geometric(ephem: ephem, instant: instant)
+      @light_time_corrected_position,
+        @light_time_corrected_velocity =
+        Correction::LightTimeDelay.compute(
+          center: @earth_geometric,
+          target: @geometric,
+          ephem: ephem
+        )
+      compute_sun(ephem) if requires_sun_data?
+    end
+
+    def astrometric
+      @astrometric ||= Astrometric.build_from_geometric(
+        instant: @instant,
+        earth_geometric: @earth_geometric,
+        light_time_corrected_position: @light_time_corrected_position,
+        light_time_corrected_velocity: @light_time_corrected_velocity,
+        target_body: self
+      )
+    end
+
+    def mean_of_date
+      @mean_of_date ||= MeanOfDate.build_from_geometric(
+        instant: @instant,
+        target_geometric: @geometric,
+        earth_geometric: @earth_geometric,
+        target_body: self
+      )
+    end
+
+    def apparent
+      @apparent ||= Apparent.build_from_astrometric(
+        instant: @instant,
+        target_astrometric: astrometric,
+        earth_geometric: @earth_geometric,
+        target_body: self
+      )
+    end
+
+    def observed_by(observer)
+      Topocentric.build_from_apparent(
+        apparent: apparent,
+        observer: observer,
+        instant: @instant,
+        target_body: self
+      )
+    end
+
+    # Returns the constellation of the body
+    # @return [Astronoby::Constellation, nil]
+    def constellation
+      @constellation ||= Constellations::Finder.find(
+        Precession.for_equatorial_coordinates(
+          coordinates: astrometric.equatorial,
+          epoch: JulianDate::B1875
+        )
+      )
+    end
+
+    # Source:
+    #  Title: Astronomical Algorithms
+    #  Author: Jean Meeus
+    #  Edition: 2nd edition
+    #  Chapter: 48 - Illuminated Fraction of the Moon's Disk
+    # @return [Astronoby::Angle, nil] Phase angle of the body
+    def phase_angle
+      return unless @sun
+
+      @phase_angle ||= begin
+        geocentric_elongation = Angle.acos(
+          @sun.apparent.equatorial.declination.sin *
+          apparent.equatorial.declination.sin +
+          @sun.apparent.equatorial.declination.cos *
+          apparent.equatorial.declination.cos *
+          (
+            @sun.apparent.equatorial.right_ascension -
+              apparent.equatorial.right_ascension
+          ).cos
+        )
+
+        term1 = @sun.astrometric.distance.km * geocentric_elongation.sin
+        term2 = astrometric.distance.km -
+          @sun.astrometric.distance.km * geocentric_elongation.cos
+        angle = Angle.atan(term1 / term2)
+        Astronoby::Util::Trigonometry
+          .adjustement_for_arctangent(term1, term2, angle)
+      end
+    end
+
+    # Fraction between 0 and 1 of the body's disk that is illuminated.
+    # @return [Float, nil] Body's illuminated fraction, between 0 and 1.
+    def illuminated_fraction
+      return unless phase_angle
+
+      @illuminated_fraction ||= (1 + phase_angle.cos) / 2.0
+    end
+
+    # Source:
+    #  Title: Astronomical Algorithms
+    #  Author: Jean Meeus
+    #  Edition: 2nd edition
+    #  Chapter: 48 - Illuminated Fraction of the Moon's Disk
+    # Apparent magnitude of the body, as seen from Earth.
+    # @return [Float, nil] Apparent magnitude of the body.
+    def apparent_magnitude
+      return unless self.class.absolute_magnitude
+
+      @apparent_magnitude ||= begin
+        body_sun_distance =
+          (astrometric.position - @sun.astrometric.position).magnitude
+        self.class.absolute_magnitude +
+          5 * Math.log10(body_sun_distance.au * astrometric.distance.au) +
+          magnitude_correction_term
+      end
+    end
+
+    # Angular diameter of the body, as seen from Earth. Based on the apparent
+    #   position of the body.
+    # @return [Astronoby::Angle] Angular diameter of the body
+    def angular_diameter
+      @angular_radius ||= begin
+        return if apparent.position.zero?
+
+        Angle.from_radians(
+          Math.asin(self.class::EQUATORIAL_RADIUS.m / apparent.distance.m) * 2
+        )
+      end
+    end
+
+    private
+
+    # By default, Solar System bodies expose attributes that are dependent on
+    # the Sun's position, such as phase angle and illuminated fraction.
+    # If a body does not require Sun data, it should override this method to
+    # return false.
+    def requires_sun_data?
+      true
+    end
+
+    def compute_geometric(ephem)
+      self.class.compute_geometric(ephem: ephem, instant: @instant)
+    end
+
+    def compute_sun(ephem)
+      @sun ||= Sun.new(instant: @instant, ephem: ephem)
+    end
+
+    # Source:
+    #  Title: Explanatory Supplement to the Astronomical Almanac
+    #  Authors: Sean E. Urban and P. Kenneth Seidelmann
+    #  Edition: University Science Books
+    #  Chapter: 10.3 - Phases and Magnitudes
+    def magnitude_correction_term
+      -2.5 * Math.log10(illuminated_fraction)
+    end
+  end
+end

data/lib/astronoby/bodies/sun.rb

@@ -1,29 +1,29 @@
 # frozen_string_literal: true
 
 module Astronoby
-  class Sun
-    SEMI_MAJOR_AXIS_IN_METERS = 149_598_500_000
-    ANGULAR_DIAMETER = Angle.from_degrees(0.533128)
-    INTERPOLATION_FACTOR = 24.07
+  class Sun < SolarSystemBody
+    EQUATORIAL_RADIUS = Distance.from_meters(695_700_000)
+    ABSOLUTE_MAGNITUDE = -26.74
 
-    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
+    def self.ephemeris_segments(_ephem_source)
+      [[SOLAR_SYSTEM_BARYCENTER, SUN]]
+    end
 
-    PERIODS_OF_THE_DAY = [
-      MORNING = :morning,
-      EVENING = :evening
-    ].freeze
+    def self.absolute_magnitude
+      ABSOLUTE_MAGNITUDE
+    end
 
-    attr_reader :time
+    # Source:
+    #  Title: Explanatory Supplement to the Astronomical Almanac
+    #  Authors: Sean E. Urban and P. Kenneth Seidelmann
+    #  Edition: University Science Books
+    #  Chapter: 10.3 - Phases and Magnitudes
+    # Apparent magnitude of the body, as seen from Earth.
+    # @return [Float] Apparent magnitude of the body.
+    def apparent_magnitude
+      @apparent_magnitude ||=
+        self.class.absolute_magnitude + 5 * Math.log10(astrometric.distance.au)
+    end
 
     # Source:
     #  Title: Astronomical Algorithms
@@ -31,215 +31,34 @@ module Astronoby
     #  Edition: 2nd edition
     #  Chapter: 28 - Equation of Time
 
-    # @param date_or_time [Date, Time] Requested date
     # @return [Integer] Equation of time in seconds
-    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)
-        .right_ascension
-      t = (epoch - Epoch::J2000) / Constants::DAYS_PER_JULIAN_MILLENIA
+    def equation_of_time
+      right_ascension = apparent.equatorial.right_ascension
+      t = (@instant.julian_date - JulianDate::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)
+      nutation = Nutation.new(instant: instant).nutation_in_longitude
+      obliquity = TrueObliquity.at(@instant)
 
       (
         Angle
-         .from_degrees(
-           l0 -
-           Constants::EQUATION_OF_TIME_CONSTANT -
-           right_ascension.degrees +
-           nutation.degrees * obliquity.cos
-         ).hours * Constants::SECONDS_PER_HOUR
+          .from_degrees(
+            l0 -
+              Constants::EQUATION_OF_TIME_CONSTANT -
+              right_ascension.degrees +
+              nutation.degrees * obliquity.cos
+          ).hours * Constants::SECONDS_PER_HOUR
       ).round
     end
 
-    # Source:
-    #  Title: Celestial Calculations
-    #  Author: J. L. Lawrence
-    #  Edition: MIT Press
-    #  Chapter: 6 - The Sun
-
-    # @param time [Time] Considered time
-    def initialize(time:)
-      @time = time
-    end
-
-    def epoch
-      @epoch ||= Epoch.from_time(@time)
-    end
-
-    def true_ecliptic_coordinates
-      Coordinates::Ecliptic.new(
-        latitude: Angle.zero,
-        longitude: true_longitude
-      )
-    end
-
-    def apparent_ecliptic_coordinates
-      nutation = Nutation.for_ecliptic_longitude(epoch: epoch)
-      longitude_with_aberration = Aberration.for_ecliptic_coordinates(
-        coordinates: true_ecliptic_coordinates,
-        epoch: epoch
-      ).longitude
-      apparent_longitude = nutation + longitude_with_aberration
-
-      Coordinates::Ecliptic.new(
-        latitude: Angle.zero,
-        longitude: apparent_longitude
-      )
-    end
-
-    # Computes the Sun's horizontal coordinates
-    #
-    # @param observer [Astronoby::Observer] Observer of the event
-    # @return [Astronoby::Coordinates::Horizontal] Sun's horizontal coordinates
-    def horizontal_coordinates(observer:)
-      apparent_ecliptic_coordinates
-        .to_apparent_equatorial(epoch: epoch)
-        .to_horizontal(time: @time, observer: observer)
-    end
-
-    # @param observer [Astronoby::Observer] Observer of the event
-    # @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 events
-    # @return [Astronoby::Events::TwilightEvents] Sun's twilight events
-    def twilight_events(observer:)
-      Events::TwilightEvents.new(sun: self, observer: observer)
-    end
-
-    # @return [Astronoby::Distance] Earth-Sun distance
-    def earth_distance
-      Distance.from_meters(
-        SEMI_MAJOR_AXIS_IN_METERS / distance_angular_size_factor
-      )
-    end
-
-    # @return [Astronoby::Angle] Apparent Sun's angular size
-    def angular_size
-      Angle.from_degrees(
-        ANGULAR_DIAMETER.degrees * distance_angular_size_factor
-      )
-    end
-
-    # @return [Astronoby::Angle] Sun's true anomaly
-    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.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) %
-          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) %
-          Constants::DEGREES_PER_CIRCLE
-      )
-    end
-
     private
 
-    def true_longitude
-      Angle.from_degrees(
-        (true_anomaly + longitude_at_perigee).degrees %
-          Constants::DEGREES_PER_CIRCLE
-      )
-    end
-
-    def days_since_epoch
-      Epoch::DEFAULT_EPOCH - epoch
-    end
-
-    def centuries
-      @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) %
-          Constants::DEGREES_PER_CIRCLE
-      )
-    end
-
-    def distance_angular_size_factor
-      term1 = 1 + orbital_eccentricity.degrees * true_anomaly.cos
-      term2 = 1 - orbital_eccentricity.degrees**2
-
-      term1 / term2
+    def requires_sun_data?
+      false
     end
   end
 end

data/lib/astronoby/bodies/uranus.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Astronoby
+  class Uranus < SolarSystemBody
+    EQUATORIAL_RADIUS = Distance.from_meters(25_559_000)
+    ABSOLUTE_MAGNITUDE = -7.11
+
+    def self.ephemeris_segments(_ephem_source)
+      [[SOLAR_SYSTEM_BARYCENTER, URANUS_BARYCENTER]]
+    end
+
+    def self.absolute_magnitude
+      ABSOLUTE_MAGNITUDE
+    end
+  end
+end

data/lib/astronoby/bodies/venus.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Astronoby
+  class Venus < SolarSystemBody
+    EQUATORIAL_RADIUS = Distance.from_meters(6_051_800)
+    ABSOLUTE_MAGNITUDE = -4.384
+
+    def self.ephemeris_segments(_ephem_source)
+      [[SOLAR_SYSTEM_BARYCENTER, VENUS_BARYCENTER]]
+    end
+
+    def self.absolute_magnitude
+      ABSOLUTE_MAGNITUDE
+    end
+
+    private
+
+    # Source:
+    #  Title: Computing Apparent Planetary Magnitudes for The Astronomical
+    #    Almanac (2018)
+    #  Authors: Anthony Mallama and James L. Hilton
+    def magnitude_correction_term
+      phase_angle_degrees = phase_angle.degrees
+      if phase_angle_degrees < 163.7
+        -1.044 * 10**-3 * phase_angle_degrees +
+          3.687 * 10**-4 * phase_angle_degrees * phase_angle_degrees -
+          2.814 * 10**-6 * phase_angle_degrees**3 +
+          8.938 * 10**-9 * phase_angle_degrees**4
+
+      else
+        240.44228 - 2.81914 * phase_angle_degrees +
+          8.39034 * 10**-3 * phase_angle_degrees * phase_angle_degrees
+      end
+    end
+  end
+end