astronoby 0.8.0 → 0.10.0

data/lib/astronoby/stellar_propagation.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module Astronoby
+  class StellarPropagation
+    # @return [Astronoby::Vector] Propagated position vector of
+    #   Astronoby::Distance components
+    def self.position_for(**kwargs)
+      new(**kwargs).position
+    end
+
+    # @return [Astronoby::Vector] Propagated position vector of
+    #   Astronoby::Velocity components
+    def self.velocity_vector_for(**kwargs)
+      new(**kwargs).velocity_vector
+    end
+
+    # @return [Astronoby::Coordinates::Equatorial] Propagated equatorial
+    #   coordinates
+    def self.equatorial_coordinates_for(**kwargs)
+      new(**kwargs).equatorial_coordinates
+    end
+
+    # @param instant [Astronoby::Instant] Instant of the observation
+    # @param equatorial_coordinates [Astronoby::Coordinates::Equatorial]
+    #   Equatorial coordinates at epoch J2000.0
+    # @param proper_motion_ra [Astronoby::AngularVelocity] Proper motion in
+    #   right ascension
+    # @param proper_motion_dec [Astronoby::AngularVelocity] Proper motion in
+    #   declination
+    # @param parallax [Astronoby::Angle] Parallax angle
+    # @param radial_velocity [Astronoby::Velocity] Radial velocity
+    # @param earth_geometric [Astronoby::ReferenceFrame::Geometric, nil]
+    #   Geometric reference frame of the Earth
+    def initialize(
+      instant:,
+      equatorial_coordinates:,
+      proper_motion_ra:,
+      proper_motion_dec:,
+      parallax:,
+      radial_velocity:,
+      earth_geometric: nil
+    )
+      @instant = instant
+      @right_ascension = equatorial_coordinates.right_ascension
+      @declination = equatorial_coordinates.declination
+      @initial_epoch = equatorial_coordinates.epoch
+      @proper_motion_ra = proper_motion_ra
+      @proper_motion_dec = proper_motion_dec
+      @parallax = parallax
+      @radial_velocity = radial_velocity
+      @earth_geometric = earth_geometric
+    end
+
+    # @return [Astronoby::Vector] Propagated position vector of
+    #   Astronoby::Distance components
+    def position
+      @position ||= Distance.vector_from_meters(
+        initial_position_vector +
+        tangential_velocity.map(&:mps) * time_elapsed_seconds
+      )
+    end
+
+    # @return [Astronoby::Vector] Propagated position vector of
+    #   Astronoby::Velocity components
+    def velocity_vector
+      @velocity_vector ||= if @earth_geometric
+        @earth_geometric.velocity - tangential_velocity
+      else
+        tangential_velocity
+      end
+    end
+
+    # @return [Astronoby::Coordinates::Equatorial] Propagated equatorial
+    #   coordinates
+    def equatorial_coordinates
+      @equatorial_coordinates ||= begin
+        right_ascension = Util::Trigonometry.adjustement_for_arctangent(
+          position.y.m,
+          position.x.m,
+          Angle.atan(position.y.m / position.x.m)
+        )
+        declination = Angle.asin(position.z.m / position.magnitude.m)
+
+        Coordinates::Equatorial.new(
+          right_ascension: right_ascension,
+          declination: declination,
+          epoch: @instant.tt
+        )
+      end
+    end
+
+    private
+
+    def distance
+      @distance ||= Distance.from_parsecs(
+        1 / (@parallax.degrees * Constants::ARCSECONDS_PER_DEGREE)
+      )
+    end
+
+    def unit_position_vector
+      @unit_position_vector ||= Vector[
+        @right_ascension.cos * @declination.cos,
+        @right_ascension.sin * @declination.cos,
+        @declination.sin
+      ]
+    end
+
+    def right_ascension_unit_vector
+      @right_ascension_unit_vector ||= Vector[
+        -@right_ascension.sin,
+        @right_ascension.cos,
+        0.0
+      ]
+    end
+
+    def declination_unit_vector
+      @declination_unit_vector ||= Vector[
+        -@right_ascension.cos * @declination.sin,
+        -@right_ascension.sin * @declination.sin,
+        @declination.cos
+      ]
+    end
+
+    def initial_position_vector
+      @initial_position_vector ||= unit_position_vector * distance.meters
+    end
+
+    def tangential_velocity
+      @tangential_velocity ||= begin
+        # Doppler factor for light travel time correction
+        k = 1.0 / (1.0 - @radial_velocity.kmps / Velocity.light_speed.kmps)
+
+        proper_motion_ra_component =
+          @proper_motion_ra.mas_per_year / (
+            @parallax.degree_milliarcseconds * Constants::DAYS_PER_JULIAN_YEAR
+          ) * k
+        proper_motion_dec_component =
+          @proper_motion_dec.mas_per_year / (
+            @parallax.degree_milliarcseconds * Constants::DAYS_PER_JULIAN_YEAR
+          ) * k
+        radial_velocity_component = Velocity
+          .from_kmps(@radial_velocity.kmps * k)
+
+        Velocity.vector_from_astronomical_units_per_day([
+          -proper_motion_ra_component * @right_ascension.sin -
+            proper_motion_dec_component * @declination.sin * @right_ascension.cos +
+            radial_velocity_component.aupd * @declination.cos * @right_ascension.cos,
+          proper_motion_ra_component * @right_ascension.cos -
+            proper_motion_dec_component * @declination.sin * @right_ascension.sin +
+            radial_velocity_component.aupd * @declination.cos * @right_ascension.sin,
+          proper_motion_dec_component * @declination.cos +
+            radial_velocity_component.aupd * @declination.sin
+        ])
+      end
+    end
+
+    def time_elapsed_seconds
+      @time_elapsed_seconds ||=
+        (@instant.tt - @initial_epoch) * Constants::SECONDS_PER_DAY
+    end
+  end
+end

data/lib/astronoby/time/greenwich_apparent_sidereal_time.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Astronoby
+  # Greenwich Apparent Sidereal Time (GAST). Derived from GMST by applying
+  # the equation of the equinoxes (nutation correction).
+  class GreenwichApparentSiderealTime < GreenwichSiderealTime
+    # Creates GAST from UTC by computing GMST and applying the equation
+    # of the equinoxes.
+    #
+    # @param utc [Time] the UTC time
+    # @return [Astronoby::GreenwichApparentSiderealTime]
+    def self.from_utc(utc)
+      gmst = GreenwichMeanSiderealTime.from_utc(utc)
+      instant = Instant.from_time(utc)
+      nutation = Nutation.new(instant: instant)
+      mean_obliquity = MeanObliquity.at(instant)
+
+      equation_of_equinoxes = nutation.nutation_in_longitude.hours *
+        mean_obliquity.cos
+      gast_time = normalize_time(gmst.time + equation_of_equinoxes)
+
+      new(date: gmst.date, time: gast_time)
+    end
+
+    # @param date [Date] the calendar date
+    # @param time [Numeric] GAST in hours
+    def initialize(date:, time:)
+      super(date: date, time: time, type: APPARENT)
+    end
+  end
+end

data/lib/astronoby/time/greenwich_mean_sidereal_time.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "iers"
+
+module Astronoby
+  # Greenwich Mean Sidereal Time (GMST). Computed from UTC using the IERS
+  # Conventions 2010 ERA-based expression, with a polynomial fallback for
+  # dates outside the IERS EOP data range.
+  class GreenwichMeanSiderealTime < GreenwichSiderealTime
+    JULIAN_CENTURIES_EXPONENTS = [
+      6.697374558,
+      2400.051336,
+      0.000025862
+    ].freeze
+
+    SIDEREAL_MINUTE_IN_UT_MINUTE = 0.9972695663
+
+    UT_TO_SIDEREAL_RATIO = 1.002737909
+
+    # Creates GMST from UTC using the IERS Conventions 2010 ERA-based
+    # expression.
+    #
+    # Source:
+    #  Title: IERS Conventions (2010)
+    #  Chapter: 5.5.7 - ERA based expressions for Greenwich Sidereal Time
+    #
+    # @param utc [Time] the UTC time
+    # @return [Astronoby::GreenwichMeanSiderealTime]
+    def self.from_utc(utc)
+      date = utc.to_date
+      gmst_hours = begin
+        gmst_radians = IERS::GMST.at(utc)
+        gmst_radians * 12.0 / Math::PI
+      rescue IERS::OutOfRangeError
+        from_utc_polynomial(utc)
+      end
+      gmst_hours = normalize_time(gmst_hours)
+
+      new(date: date, time: gmst_hours)
+    end
+
+    # Polynomial fallback for dates outside the IERS EOP data range.
+    #
+    # Source:
+    #  Title: Practical Astronomy with your Calculator or Spreadsheet
+    #  Authors: Peter Duffett-Smith and Jonathan Zwart
+    #  Edition: Cambridge University Press
+    #  Chapter: 12 - Conversion of UT to Greenwich sidereal time (GST)
+    #
+    # @param utc [Time] the UTC time
+    # @return [Numeric] GMST in hours
+    def self.from_utc_polynomial(utc)
+      julian_day = utc.to_date.ajd
+      t = (julian_day - JulianDate::J2000) / Constants::DAYS_PER_JULIAN_CENTURY
+      t0 = (
+        (JULIAN_CENTURIES_EXPONENTS[0] +
+          (JULIAN_CENTURIES_EXPONENTS[1] * t) +
+          (JULIAN_CENTURIES_EXPONENTS[2] * t * t)) % Constants::HOURS_PER_DAY
+      ).abs
+
+      ut_in_hours = utc.hour +
+        utc.min / Constants::MINUTES_PER_HOUR +
+        (utc.sec + utc.subsec) / Constants::SECONDS_PER_HOUR
+
+      UT_TO_SIDEREAL_RATIO * ut_in_hours + t0
+    end
+
+    # @param date [Date] the calendar date
+    # @param time [Numeric] GMST in hours
+    def initialize(date:, time:)
+      super(date: date, time: time, type: MEAN)
+    end
+
+    # Converts GMST back to UTC.
+    #
+    # Source:
+    #  Title: Practical Astronomy with your Calculator or Spreadsheet
+    #  Authors: Peter Duffett-Smith and Jonathan Zwart
+    #  Edition: Cambridge University Press
+    #  Chapter: 13 - Conversion of GST to UT
+    #
+    # @return [Time] the UTC time
+    def to_utc
+      date = @date
+      julian_day = @date.ajd
+      t = (julian_day - JulianDate::J2000) / Constants::DAYS_PER_JULIAN_CENTURY
+
+      t0 = (
+        (JULIAN_CENTURIES_EXPONENTS[0] +
+          (JULIAN_CENTURIES_EXPONENTS[1] * t) +
+          (JULIAN_CENTURIES_EXPONENTS[2] * t * t)) % Constants::HOURS_PER_DAY
+      ).abs
+
+      a = normalize_time(@time - t0)
+
+      utc = SIDEREAL_MINUTE_IN_UT_MINUTE * a
+
+      Util::Time.decimal_hour_to_time(date, 0, utc)
+    end
+  end
+end

data/lib/astronoby/time/greenwich_sidereal_time.rb

@@ -1,73 +1,56 @@
 # frozen_string_literal: true
 
 module Astronoby
-  class GreenwichSiderealTime
-    JULIAN_CENTURIES_EXPONENTS = [
-      6.697374558,
-      2400.051336,
-      0.000025862
-    ].freeze
-
-    SIDEREAL_MINUTE_IN_UT_MINUTE = 0.9972695663
-
-    attr_reader :date, :time
-
-    # Source:
-    #  Title: Practical Astronomy with your Calculator or Spreadsheet
-    #  Authors: Peter Duffett-Smith and Jonathan Zwart
-    #  Edition: Cambridge University Press
-    #  Chapter: 12 - Conversion of UT to Greenwich sidereal time (GST)
-    def self.from_utc(utc)
-      date = utc.to_date
-      julian_day = utc.to_date.ajd
-      t = (julian_day - JulianDate::J2000) / Constants::DAYS_PER_JULIAN_CENTURY
-      t0 = (
-        (JULIAN_CENTURIES_EXPONENTS[0] +
-          (JULIAN_CENTURIES_EXPONENTS[1] * t) +
-          (JULIAN_CENTURIES_EXPONENTS[2] * t * t)) % Constants::HOURS_PER_DAY
-      ).abs
-
-      ut_in_hours = utc.hour +
-        utc.min / Constants::MINUTES_PER_HOUR +
-        (utc.sec + utc.subsec) / Constants::SECONDS_PER_HOUR
-
-      gmst = 1.002737909 * ut_in_hours + t0
-      gmst += Constants::HOURS_PER_DAY if gmst.negative?
-      gmst -= Constants::HOURS_PER_DAY if gmst > Constants::HOURS_PER_DAY
+  # Greenwich Sidereal Time base class. Dispatches to mean or apparent
+  # subclasses.
+  class GreenwichSiderealTime < SiderealTime
+    # Creates a Greenwich Sidereal Time from UTC.
+    #
+    # @param utc [Time] the UTC time
+    # @param type [Symbol] :mean or :apparent
+    # @return [Astronoby::GreenwichMeanSiderealTime,
+    #   Astronoby::GreenwichApparentSiderealTime]
+    def self.from_utc(utc, type: MEAN)
+      validate_type!(type)
+      case type
+      when MEAN
+        GreenwichMeanSiderealTime.from_utc(utc)
+      when APPARENT
+        GreenwichApparentSiderealTime.from_utc(utc)
+      end
+    end
 
-      new(date: date, time: gmst)
+    # @param utc [Time] the UTC time
+    # @return [Astronoby::GreenwichMeanSiderealTime]
+    def self.mean_from_utc(utc)
+      GreenwichMeanSiderealTime.from_utc(utc)
     end
 
-    def initialize(date:, time:)
-      @date = date
-      @time = time
+    # @param utc [Time] the UTC time
+    # @return [Astronoby::GreenwichApparentSiderealTime]
+    def self.apparent_from_utc(utc)
+      GreenwichApparentSiderealTime.from_utc(utc)
     end
 
-    # Source:
-    #  Title: Practical Astronomy with your Calculator or Spreadsheet
-    #  Authors: Peter Duffett-Smith and Jonathan Zwart
-    #  Edition: Cambridge University Press
-    #  Chapter: 13 - Conversion of GST to UT
+    # Converts to UTC.
+    #
+    # @return [Time] the UTC time
+    # @raise [NotImplementedError] if this is apparent sidereal time
     def to_utc
-      date = @date
-      julian_day = @date.ajd
-      t = (julian_day - JulianDate::J2000) / Constants::DAYS_PER_JULIAN_CENTURY
-
-      t0 = (
-        (JULIAN_CENTURIES_EXPONENTS[0] +
-          (JULIAN_CENTURIES_EXPONENTS[1] * t) +
-          (JULIAN_CENTURIES_EXPONENTS[2] * t * t)) % Constants::HOURS_PER_DAY
-      ).abs
-
-      a = @time - t0
-      a += Constants::HOURS_PER_DAY if a.negative?
-      a -= Constants::HOURS_PER_DAY if a > Constants::HOURS_PER_DAY
-
-      utc = SIDEREAL_MINUTE_IN_UT_MINUTE * a
+      unless mean?
+        raise NotImplementedError,
+          "UTC conversion only supported for mean sidereal time"
+      end
 
-      Util::Time.decimal_hour_to_time(date, 0, utc)
+      gmst = GreenwichMeanSiderealTime.new(date: @date, time: @time)
+      gmst.to_utc
     end
 
+    # Converts to Local Sidereal Time for a given longitude.
+    #
+    # @param longitude [Astronoby::Angle] the observer's longitude
+    # @return [Astronoby::LocalMeanSiderealTime,
+    #   Astronoby::LocalApparentSiderealTime]
     def to_lst(longitude:)
       LocalSiderealTime.from_gst(gst: self, longitude: longitude)
     end

data/lib/astronoby/time/local_apparent_sidereal_time.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Astronoby
+  # Local Apparent Sidereal Time (LAST). Derived from GAST by adding the
+  # observer's longitude.
+  class LocalApparentSiderealTime < LocalSiderealTime
+    # Creates LAST from a Greenwich Apparent Sidereal Time and longitude.
+    #
+    # Source:
+    #  Title: Practical Astronomy with your Calculator or Spreadsheet
+    #  Authors: Peter Duffett-Smith and Jonathan Zwart
+    #  Edition: Cambridge University Press
+    #  Chapter: 14 - Local sidereal time (LST)
+    #
+    # @param gst [Astronoby::GreenwichApparentSiderealTime] GAST
+    # @param longitude [Astronoby::Angle] the observer's longitude
+    # @return [Astronoby::LocalApparentSiderealTime]
+    # @raise [ArgumentError] if gst is not apparent sidereal time
+    def self.from_gst(gst:, longitude:)
+      unless gst.apparent?
+        raise ArgumentError, "GST must be apparent sidereal time"
+      end
+
+      date = gst.date
+      time = normalize_time(gst.time + longitude.hours)
+
+      new(date: date, time: time, longitude: longitude)
+    end
+
+    # Creates LAST from UTC and longitude.
+    #
+    # @param utc [Time] the UTC time
+    # @param longitude [Astronoby::Angle] the observer's longitude
+    # @return [Astronoby::LocalApparentSiderealTime]
+    def self.from_utc(utc, longitude:)
+      gast = GreenwichApparentSiderealTime.from_utc(utc)
+      from_gst(gst: gast, longitude: longitude)
+    end
+
+    # @param date [Date] the calendar date
+    # @param time [Numeric] LAST in hours
+    # @param longitude [Astronoby::Angle] the observer's longitude
+    def initialize(date:, time:, longitude:)
+      super(date: date, time: time, longitude: longitude, type: APPARENT)
+    end
+
+    # Converts to Greenwich Apparent Sidereal Time.
+    #
+    # Source:
+    #  Title: Practical Astronomy with your Calculator or Spreadsheet
+    #  Authors: Peter Duffett-Smith and Jonathan Zwart
+    #  Edition: Cambridge University Press
+    #  Chapter: 15 - Converting LST to GST
+    #
+    # @return [Astronoby::GreenwichApparentSiderealTime]
+    def to_gst
+      date = @date
+      time = normalize_time(@time - @longitude.hours)
+
+      GreenwichApparentSiderealTime.new(date: date, time: time)
+    end
+  end
+end

data/lib/astronoby/time/local_mean_sidereal_time.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Astronoby
+  # Local Mean Sidereal Time (LMST). Derived from GMST by adding the
+  # observer's longitude.
+  class LocalMeanSiderealTime < LocalSiderealTime
+    # Creates LMST from a Greenwich Mean Sidereal Time and longitude.
+    #
+    # Source:
+    #  Title: Practical Astronomy with your Calculator or Spreadsheet
+    #  Authors: Peter Duffett-Smith and Jonathan Zwart
+    #  Edition: Cambridge University Press
+    #  Chapter: 14 - Local sidereal time (LST)
+    #
+    # @param gst [Astronoby::GreenwichMeanSiderealTime] GMST
+    # @param longitude [Astronoby::Angle] the observer's longitude
+    # @return [Astronoby::LocalMeanSiderealTime]
+    # @raise [ArgumentError] if gst is not mean sidereal time
+    def self.from_gst(gst:, longitude:)
+      unless gst.mean?
+        raise ArgumentError, "GST must be mean sidereal time"
+      end
+
+      date = gst.date
+      time = normalize_time(gst.time + longitude.hours)
+
+      new(date: date, time: time, longitude: longitude)
+    end
+
+    # Creates LMST from UTC and longitude.
+    #
+    # @param utc [Time] the UTC time
+    # @param longitude [Astronoby::Angle] the observer's longitude
+    # @return [Astronoby::LocalMeanSiderealTime]
+    def self.from_utc(utc, longitude:)
+      gmst = GreenwichMeanSiderealTime.from_utc(utc)
+      from_gst(gst: gmst, longitude: longitude)
+    end
+
+    # @param date [Date] the calendar date
+    # @param time [Numeric] LMST in hours
+    # @param longitude [Astronoby::Angle] the observer's longitude
+    def initialize(date:, time:, longitude:)
+      super(date: date, time: time, longitude: longitude, type: MEAN)
+    end
+
+    # Converts to Greenwich Mean Sidereal Time.
+    #
+    # Source:
+    #  Title: Practical Astronomy with your Calculator or Spreadsheet
+    #  Authors: Peter Duffett-Smith and Jonathan Zwart
+    #  Edition: Cambridge University Press
+    #  Chapter: 15 - Converting LST to GST
+    #
+    # @return [Astronoby::GreenwichMeanSiderealTime]
+    def to_gst
+      date = @date
+      time = normalize_time(@time - @longitude.hours)
+
+      GreenwichMeanSiderealTime.new(date: date, time: time)
+    end
+  end
+end

data/lib/astronoby/time/local_sidereal_time.rb

@@ -1,41 +1,74 @@
 # frozen_string_literal: true
 
 module Astronoby
-  class LocalSiderealTime
-    attr_reader :date, :time, :longitude
+  # Local Sidereal Time base class. Dispatches to mean or apparent subclasses
+  # based on the type of the source GST.
+  class LocalSiderealTime < SiderealTime
+    # @return [Astronoby::Angle] the observer's longitude
+    attr_reader :longitude
 
-    # Source:
-    #  Title: Practical Astronomy with your Calculator or Spreadsheet
-    #  Authors: Peter Duffett-Smith and Jonathan Zwart
-    #  Edition: Cambridge University Press
-    #  Chapter: 14 - Local sidereal time (LST)
+    # Creates an LST from a Greenwich Sidereal Time and longitude.
+    #
+    # @param gst [Astronoby::GreenwichSiderealTime] Greenwich Sidereal Time
+    # @param longitude [Astronoby::Angle] the observer's longitude
+    # @return [Astronoby::LocalMeanSiderealTime,
+    #   Astronoby::LocalApparentSiderealTime]
     def self.from_gst(gst:, longitude:)
-      date = gst.date
-      time = gst.time + longitude.hours
-      time += Constants::HOURS_PER_DAY if time.negative?
-      time -= Constants::HOURS_PER_DAY if time > Constants::HOURS_PER_DAY
+      case gst.type
+      when MEAN
+        LocalMeanSiderealTime.from_gst(gst: gst, longitude: longitude)
+      when APPARENT
+        LocalApparentSiderealTime.from_gst(gst: gst, longitude: longitude)
+      end
+    end
 
-      new(date: date, time: time, longitude: longitude)
+    # Creates an LST from UTC and longitude.
+    #
+    # @param utc [Time] the UTC time
+    # @param longitude [Astronoby::Angle] the observer's longitude
+    # @param type [Symbol] :mean or :apparent
+    # @return [Astronoby::LocalMeanSiderealTime,
+    #   Astronoby::LocalApparentSiderealTime]
+    def self.from_utc(utc, longitude:, type: MEAN)
+      validate_type!(type)
+      case type
+      when MEAN
+        LocalMeanSiderealTime.from_utc(utc, longitude: longitude)
+      when APPARENT
+        LocalApparentSiderealTime.from_utc(utc, longitude: longitude)
+      end
     end
 
-    def initialize(date:, time:, longitude:)
-      @date = date
-      @time = time
+    # @param date [Date] the calendar date
+    # @param time [Numeric] the sidereal time in hours
+    # @param longitude [Astronoby::Angle] the observer's longitude
+    # @param type [Symbol] :mean or :apparent
+    def initialize(date:, time:, longitude:, type: MEAN)
+      super(date: date, time: time, type: type)
       @longitude = longitude
     end
 
-    # Source:
-    #  Title: Practical Astronomy with your Calculator or Spreadsheet
-    #  Authors: Peter Duffett-Smith and Jonathan Zwart
-    #  Edition: Cambridge University Press
-    #  Chapter: 15 - Converting LST to GST
+    # Converts to Greenwich Sidereal Time.
+    #
+    # @return [Astronoby::GreenwichMeanSiderealTime,
+    #   Astronoby::GreenwichApparentSiderealTime]
     def to_gst
-      date = @date
-      time = @time - @longitude.hours
-      time += Constants::HOURS_PER_DAY if time.negative?
-      time -= Constants::HOURS_PER_DAY if time > Constants::HOURS_PER_DAY
-
-      GreenwichSiderealTime.new(date: date, time: time)
+      case @type
+      when MEAN
+        lst = LocalMeanSiderealTime.new(
+          date: @date,
+          time: @time,
+          longitude: @longitude
+        )
+        lst.to_gst
+      when APPARENT
+        last = LocalApparentSiderealTime.new(
+          date: @date,
+          time: @time,
+          longitude: @longitude
+        )
+        last.to_gst
+      end
     end
   end
 end