korba 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a8a9dc1d59d577592a4ef91601bb34a4921e2bb1eb731c0fe866698759717d09
-  data.tar.gz: bb572412946fd8f08a00ab844c4a4975d08953871984a142225ffe09b786417d
+  metadata.gz: 5dc3a4abbdd189f4388673e3960a615940a4feb68c359cce37a29ff47fa7efcb
+  data.tar.gz: c312b2be706e321242d0f4c762134ad82ea681348e5631ec36a13ed91c36db11
 SHA512:
-  metadata.gz: a6f13b11b06a7dc3159b5219204a3c83791a5708f7fc8d64c0d72734bd751c655b8438ef7d29fbb2599f94dfa6657e9c282235dbf86239fab49ad12a2eafff9d
-  data.tar.gz: bcc2a2d8b20d9accbe8b6079334ce6c4610a22e78363d7c9e6243f39a1608c46a90adc0b7d0e52c53adb9fb7c81b7a4dc60f1a291e523e3166bc54b68f9a6897
+  metadata.gz: f0cc15b9fa16cec125d3902e3b52e1336acf4246c72860049955c32456d1eaa0e56a2fd99953477d36141da23b3b8696ed0b8a611c80bc51e1249368c7f07f84
+  data.tar.gz: ffcbf5ed21c86f069d83276227c9db29e5b59d257d1630f5a1fb15eaff0550b881b1e7753fcc551ce6c647c49faf2bc84ee52efb015fbd9ad8efa9355b2da6ad

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## [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
+
 ## [0.7.0] - 2026-04-01
 
 - FIX: Use SGP4 for TLE to Cartesian conversion

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

@@ -19,19 +19,37 @@ module Korba
     end
 
     def to_car
-      vector_n = Vector[
-        Math.sin(deg_to_rad(inclination)) * Math.sin(deg_to_rad(ra_of_asc_node)),
-        -Math.sin(deg_to_rad(inclination)) * Math.cos(deg_to_rad(ra_of_asc_node)),
-        Math.cos(deg_to_rad(inclination))
-      ]
-      vector_omega = Vector[Math.cos(deg_to_rad(ra_of_asc_node)), Math.sin(deg_to_rad(ra_of_asc_node)), 0]
-      vector_m = vector_n.cross(vector_omega)
+      # 特異点対応: inclinationが0（または極めて小さい）場合の処理
+      is_equatorial = inclination.abs < 1e-10
+
+      if is_equatorial
+        # 赤道面内の場合、x軸を基準にする
+        vector_omega = Vector[1.0, 0.0, 0.0]
+        vector_m = Vector[0.0, 1.0, 0.0]
+        vector_n = Vector[0.0, 0.0, 1.0]
+      else
+        vector_n = Vector[
+          Math.sin(deg_to_rad(inclination)) * Math.sin(deg_to_rad(ra_of_asc_node)),
+          -Math.sin(deg_to_rad(inclination)) * Math.cos(deg_to_rad(ra_of_asc_node)),
+          Math.cos(deg_to_rad(inclination))
+        ]
+        vector_omega = Vector[Math.cos(deg_to_rad(ra_of_asc_node)), Math.sin(deg_to_rad(ra_of_asc_node)), 0.0]
+        vector_m = vector_n.cross(vector_omega)
+      end
 
       r_angle_factor = deg_to_rad(arg_of_pericenter + true_anomaly)
       vector_r = distance * (Math.cos(r_angle_factor) * vector_omega + Math.sin(r_angle_factor) * vector_m)
       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

@@ -4,7 +4,7 @@ module Korba
   module OrbitUtils
     def semi_major_axis
       # a = (μ / n^2)^(1/3) m
-      (Constant::GME / (mean_motion * 2 * Math::PI / 86400.0) ** 2.0) ** (1.0 / 3.0)
+      (Constant::GME / (mean_motion * 2.0 * Math::PI / 86400.0) ** 2.0) ** (1.0 / 3.0)
     end
 
     def height_at_perigee
@@ -21,8 +21,12 @@ module Korba
     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.acos(factor))
+      e_rad = deg_to_rad(eccentric_anomaly)
+      y = Math.sqrt(1 - eccentricity ** 2) * Math.sin(e_rad)
+      x = Math.cos(e_rad) - eccentricity
+
+      # atan2(y, x) で正確な位相（-pi から pi）を求める
+      rad_to_deg(Math.atan2(y, x))
     end
 
     def distance
@@ -30,10 +34,12 @@ module Korba
     end
 
     def velocity
-      Math.sqrt(Constant::GME * (2 / distance - 1 / semi_major_axis))
+      Math.sqrt(Constant::GME * (2.0 / distance - 1.0 / semi_major_axis))
     end
 
     def path_angle
+      return 0.0 if eccentricity < 1e-15
+
       factor = Math.sqrt(Constant::GME * semi_major_axis * (1 - eccentricity ** 2)) / (distance * velocity)
       rad_to_deg(Math.acos(factor))
     end
@@ -44,8 +50,8 @@ module Korba
     end
 
     def normalize_rad(rad)
-      rad = rad + 2 * Math::PI if rad < 0
-      normalize_rad = rad > 2 * Math::PI ? rad - 2 * Math::PI : 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
     end
@@ -56,8 +62,8 @@ module Korba
     end
 
     def normalize_deg(deg)
-      deg = deg + 360 if deg < 0
-      normalized_deg = deg > 360 ? deg - 360 : 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
     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