orbit 0.8.0

data/lib/orbit/orbit_globals.rb

@@ -0,0 +1,128 @@
+module Orbit
+
+  class OrbitGlobals
+
+    PI            = 3.141592653589793
+    TWO_PI        = 2.0 * OrbitGlobals::PI
+    RADS_PER_DEGREE = OrbitGlobals::PI / 180.0
+    DEGREES_PER_RAD = 180.0 / OrbitGlobals::PI
+
+    GM            = 398601.2   # Earth gravitational constant, km^3/sec^2
+    GEO_SYNC_ALT    = 42241.892  # km
+    EARTHDIAM     = 12800.0    # km
+    DAYSIDEREAL   = (23 * 3600) + (56 * 60) + 4.09  # sec
+    DAYSOLAR      = (24 * 3600.0)   # sec
+
+    AE            = 1.0
+    AU            = 149597870.0  # Astronomical unit (km) (IAU 76)
+    SR            = 696000.0     # Solar radius (km)      (IAU 76)
+    XKMPER        = 6378.135     # Earth equatorial radius - kilometers (WGS '72)
+    F             = 1.0 / 298.26 # Earth flattening (WGS '72)
+    GE            = 398600.8     # Earth gravitational constant (WGS '72)
+    J2            = 1.0826158E-3 # J2 harmonic (WGS '72)
+    J3            = -2.53881E-6  # J3 harmonic (WGS '72)
+    J4            = -1.65597E-6  # J4 harmonic (WGS '72)
+    CK2           = OrbitGlobals::J2 / 2.0
+    CK4           = -3.0 * OrbitGlobals::J4 / 8.0
+    XJ3           = OrbitGlobals::J3
+    QO            = OrbitGlobals::AE + 120.0 / OrbitGlobals::XKMPER
+    S             = OrbitGlobals::AE + 78.0  / OrbitGlobals::XKMPER
+    MIN_PER_DAY     = 1440.0        # Minutes per day (solar)
+    SEC_PER_DAY     = 86400.0       # Seconds per day (solar)
+    OMEGAE        = 1.00273790934 # Earth rotation per sidereal day
+     XKE          = Math.sqrt(3600.0 * OrbitGlobals::GE /
+                       (OrbitGlobals::XKMPER * OrbitGlobals::XKMPER * OrbitGlobals::XKMPER)) # sqrt(ge) ER^3/min^2
+     QOMS2T       = ((OrbitGlobals::QO - OrbitGlobals::S) ** 4.0) #(QO - S)^4 ER^4
+
+
+     def self.sqr( n )
+       n ** 2
+     end
+
+     def self.deg_to_rad( deg )
+       deg * RADS_PER_DEGREE;
+     end
+
+     def self.rad_to_deg( rad )
+       rad * DEGREES_PER_RAD;
+     end
+
+
+     def self.fmod2p(arg)
+        modu = (arg % TWO_PI);
+
+        if (modu < 0.0)
+           modu += TWO_PI
+         end
+
+        return modu
+      end
+
+     # // ///////////////////////////////////////////////////////////////////////////
+     #    // Globals.AcTan()
+     #    // ArcTangent of sin(x) / cos(x). The advantage of this function over arctan()
+     #    // is that it returns the correct quadrant of the angle.
+     def self.actan( sinx,  cosx)
+        ret = nil
+
+        if (cosx == 0.0)
+           if (sinx > 0.0)
+              ret = PI / 2.0
+           else
+              ret = 3.0 * PI / 2.0
+          end
+        else
+           if (cosx > 0.0)
+              ret = Math.atan(sinx / cosx)
+           else
+              ret = PI + Math.atan(sinx / cosx)
+            end
+          end
+
+        return ret
+      end
+
+      def self.time_to_gmst(t)
+        jd = t.to_date.jd - 0.5
+        seconds = (t.hour * 3600) + (t.min * 60) + (t.sec).to_f + (t.subsec).to_f
+        fraction_of_day = seconds / 86400.0
+
+        jd += fraction_of_day
+
+        #puts "jd: #{jd}"
+
+        ut = (jd + 0.5 ) % 1.0;
+        jd = jd - ut
+        tu = (jd - 2451545.0) / 36525.0
+        gmst = 24110.54841 + tu * (8640184.812866 + tu * (0.093104 - tu * 6.2E-6));
+        gmst =  ( gmst + 86400.0 * 1.00273790934 * ut ) % 86400.0
+        if (gmst < 0.0)
+          gmst += 86400.0 # "wrap" negative modulo value
+        end
+
+        gmst = (OrbitGlobals::TWO_PI * (gmst / 86400.0))
+
+        # puts "gmst: #{gmst}"
+
+        gmst
+      end
+
+      # /////////////////////////////////////////////////////////////////////
+      # 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.
+      def self.time_to_lmst (t, lon)
+        gmst = OrbitGlobals.time_to_gmst( t )
+        lmst = ( gmst + lon ) % TWO_PI
+
+        # puts "long: #{lon}"
+        # puts "gmst: #{gmst}"
+        # puts "lmst: #{lmst}"
+
+        lmst
+      end
+
+  end
+end

data/lib/orbit/satellite.rb

@@ -0,0 +1,40 @@
+module Orbit
+  class Satellite
+
+    attr_accessor :tle
+    attr_accessor :orbit
+
+    def initialize( tle_string )
+      @tle = Tle.new(tle_string)
+      @orbit = Orbit.new(@tle)
+    end
+
+    def eci_position_at_time( time )
+      since_epoch = ( time.utc.to_f - @tle.epoch.to_f )
+
+      eci_position_at_seconds_since_epoch( since_epoch )
+    end
+
+    def eci_position_at_seconds_since_epoch( time_since_epoch )
+      t = time_since_epoch / 60.0
+
+      p = @orbit.get_position( t ) #For whatever reason this is decimal minutes
+    end
+
+    def position_at_time( time )
+      seconds_since_epoch = ( time.utc.to_f - @tle.epoch.to_f )
+      position_at_seconds_since_epoch( seconds_since_epoch )
+    end
+
+    def position_at_seconds_since_epoch( time_since_epoch )
+      eci_position_at_seconds_since_epoch( time_since_epoch ).to_geo
+    end
+
+    def current_position
+      since_epoch = ( Time.new.utc.to_f - @tle.epoch.to_f )
+
+      position_at_seconds_since_epoch( since_epoch )
+    end
+
+  end
+end

data/lib/orbit/site.rb

@@ -0,0 +1,115 @@
+module Orbit
+
+  class Site
+
+    attr_accessor :geo
+
+    def initialize( lat, lon, alt )
+      alt = alt / 1000 #km
+      @geo = GeocentricCoordinates.new( OrbitGlobals.deg_to_rad( lat ), OrbitGlobals.deg_to_rad( lon ), alt )
+    end
+
+    def latitude_rad
+      @geo.latitude_rad
+    end
+
+    def longitude_rad
+      @geo.longitude_rad
+    end
+
+    def latitude_deg
+      OrbitGlobals::rad_to_deg( latitude_rad )
+    end
+
+    def longitude_deg
+      OrbitGlobals::rad_to_deg( longitude_rad )
+    end
+
+    def altitude
+      @geo.altitude
+    end
+
+    def get_position(date)
+      return Eci.new(@geo, date)
+    end
+
+    def view_angle_to_satellite_at_time( sat, time )
+      sat_position = sat.eci_position_at_time( time )
+      topoLook = get_look_angle( sat_position )
+    end
+
+    def get_look_angle(eci)
+           # Calculate the ECI coordinates for this Site object at the time
+           # of interest.
+           date      = eci.date
+           eciSite   = Eci.new(@geo, date)
+           vecRgRate = Vector.new(eci.velocity.m_x - eciSite.velocity.m_x,
+                                         eci.velocity.m_y - eciSite.velocity.m_y,
+                                         eci.velocity.m_z - eciSite.velocity.m_z)
+
+           x = eci.position.m_x - eciSite.position.m_x
+           y = eci.position.m_y - eciSite.position.m_y
+           z = eci.position.m_z - eciSite.position.m_z
+           w = Math.sqrt(OrbitGlobals::sqr(x) + OrbitGlobals::sqr(y) + OrbitGlobals::sqr(z))
+
+           vecRange = Vector.new(x, y, z, w)
+
+           # The site's Local Mean Sidereal Time at the time of interest.
+           theta = OrbitGlobals.time_to_lmst( date, longitude_rad)
+
+           sin_lat   = Math.sin(latitude_rad)
+           cos_lat   = Math.cos(latitude_rad)
+           sin_theta = Math.sin(theta)
+           cos_theta = Math.cos(theta)
+
+           top_s = sin_lat * cos_theta * vecRange.m_x +
+                          sin_lat * sin_theta * vecRange.m_y -
+                          cos_lat * vecRange.m_z
+           top_e = -sin_theta * vecRange.m_x +
+                           cos_theta * vecRange.m_y
+           top_z = cos_lat * cos_theta * vecRange.m_x +
+                          cos_lat * sin_theta * vecRange.m_y +
+                          sin_lat * vecRange.m_z
+           az    = Math.atan(-top_e / top_s)
+
+           if (top_s > 0.0)
+              az += OrbitGlobals::PI
+            end
+
+           if (az < 0.0)
+              az += 2.0 * OrbitGlobals::PI
+            end
+
+           el   = Math.asin(top_z / vecRange.m_w)
+           rate = (vecRange.m_x * vecRgRate.m_x +
+                          vecRange.m_y * vecRgRate.m_y +
+                          vecRange.m_z * vecRgRate.m_z) / vecRange.m_w
+
+           topo = TopocentricHorizonCoordinates.new(az,         # azimuth, radians
+                                          el,         # elevation, radians
+                                          vecRange.m_w, # range, km
+                                          rate)      # rate, km / sec
+  #if WANT_ATMOSPHERIC_CORRECTION
+        # Elevation correction for atmospheric refraction.
+        # Reference:  Astronomical Algorithms by Jean Meeus, pp. 101-104
+        # Note:  Correction is meaningless when apparent elevation is below horizon
+        topo.elevation += OrbitGlobals::deg_to_rad((1.02 /
+                                      Math.tan(OrbitGlobals::deg_to_rad(OrbitGlobals::rad_to_deg(el) + 10.3 /
+                                      (OrbitGlobals::rad_to_deg(el) + 5.11)))) / 60.0)
+        if (topo.elevation < 0.0)
+           topo.elevation = el    # Reset to true elevation
+         end
+
+        if (topo.elevation > (OrbitGlobals::PI / 2))
+           topo.elevation = (OrbitGlobals::PI / 2)
+         end
+  #endif
+           return topo
+
+    end
+
+
+
+
+  end
+end

data/lib/orbit/tle.rb

@@ -0,0 +1,127 @@
+module Orbit
+
+  class Tle
+
+    attr_accessor :tle_string
+    attr_accessor :norad_num
+    attr_accessor :intl_desc
+    attr_accessor :set_number      # TLE set number
+    attr_accessor :epoch_year      # Epoch: Last two digits of year
+    attr_accessor :epoch_day       # Epoch: Fractional Julian Day of year
+    attr_accessor :orbit_at_epoch  # Orbit at epoch
+    attr_accessor :inclination     # Inclination
+    attr_accessor :raan            # R.A. ascending node
+    attr_accessor :eccentricity    # Eccentricity
+    attr_accessor :arg_perigee     # Argument of perigee
+    attr_accessor :mean_anomaly    # Mean anomaly
+    attr_accessor :mean_motion     # Mean motion
+    attr_accessor :mean_motion_dt  # First time derivative of mean motion
+    attr_accessor :mean_motion_dt2 # Second time derivative of mean motion
+    attr_accessor :bstar_drag      # BSTAR Drag
+
+
+  # ISS (ZARYA)
+  # 1 25544U 98067A   08264.51782528 −.00002182  00000-0 -11606-4 0  2927
+  # 2 25544  51.6416 247.4627 0006703 130.5360 325.0288 15.72125391563537
+
+    FIELD_COLUMNS = {
+      norad_num:       [1, 3,7],
+      classification:  [1, 8,8],
+      launch_year:     [1, 10,11],
+      launch_num:      [1, 12,14],
+      launch_piece:    [1, 15,17],
+      epoch_year:      [1, 19,20],
+      epoch_day:       [1, 21,32],
+      mean_motion_dt:  [1, 34,43],
+      mean_motion_dt2: [1, 45,52],
+      bstar_drag:      [1, 54,61],
+      number_zero:     [1, 63,63],
+      element_num:     [1, 65,68],
+      checksum_1:      [1, 69,69],
+      inclination:     [2, 9,16],
+      raan:            [2, 18,25],
+      eccentricity:    [2, 27,33],
+      arg_perigee:     [2, 35,42],
+      mean_anomaly:    [2, 44,51],
+      mean_motion:     [2, 53,63],
+      revolution_num:  [2, 64,68],
+      checksum_2:      [2, 69,69]
+    }
+
+
+    def initialize( s )
+      @tle_string      = s
+
+      # puts @tle_string
+
+      @norad_num       = get_field( :norad_num )
+      @classification  = get_field( :classification )
+      @launch_year     = get_field( :launch_year )
+      @launch_num      = get_field( :launch_num )
+      @launch_piece    = get_field( :launch_piece )
+      @mean_motion_dt  = get_field( :mean_motion_dt ).to_f
+      @mean_motion_dt2 = exp_to_float( "0." + get_field( :mean_motion_dt2 ) ).to_f
+      @bstar_drag      = exp_to_float( "0." + get_field( :bstar_drag ) ).to_f
+      @element_num     = get_field( :element_num ).to_f
+      @inclination     = get_field( :inclination ).to_f
+      @raan            = get_field( :raan ).to_f
+      @eccentricity    = exp_to_float( "0." + get_field( :eccentricity ) ).to_f
+      @arg_perigee     = get_field( :arg_perigee ).to_f
+      @mean_anomaly    = get_field( :mean_anomaly ).to_f
+      @mean_motion     = get_field( :mean_motion ).to_f
+      @revolution_num  = get_field( :revolution_num ).to_f
+    end
+
+    def exp_to_float( exp )
+      # puts "exp: #{exp}"
+      parts = exp.split( "-" )
+      exp_part = -0.1
+
+      if parts.count < 2
+        parts = exp.split( " " )
+        exp_part = 0.1
+      end
+
+      float = parts[0].to_f * ( exp_part ** parts[1].to_f )
+    end
+
+    def get_field( field )
+      lines = @tle_string.split( "\n" )
+
+      line_num        = FIELD_COLUMNS[field][0]
+      substring_start = FIELD_COLUMNS[field][1] - 1 # Convert to zero-base
+      substring_end   = FIELD_COLUMNS[field][2] - 1 # Convert to zero-base
+
+      lines[line_num][substring_start..substring_end].strip
+    end
+
+    def to_s
+      hash = {}
+      instance_variables.each {|var| hash[var.to_s.delete("@")] = instance_variable_get(var) }
+
+      hash.to_s
+    end
+
+    def epoch
+      epoch_year     = get_field( :epoch_year ).to_f
+      epoch_day      = get_field( :epoch_day ).to_f
+
+      epoch_year = epoch_year < 57 ? ( epoch_year + 2000 ) : ( epoch_year + 1900 )
+
+      epoch = Time.at( Time.utc( epoch_year ).to_i + ( ( epoch_day - 1 ) * OrbitGlobals::SEC_PER_DAY ) )
+
+      epoch = epoch.utc
+
+      # puts "epoch_year: #{epoch_year}"
+      # puts "epoch_day: #{epoch_day}"
+      # puts "epoch: #{epoch}"
+
+      epoch
+    end
+
+    # def epoch_julian
+    #   epoch.
+    # end
+
+  end
+end

data/lib/orbit/topocentric_horizon_coordinates.rb

@@ -0,0 +1,33 @@
+module Orbit
+
+  class TopocentricHorizonCoordinates
+    #/ <summary>
+    #/ The azimuth, in radians.
+    #/ </summary>
+    attr_accessor :azimuth
+
+    #/ <summary>
+    #/ The elevation, in radians.
+    #/ </summary>
+    attr_accessor :elevation
+
+    #/ <summary>
+    #/ The range, in kilometers.
+    #/ </summary>
+    attr_accessor :range
+
+    #/ <summary>
+    #/ The range rate, in kilometers per second.
+    #/ A negative value means "towards observer".
+    #/ </summary>
+    attr_accessor :range_rate
+
+    def initialize( az, el, r, rr )
+      @azimuth    = az
+      @elevation  = el
+      @range      = r
+      @range_rate = rr
+    end
+
+  end
+end

data/lib/orbit/vector.rb

@@ -0,0 +1,56 @@
+module Orbit
+
+  class Vector
+    attr_accessor :m_x
+    attr_accessor :m_y
+    attr_accessor :m_z
+    attr_accessor :m_w
+
+    def initialize( x = nil, y = nil, z = nil, w = nil )
+      @m_x = x
+      @m_y = y
+      @m_z = z
+      @m_w = w
+    end
+
+    # ##################################/
+    # Multiply each component in the vector by 'factor'.
+    def mul(factor)
+      #puts "m_x: #{@m_x}, factor: #{factor}"
+
+       @m_x = @m_x * factor
+       @m_y *= factor
+       @m_z *= factor
+       @m_w *= (factor).abs if @m_w
+     end
+
+    # ##################################/
+    # Subtract a vector from this one.
+    def sub(vec)
+       @m_x -= vec.m_x
+       @m_y -= vec.m_y
+       @m_z -= vec.m_z
+       @m_w -= vec.m_w
+     end
+
+    # ##################################/
+    # Calculate the angle between this vector and another
+    def angle(vec)
+       return Math.acos(dot(vec) / (magnitude() * vec.magnitude()))
+     end
+
+    # ##################################/
+    def magnitude
+       return Math.sqrt((@m_x * @m_x) + (@m_y * @m_y) + (@m_z * @m_z))
+     end
+
+
+    # ##################################/
+    # Return the dot product
+    def dot(vec)
+       return (@m_x * vec.m_x) + (@m_y * vec.m_y) + (@m_z * vec.m_z)
+     end
+
+
+  end
+end