orbit 0.8.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.rbc
+*.sassc
+.sass-cache
+capybara-*.html
+.rspec
+/.bundle
+/vendor/bundle
+/log/*
+/tmp/*
+/db/*.sqlite3
+/public/system/*
+/coverage/
+/spec/tmp/*
+**.orig
+rerun.txt
+pickle-email-*.html
+.DS_Store

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,14 @@
+PATH
+  remote: .
+  specs:
+    orbit (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  orbit!

data/README.md

@@ -0,0 +1,16 @@
+orbit
+=====
+
+A ruby gem for calculating satellite positions and observation angles, etc.
+
+## Usage
+
+    tle = "EYESAT-1 (AO-27)\n1 22825U 93061C   12265.90994989  .00000070  00000-0  44528-4 0  2022\n2 22825  98.5823 207.2528 0008444   2.3056 357.8161 14.29486540990291"
+    s = Orbit::Satellite.new( tle )
+    l = Orbit::Site.new( 33.5, -95.3, 23 ) # Lat, Lng, Elevation Above Sea Level in Meters
+    tc = l.view_angle_to_satellite_at_time( s, Time.now )
+
+    elevation = Orbit::OrbitGlobals.rad_to_deg( tc.elevation )
+    azimuth   = Orbit::OrbitGlobals.rad_to_deg( tc.azimuth )
+
+    puts "Elevation: #{elevation}, Azimuth: #{azimuth}"

data/lib/orbit.rb

@@ -0,0 +1,27 @@
+require 'orbit/orbit_globals'
+require 'orbit/geocentric_coordinates'
+require 'orbit/topocentric_horizon_coordinates'
+require 'orbit/julian'
+require 'orbit/norad_base'
+require 'orbit/norad_sgp4'
+require 'orbit/norad_sdp4'
+require 'orbit/eci'
+require 'orbit/site'
+require 'orbit/satellite'
+require 'orbit/tle'
+require 'orbit/orbit'
+require 'orbit/vector'
+require 'date'
+
+module Orbit
+
+end
+
+# Testing
+# tle_string = "CUBESAT XI-V (CO-58)\n1 28895U 05043F   12264.16320281  .00000287  00000-0  67805-4 0  2813\n2 28895  97.9003 126.1967 0016829 209.8455 150.1749 14.60744896367522"
+#
+# tle = Orbit::Tle.new( tle_string )
+# o   = Orbit::Orbit.new( tle )
+# eci = o.get_position( ( Time.new.utc.to_f - tle.epoch.to_f ) / 60.0 )
+# puts eci
+# puts eci.to_geo

data/lib/orbit/demo.rb

@@ -0,0 +1,152 @@
+require './orbit_globals.rb'
+require './geocentric_coordinates.rb'
+require './topocentric_horizon_coordinates.rb'
+require './julian.rb'
+require './norad_base.rb'
+require './norad_sgp4.rb'
+require './norad_sdp4.rb'
+require './eci.rb'
+require './site.rb'
+require './tle.rb'
+require './orbit.rb'
+require './vector.rb'
+require 'pp'
+require 'date'
+
+# def PrintPosVel(Tle tle)
+#    const int Step = 360;
+#
+#    Orbit     orbit  = new Orbit(tle);
+#    List<Eci> coords = new List<Eci>();
+#
+#    # Calculate position, velocity
+#    # mpe = "minutes past epoch"
+#    for (int mpe = 0; mpe <= (Step * 4); mpe += Step)
+#    {
+#       # Get the position of the satellite at time "mpe".
+#       # The coordinates are placed into the variable "eci".
+#       Eci eci = orbit.GetPosition(mpe);
+#
+#       # Add the coordinate object to the list
+#       coords.Add(eci);
+#    }
+#
+#    # Print TLE data
+#    Console.Write("{0}\n", tle.Name);
+#    Console.Write("{0}\n", tle.Line1);
+#    Console.Write("{0}\n", tle.Line2);
+#
+#    # Header
+#    Console.Write("\n  TSINCE            X                Y                Z\n\n");
+#
+#    # Iterate over each of the ECI position objects pushed onto the
+#    # coordinate list, above, printing the ECI position information
+#    # as we go.
+#    for (int i = 0; i < coords.Count; i++)
+#    {
+#       Eci e = coords[i] as Eci;
+#
+#       Console.Write("{0,8}.00 {1,16:f8} {2,16:f8} {3,16:f8}\n",
+#                     i * Step,
+#                     e.Position.X,
+#                     e.Position.Y,
+#                     e.Position.Z);
+#    }
+#
+#    Console.Write("\n                  XDOT             YDOT             ZDOT\n\n");
+#
+#    # Iterate over each of the ECI position objects in the coordinate
+#    # list again, but this time print the velocity information.
+#    for (int i = 0; i < coords.Count; i++)
+#    {
+#       Eci e = coords[i] as Eci;
+#
+#       Console.Write("{0,24:f8} {1,16:f8} {2,16:f8}\n",
+#                     e.Velocity.X,
+#                     e.Velocity.Y,
+#                     e.Velocity.Z);
+#    }
+# end
+
+
+tle_string  = "OSCAR 3\n"
+tle_string += "1 01293U 65016F   12263.95608778 +.00000319 +00000-0 +23014-3 0 04606\n"
+tle_string += "2 01293 070.0701 117.1490 0017260 014.5647 345.5955 14.05174409427057"
+
+tle1 = Tle.new(tle_string)
+
+#puts tle1
+
+# PrintPosVel(tle1);
+
+# puts ""
+
+# Test SDP4
+# tle_string =  "AO-7\n"
+# tle_string += "1 07530U 74089B   12263.39564296 -.00000027  00000-0  10000-3 0  4844\n"
+# tle_string += "2 07530 101.4097 256.9929 0012088  96.9320 263.3131 12.53591429731853"
+
+tle2 = Tle.new(tle_string)
+
+# pp tle2
+# puts "Epoch: #{tle2.epoch}"
+# puts "Now: #{Time.now}"
+
+diff = ( Time.new.to_i - tle2.epoch.to_i ) / 60.0
+
+# puts "Diff: #{diff}"
+
+# PrintPosVel(tle2);
+
+#puts "\nExample output:"
+
+# Example: Define a location on the earth, then determine the look-angle
+# to the SDP4 satellite defined above.
+
+# Create an orbit object using the SDP4 TLE object.
+orbitSDP4 = Orbit.new(tle2)
+
+# pp orbitSDP4
+
+# Get the location of the satellite from the Orbit object. The
+# earth-centered inertial information is placed into eciSDP4.
+# Here we ask for the location of the satellite 90 minutes after
+# the TLE epoch.
+eciSDP4 = orbitSDP4.get_position( diff )
+
+eciGeo = eciSDP4.to_geo
+#pp eciSDP4
+
+sat_lat = OrbitGlobals.rad_to_deg( eciGeo.latitude_rad )
+sat_lon = OrbitGlobals.rad_to_deg( eciGeo.longitude_rad )
+sat_alt = eciGeo.altitude
+
+if sat_lon > 180
+  sat_lon = 360 - sat_lon
+  sat_lon *= -1
+end
+
+puts "Sat Lat: #{sat_lat }"
+puts "Sat Lon: #{sat_lon}"
+puts "Sat Ele: #{sat_alt}"
+
+# Now create a site object. Site objects represent a location on the
+# surface of the earth. Here we arbitrarily select a point on the
+# equator.
+site_me = Site.new(33.5, -112.05, 380) # 0.00 N, 100.00 W, 0 km altitude
+
+# pp site_me.get_position( eciSDP4.date )
+
+# Now get the "look angle" from the site to the satellite.
+# Note that the ECI object "eciSDP4" has a time associated
+# with the coordinates it contains; this is the time at which
+# the look angle is valid.
+topoLook = site_me.get_look_angle(eciSDP4)
+
+# pp topoLook
+
+# Print out the results. Note that the Azimuth and Elevation are
+# stored in the CoordTopo object as radians. Here we convert
+# to degrees using Rad2Deg()
+
+puts "AZ: #{OrbitGlobals.rad_to_deg(topoLook.azimuth).to_f}  EL: #{OrbitGlobals.rad_to_deg(topoLook.elevation).to_f}"

data/lib/orbit/eci.rb

@@ -0,0 +1,130 @@
+module Orbit
+  class Eci
+    attr_accessor :m_Position
+    attr_accessor :m_Velocity
+    attr_accessor :m_Date
+
+    def self.new_with_pos_vel_gmt(pos, vel, gmt)
+      # puts "new_with_pos_vel_gmt #{pos}, #{vel}, #{gmt}"
+
+      eci = self.new
+
+      eci.m_Position = pos
+      eci.m_Velocity = vel
+      eci.m_Date     = gmt
+
+      eci
+    end
+
+    def initialize( geo = nil, date = nil )
+      if !geo.nil? && !date.nil?
+        setup( geo, date )
+      end
+    end
+
+    def setup( geo, date )
+      # puts "Eci.setup( geo, #{date} )"
+         mfactor = OrbitGlobals::TWO_PI * (OrbitGlobals::OMEGAE / OrbitGlobals::SEC_PER_DAY)
+         lat = geo.latitude_rad
+         lon = geo.longitude_rad
+         alt = geo.altitude
+
+         # Calculate Local Mean Sidereal Time (theta)
+         theta = OrbitGlobals.time_to_lmst( date, lon )
+         c = 1.0 / Math.sqrt(1.0 + OrbitGlobals::F * (OrbitGlobals::F - 2.0) * OrbitGlobals::sqr(Math.sin(lat)))
+         s = ((1.0 - OrbitGlobals::F) ** 2 ) * c
+         achcp = (OrbitGlobals::XKMPER * c + alt) * Math.cos(lat)
+
+         @m_Date = date
+         @m_Position = Vector.new()
+
+         @m_Position.m_x = achcp * Math.cos(theta)                    # km
+         @m_Position.m_y = achcp * Math.sin(theta)                    # km
+         @m_Position.m_z = (OrbitGlobals::XKMPER * s + alt) * Math.sin(lat) # km
+         @m_Position.m_w = Math.sqrt(OrbitGlobals::sqr(@m_Position.m_x) +
+            OrbitGlobals::sqr(@m_Position.m_y) +
+            OrbitGlobals::sqr(@m_Position.m_z))            # range, km
+
+         @m_Velocity = Vector.new()
+
+         @m_Velocity.m_x = -mfactor * @m_Position.m_y               # km / sec
+         @m_Velocity.m_y =  mfactor * @m_Position.m_x
+         @m_Velocity.m_z = 0.0
+         @m_Velocity.m_w = Math.sqrt(OrbitGlobals::sqr(@m_Velocity.m_x) +  # range rate km/sec^2
+            OrbitGlobals::sqr(@m_Velocity.m_y))
+      end
+
+      #endregion
+
+      #region Properties
+
+      def position
+        @m_Position
+      end
+
+      def velocity
+        @m_Velocity
+      end
+
+      def date
+        @m_Date
+      end
+
+      #endregion
+
+      # #####################################/
+      # Return the corresponding geodetic position (based on the current ECI
+      # coordinates/Julian date).
+      # Assumes the earth is an oblate spheroid as defined in WGS '72.
+      # Reference: The 1992 Astronomical Almanac, page K12.
+      # Reference: www.celestrak.com (Dr. TS Kelso)
+      def to_geo
+        # puts "to_geo"
+         theta = OrbitGlobals::actan(@m_Position.m_y, @m_Position.m_x)
+         # puts "theta: #{theta}"
+         # puts "m_Date: #{@m_Date}"
+         lon   = (theta - OrbitGlobals.time_to_gmst( @m_Date )) % OrbitGlobals::TWO_PI
+
+         if (lon < 0.0)
+            lon += OrbitGlobals::TWO_PI  # "wrap" negative modulo
+          end
+
+         r   = Math.sqrt(OrbitGlobals.sqr(@m_Position.m_x) + OrbitGlobals.sqr(@m_Position.m_y))
+         e2  = OrbitGlobals::F * (2.0 - OrbitGlobals::F)
+         lat = OrbitGlobals.actan(@m_Position.m_z, r)
+
+         delta = 1.0e-07
+         phi = nil
+         c = nil
+
+         begin
+            phi = lat
+            c   = 1.0 / Math.sqrt(1.0 - e2 * OrbitGlobals::sqr(Math.sin(phi)))
+            lat = OrbitGlobals::actan(@m_Position.m_z + OrbitGlobals::XKMPER * c * e2 * Math.sin(phi), r)
+         end while ((lat - phi).abs > delta)
+
+         alt = r / Math.cos(lat) - OrbitGlobals::XKMPER * c
+
+         return GeocentricCoordinates.new(lat, lon, alt) # radians, radians, kilometers
+       end
+
+
+    #/ <summary>
+    #/ Scale the position vector by the given scaling factor.
+    #/ </summary>
+    #/ <param name="factor">The scaling factor.</param>
+    def scale_pos_vector(factor)
+       @m_Position.mul(factor)
+     end
+
+    #/ <summary>
+    #/ Scales the velocity vector by the given scaling factor.
+    #/ </summary>
+    #/ <param name="factor">The scaling factor.</param>
+    def scale_vel_vector(factor)
+       @m_Velocity.mul(factor)
+     end
+
+
+  end
+end

data/lib/orbit/geocentric_coordinates.rb

@@ -0,0 +1,37 @@
+module Orbit
+  class GeocentricCoordinates
+    attr_accessor :latitude_rad
+    attr_accessor :longitude_rad
+    attr_accessor :altitude
+
+    def initialize( lat = nil, lon = nil, alt = 0 )
+      @latitude_rad  = lat
+      @longitude_rad = lon
+      @altitude      = alt
+    end
+
+    def latitude
+      OrbitGlobals.rad_to_deg( @latitude_rad )
+    end
+
+    def longitude
+      l = OrbitGlobals.rad_to_deg( @longitude_rad )
+
+      if l > 180
+        l = 360 - l
+        l *= -1
+      end
+
+      l
+    end
+
+    def altitude
+      @altitude * 1000.0 #Convert from km to m
+    end
+
+    def to_s
+      "Lat: #{latitude}, Lng: #{longitude}, Alt: #{altitude}"
+    end
+
+  end
+end

data/lib/orbit/julian.rb

@@ -0,0 +1,153 @@
+class Julian
+  # EPOCH_JAN0_12H_1900 = 2415020.0 # Dec 31.5 1899 = Dec 31 1899 12h UTC
+  # EPOCH_JAN1_00H_1900 = 2415020.5 # Jan  1.0 1900 = Jan  1 1900 00h UTC
+  # EPOCH_JAN1_12H_1900 = 2415021.0 # Jan  1.5 1900 = Jan  1 1900 12h UTC
+  # EPOCH_JAN1_12H_2000 = 2451545.0 # Jan  1.5 2000 = Jan  1 2000 12h UTC
+  #
+  # @m_Date # Julian date
+  # @m_Year # Year including century
+  # @m_Day  # Day of year, 1.0 = Jan 1 00h
+  #
+  # #region Construction
+  #
+  # # ##################################/
+  # # Create a Julian date object from a DateTime object. The time
+  # # contained in the DateTime object is assumed to be UTC.
+  # public Julian(DateTime dt)
+  # {
+  #    double day = dt.DayOfYear +
+  #       (dt.Hour +
+  #       ((dt.Minute +
+  #       ((dt.Second + (dt.Millisecond / 1000.0)) / 60.0)) / 60.0)) / 24.0
+  #
+  #    Initialize(dt.Year, day)
+  # }
+  #
+  # # ##################################/
+  # # Create a Julian date object from a year and day of year.
+  # # The year is given with the century (i.e. 2001).
+  # # The integer part of the day value is the day of year, with 1 meaning
+  # # January 1.
+  # # The fractional part of the day value is the fractional portion of
+  # # the day.
+  # # Examples:
+  # #    day = 1.0  Jan 1 00h
+  # #    day = 1.5  Jan 1 12h
+  # #    day = 2.0  Jan 2 00h
+  # public Julian(int year, double day)
+  # {
+  #    Initialize(year, day)
+  # }
+  #
+  # #endregion
+  #
+  # #region Properties
+  #
+  # public double Date { get { return @m_Date } }
+  #
+  # public double FromJan1_00h_1900() { return @m_Date - EPOCH_JAN1_00H_1900 }
+  # public double FromJan1_12h_1900() { return @m_Date - EPOCH_JAN1_12H_1900 }
+  # public double FromJan0_12h_1900() { return @m_Date - EPOCH_JAN0_12H_1900 }
+  # public double FromJan1_12h_2000() { return @m_Date - EPOCH_JAN1_12H_2000 }
+  #
+  # #endregion
+  #
+  # # ##################################/
+  # public TimeSpan Diff(Julian date)
+  # {
+  #    const double TICKS_PER_DAY = 8.64e11 # 1 tick = 100 nanoseconds
+  #    return new TimeSpan((long)((m_Date - date.m_Date) * TICKS_PER_DAY))
+  # }
+  #
+  # # ##################################/
+  # # Initialize the Julian object.
+  # # The first day of the year, Jan 1, is day 1.0. Noon on Jan 1 is
+  # # represented by the day value of 1.5, etc.
+  # protected void Initialize(int year, double day)
+  # {
+  #    # Arbitrary years used for error checking
+  #    if (year < 1900 || year > 2100)
+  #    {
+  #       throw new ArgumentOutOfRangeException("year")
+  #    }
+  #
+  #    # The last day of a leap year is day 366
+  #    if (day < 1.0 || day >= 367.0)
+  #    {
+  #       throw new ArgumentOutOfRangeException("day")
+  #    }
+  #
+  #    @m_Year = year
+  #    @m_Day  = day
+  #
+  #    # Now calculate Julian date
+  #    # Ref: "Astronomical Formulae for Calculators", Jean Meeus, pages 23-25
+  #
+  #    year--
+  #
+  #    # Centuries are not leap years unless they divide by 400
+  #    int A = (year / 100)
+  #    int B = 2 - A + (A / 4)
+  #
+  #    double NewYears = (int)(365.25 * year) +
+  #                      (int)(30.6001 * 14)  +
+  #                      1720994.5 + B
+  #
+  #    @m_Date = NewYears + day
+  # }
+  #
+  # # ##################################/
+  # # ToGmst()
+  # # Calculate Greenwich Mean Sidereal Time for the Julian date. The
+  # # return value is the angle, in radians, measuring eastward from the
+  # # Vernal Equinox to the prime meridian. This angle is also referred
+  # # to as "ThetaG" (Theta GMST).
+  # #
+  # # References:
+  # #    The 1992 Astronomical Almanac, page B6.
+  # #    Explanatory Supplement to the Astronomical Almanac, page 50.
+  # #    Orbital Coordinate Systems, Part III, Dr. T.S. Kelso,
+  # #       Satellite Times, Nov/Dec 1995
+  # public double ToGmst()
+  # {
+  #    double UT = (m_Date + 0.5) % 1.0
+  #    double TU = (FromJan1_12h_2000() - UT) / 36525.0
+  #
+  #    double GMST = 24110.54841 + TU *
+  #                  (8640184.812866 + TU * (0.093104 - TU * 6.2e-06))
+  #
+  #    GMST = (GMST + Globals.SecPerDay * Globals.OmegaE * UT) % Globals.SecPerDay
+  #
+  #    if (GMST < 0.0)
+  #    {
+  #       GMST += Globals.SecPerDay  # "wrap" negative modulo value
+  #    }
+  #
+  #    return  (Globals.TwoPi * (GMST / Globals.SecPerDay))
+  # }
+  #
+  # # ##################################/
+  # # ToLmst()
+  # # Calculate Local Mean Sidereal Time for given longitude (for this date).
+  # # The longitude is assumed to be in radians measured west from Greenwich.
+  # # The return value is the angle, in radians, measuring eastward from the
+  # # Vernal Equinox to the given longitude.
+  # public double ToLmst(double lon)
+  # {
+  #    return (ToGmst() + lon) % Globals.TwoPi
+  # }
+  #
+  # # ##################################/
+  # # ToTime()
+  # # Convert to type DateTime. The resulting value is UTC.
+  # public DateTime ToTime()
+  # {
+  #    # Jan 1
+  #    DateTime dt = new DateTime(m_Year, 1, 1)
+  #
+  #    # @m_Day = 1 = Jan1
+  #    dt = dt.AddDays(m_Day - 1.0)
+  #
+  #    return dt
+  # }
+end