korba 0.7.1 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d032139625c6722891cef771fc76ffb90e8b082f89146ebb860a5f8034004b15
-  data.tar.gz: 354e2f0f7c382059bf7a424ffd952c32b56b6ae616b5c7bd42f50a148d2f42c3
+  metadata.gz: 82d326cac0ea342432bbb082f3abf220a6104073c070bc9c634bab9bb981c388
+  data.tar.gz: 0254dd92e20901966e424acf29a1c1cdc4c44128499e2c85b3fac3cb10fe89f9
 SHA512:
-  metadata.gz: 6f73a3a19efff8c89299173d67dbfa1aaf754ce1c0828148f7bd3933cd57d8de8ba74352cc12849fcd405882c964f345353e1f6d4204b4e451d00a8a6ebf5337
-  data.tar.gz: 293456b12a49007bb1f1c1acc6201fcf99678e5427b1c81942d9f1e53ab5c9cc8716ffdeaaa562846c45ef2b245400f7d73758a05494da91df1528da9e06cba0
+  metadata.gz: a8c434b74a17a64f5ad4367a41391ec85345021f1b1de5ad741b9632a49ae92d123eb8aac9dd22e262a01953012862862a396fe9e5b6429dd5a126412d813bc4
+  data.tar.gz: f6e6c90bc931c98854823baa0089b6dff556b70def4a1a0d72f1544e633cc9745097506b00f422812ddbb4f598d640df53d18dfd6576145a2b19361cdc75270c

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## [0.9.0] - 2026-05-04
+
+- Enable orbit propagation with Keplerian elements
+
+## [0.8.0] - 2026-04-19
+
+- Enable orbit propagation using 4th-order Runge-Kutta
+- Enable conversion from Cartesian to Keplerian elements
+
 ## [0.7.1] - 2026-04-05
 
 - FIX: Fixed calculation when orbital inclination and eccentricity are 0

data/lib/korba/car.rb

@@ -2,6 +2,8 @@
 
 module Korba
   class Car
+    include OrbitUtils
+
     attr_reader :object_name, :epoch, :x, :y, :z, :vx, :vy, :vz
 
     def initialize(object_name:, epoch:, x:, y:, z:, vx:, vy:, vz:)
@@ -14,5 +16,85 @@ module Korba
       @vy = vy
       @vz = vz
     end
+
+    def to_kep
+      inclination = rad_to_deg(Math.atan2(Math.sqrt(specific_angular_momentum_vector[0] ** 2 + specific_angular_momentum_vector[1] ** 2), specific_angular_momentum_vector[2]))
+      ra_of_asc_node = rad_to_deg(Math.atan2(specific_angular_momentum_vector[0], -specific_angular_momentum_vector[1]))
+
+      Kep.new(object_name:,
+              epoch:,
+              semi_major_axis:,
+              eccentricity:,
+              inclination:,
+              ra_of_asc_node:,
+              arg_of_pericenter: normalize_deg(arg_of_latitude - true_anomaly),
+              mean_anomaly: rad_to_deg(deg_to_rad(eccentric_anomaly) - eccentricity * Math.sin(deg_to_rad(eccentric_anomaly))))
+    end
+
+    private
+
+    def position_vector
+      @position_vector ||= Vector[x, y, z]
+    end
+
+    def velocity_vector
+      @velocity_vector ||= Vector[vx, vy, vz]
+    end
+
+    def distance
+      @distance ||= position_vector.norm
+    end
+
+    def velocity
+      @velocity ||= velocity_vector.norm
+    end
+
+    def semi_major_axis
+      @semi_major_axis ||= Constant::GME * distance / (2 * Constant::GME - distance * velocity ** 2)
+    end
+
+    def eccentricity
+      @eccentricity ||= Math.sqrt(((semi_major_axis - distance) / semi_major_axis) ** 2 + (position_vector.dot(velocity_vector) ** 2) / (Constant::GME * semi_major_axis))
+    end
+
+    def eccentric_anomaly
+      @eccentric_anomaly ||= rad_to_deg(Math.atan2(Math.sqrt(semi_major_axis / Constant::GME) * position_vector.dot(velocity_vector), semi_major_axis - distance))
+    end
+
+    def true_anomaly
+      factor = (Math.cos(deg_to_rad(eccentric_anomaly)) - eccentricity) / (1 - eccentricity * Math.cos(deg_to_rad(eccentric_anomaly)))
+      rad_to_deg(Math.atan2(Math.sqrt(1 - factor ** 2), factor))
+    end
+
+    def angular_momentum_vector
+      @angular_momentum_vector ||= position_vector.cross(velocity_vector)
+    end
+
+    def raan_vector
+      @raan_vector ||= Vector[0, 0, 1].cross(angular_momentum_vector)
+    end
+
+    def eccentricity_vector
+      @eccentricity_vector ||= ((velocity ** 2 - Constant::GME / distance) * position_vector - (position_vector * velocity_vector) * velocity_vector) / Constant::GME
+    end
+
+    def specific_angular_momentum_vector
+      @specific_angular_momentum_vector ||= position_vector.cross(velocity_vector)
+    end
+
+    def raan_vector
+      @raan_vector ||= Vector[0, 0, 1].cross(specific_angular_momentum_vector)
+    end
+
+    def arg_of_latitude
+      y = position_vector.dot(raan_vector)
+      x = position_vector.norm * raan_vector.norm
+      arg_of_latitude = (Math.atan2(
+        Math.sqrt(1 - (y / x) ** 2),
+        y / x
+      ))
+      arg_of_latitude = 2 * Math::PI - arg_of_latitude if z < 0
+      rad_to_deg(arg_of_latitude)
+    end
   end
 end

data/lib/korba/constant.rb

@@ -5,6 +5,7 @@ module Korba
     # geocentric gravitational constant in m3/s2
     GME = 3.9860044188e14
     # nominal equatorial Earth radius in m
-    EARTH_RADIUS = 6378137
+    EARTH_RADIUS = 6378137.0
+    J2 = 1.08262668e-3
   end
 end

data/lib/korba/kep.rb

@@ -42,6 +42,14 @@ module Korba
       v_angle_factor = deg_to_rad(arg_of_pericenter + true_anomaly - path_angle)
       vector_v = velocity * (-Math.sin(v_angle_factor) * vector_omega + (Math.cos(v_angle_factor)) * vector_m)
 
+      # NOTE: こっちでもいい
+      # factor_matrix = Matrix[[Math.cos(deg_to_rad(ra_of_asc_node)), -Math.sin(deg_to_rad(ra_of_asc_node)) * Math.cos(deg_to_rad(inclination))],
+      #                        [Math.sin(deg_to_rad(ra_of_asc_node)), Math.cos(deg_to_rad(ra_of_asc_node)) * Math.cos(deg_to_rad(inclination))],
+      #                        [0, Math.sin(deg_to_rad(inclination))]] *
+      #                 Matrix[[Math.cos(deg_to_rad(arg_of_pericenter)), -Math.sin(deg_to_rad(arg_of_pericenter))], [Math.sin(deg_to_rad(arg_of_pericenter)), Math.cos(deg_to_rad(arg_of_pericenter))]]
+      # vector_r = Vector[*(factor_matrix * Matrix[[Math.cos(deg_to_rad(true_anomaly)) - eccentricity], [Math.sqrt(1 - eccentricity ** 2) * Math.sin(deg_to_rad(true_anomaly))]] * semi_major_axis).to_a.flatten]
+      # vector_v = Vector[*(factor_matrix * Matrix[[-Math.sin(deg_to_rad(true_anomaly))], [Math.sqrt(1 - eccentricity ** 2) * Math.cos(deg_to_rad(true_anomaly))]] * Math.sqrt(Constant::GME * semi_major_axis) / vector_r.norm).to_a.flatten]
+
       Car.new(object_name:, epoch:, x: vector_r[0], y: vector_r[1], z: vector_r[2], vx: vector_v[0], vy: vector_v[1], vz: vector_v[2])
     end
   end

data/lib/korba/orbit_utils.rb

@@ -7,6 +7,10 @@ module Korba
       (Constant::GME / (mean_motion * 2.0 * Math::PI / 86400.0) ** 2.0) ** (1.0 / 3.0)
     end
 
+    def period
+      2.0 * Math::PI * Math.sqrt(semi_major_axis ** 3 / Constant::GME)
+    end
+
     def height_at_perigee
       semi_major_axis * (1 - eccentricity) - Constant::EARTH_RADIUS
     end
@@ -50,10 +54,7 @@ module Korba
     end
 
     def normalize_rad(rad)
-      rad = rad + 2.0 * Math::PI if rad < 0
-      normalize_rad = rad > 2.0 * Math::PI ? rad - 2.0 * Math::PI : rad
-      normalize_rad(normalize_rad) if normalize_rad != rad
-      normalize_rad
+      rad % (2.0 * Math::PI)
     end
 
     def rad_to_deg(rad)
@@ -62,10 +63,7 @@ module Korba
     end
 
     def normalize_deg(deg)
-      deg = deg + 360.0 if deg < 0
-      normalized_deg = deg > 360.0 ? deg - 360.0 : deg
-      normalize_deg(normalized_deg) if normalized_deg != deg
-      normalized_deg
+      deg % 360.0
     end
   end
 end

data/lib/korba/propagator/kepler.rb

@@ -0,0 +1,54 @@
+module Korba
+  module Propagator
+    class Kepler
+      include OrbitUtils
+
+      def initialize(initial_kep, disable_j2: false)
+        @initial_kep = initial_kep
+        @disable_j2 = disable_j2
+      end
+
+      def propagate(seconds_after_epoch)
+        mean_motion = Math.sqrt(Constant::GME / @initial_kep.semi_major_axis ** 3)
+        mean_anomaly = rad_to_deg(deg_to_rad(@initial_kep.mean_anomaly) + mean_motion * seconds_after_epoch)
+
+        Kep.new(
+          object_name: @initial_kep.object_name,
+          epoch: @initial_kep.epoch + seconds_after_epoch,
+          semi_major_axis: @initial_kep.semi_major_axis,
+          eccentricity: @initial_kep.eccentricity,
+          inclination: @initial_kep.inclination,
+          ra_of_asc_node: ra_of_asc_node(seconds_after_epoch),
+          arg_of_pericenter: arg_of_pericenter(seconds_after_epoch),
+          mean_anomaly: mean_anomaly,
+        )
+      end
+
+      private
+
+      def ra_of_asc_node(seconds_after_epoch)
+        return @initial_kep.ra_of_asc_node if @disable_j2
+
+        rad_to_deg(deg_to_rad(@initial_kep.ra_of_asc_node) + ra_of_asc_node_dot_radian * seconds_after_epoch)
+      end
+
+      def ra_of_asc_node_dot_radian
+        -(3 * Math::PI * Constant::J2 *
+          (Constant::EARTH_RADIUS / @initial_kep.semi_major_axis * (1 - @initial_kep.eccentricity ** 2)) ** 2 *
+          Math.cos(deg_to_rad(@initial_kep.inclination))) / @initial_kep.period
+      end
+
+      def arg_of_pericenter(seconds_after_epoch)
+        return @initial_kep.arg_of_pericenter if @disable_j2
+
+        rad_to_deg(deg_to_rad(@initial_kep.arg_of_pericenter) + arg_of_pericenter_dot_radian * seconds_after_epoch)
+      end
+
+      def arg_of_pericenter_dot_radian
+        (3 * Math::PI / 2.0 * Constant::J2 *
+         (Constant::EARTH_RADIUS / @initial_kep.semi_major_axis * (1 - @initial_kep.eccentricity ** 2)) ** 2 *
+         (5 * (Math.cos(deg_to_rad(@initial_kep.inclination)) ** 2) - 1)) / @initial_kep.period
+      end
+    end
+  end
+end

data/lib/korba/propagator/rk4.rb

@@ -0,0 +1,63 @@
+module Korba
+  module Propagator
+    class Rk4
+      def initialize(initial_car, disable_j2: false)
+        @initial_car = initial_car
+        @disable_j2 = disable_j2
+      end
+
+      def propagate(seconds_after_epoch, dt = 1.0)
+        steps = (seconds_after_epoch / dt).to_i
+        t = 0.0
+        y = Vector[@initial_car.x, @initial_car.y, @initial_car.z, @initial_car.vx, @initial_car.vy, @initial_car.vz]
+
+        steps.times do
+          y = step(t, y, dt)
+          t += dt
+        end
+
+        Car.new(
+          object_name: @initial_car.object_name,
+          epoch: @initial_car.epoch + seconds_after_epoch,
+          x: y[0],
+          y: y[1],
+          z: y[2],
+          vx: y[3],
+          vy: y[4],
+          vz: y[5],
+        )
+      end
+
+      private
+
+      def step(t, y, dt)
+        k1 = f(t, y)
+        k2 = f(t + dt / 2.0, y + k1 * (dt / 2.0))
+        k3 = f(t + dt / 2.0, y + k2 * (dt / 2.0))
+        k4 = f(t + dt, y + k3 * dt)
+
+        y + (k1 + 2 * k2 + 2 * k3 + k4) * (dt / 6.0)
+      end
+
+      def f(t, y)
+        position_vector = Vector[y[0], y[1], y[2]]
+        velocity_vector = Vector[y[3], y[4], y[5]]
+        r = position_vector.magnitude
+        base_acceleration_vector = -Constant::GME * position_vector / (r ** 3)
+        acceleration_vector = @disable_j2 ? base_acceleration_vector : add_j2_effect(base_acceleration_vector, r, position_vector[2])
+
+        Vector[velocity_vector[0], velocity_vector[1], velocity_vector[2], acceleration_vector[0], acceleration_vector[1], acceleration_vector[2]]
+      end
+
+      def add_j2_effect(base_acceleration_vector, r, z)
+        j2_factor = (3.0 / 2.0) * Constant::J2 * (Constant::EARTH_RADIUS / r) ** 2
+        factor = 5 * (z / r) ** 2
+        [
+          base_acceleration_vector[0] * (1 + j2_factor * (1 - factor)),
+          base_acceleration_vector[1] * (1 + j2_factor * (1 - factor)),
+          base_acceleration_vector[2] * (1 + j2_factor * (3 - factor)),
+        ]
+      end
+    end
+  end
+end