kerbaldyn 0.7.0

data/spec/options_processor_spec.rb

@@ -0,0 +1,33 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe KerbalDyn::Mixin::OptionsProcessor do
+
+  class OptionsProcessorTestClass
+    include KerbalDyn::Mixin::OptionsProcessor
+    DEFAULTS = {:foo => :default}
+
+    def initialize(opts={})
+      process_options(opts, DEFAULTS)
+    end
+
+    attr_accessor :foo
+    attr_accessor :alpha
+  end
+
+  it 'should set valid keys' do
+    obj = OptionsProcessorTestClass.new(:foo => :bar, :alpha => :beta)
+    obj.foo.should == :bar
+    obj.alpha.should == :beta
+  end
+
+  it 'should error on invalid keys' do
+    lambda {OptionsProcessorTestClass.new(:miss => :sunshine)}.should raise_error(NoMethodError)
+  end
+
+  it 'should use a block as a defaults hook' do
+    obj = OptionsProcessorTestClass.new
+    obj.foo.should == :default
+    obj.alpha.should == nil
+  end
+
+end

data/spec/orbit_spec.rb

@@ -0,0 +1,357 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe KerbalDyn::Orbit do
+
+  describe 'Circularize' do
+
+    before(:all) do
+      @planet = KerbalDyn::Planetoid.new('Test Planet', :gravitational_parameter => 3.5316e12, :radius => 600000)
+      @satellite = KerbalDyn::Planetoid.test_particle
+      @elliptical = KerbalDyn::Orbit.new(@planet, :secondary_body => @satellite, :periapsis => 700000.0, :apoapsis => 3e6, :inclination => 0.2)
+      @circular = @elliptical.circularize
+    end
+
+    it 'should have the same primary body' do
+      @circular.primary_body.should == @elliptical.primary_body
+    end
+
+    it 'should have the same secondary body' do
+      @circular.secondary_body.should == @elliptical.secondary_body
+    end
+
+    it 'should be circular' do
+      @circular.kind.should == :circular
+    end
+
+    it 'should have the same semimajor_axis' do
+      @circular.semimajor_axis.should == @elliptical.semimajor_axis
+    end
+
+    it 'should have zero inclination' do
+      @circular.inclination.should be_within(1e-9).of(0.0)
+    end
+
+    it 'should have the same period' do
+      @circular.period.should be_within_six_sigma_of(@elliptical.period)
+    end
+
+    it 'should have a periapsis and apoapsis velocity that is the same as original mean velocity.' do
+      @circular.mean_velocity.should be_within_six_sigma_of(@elliptical.mean_velocity)
+      @circular.periapsis_velocity.should be_within_six_sigma_of(@elliptical.mean_velocity)
+      @circular.apoapsis_velocity.should be_within_six_sigma_of(@elliptical.mean_velocity)
+    end
+
+  end
+
+  describe 'Orbit Types' do
+
+    describe 'Circular Orbit' do
+      before(:all, &BeforeFactory.earth)
+      before(:all, &BeforeFactory.earth_geostationary_orbit)
+
+      it 'should be closed' do
+        @orbit.closed?.should be_true
+        @orbit.open?.should be_false
+      end
+
+      it 'should be circular' do
+        @orbit.kind.should == :circular
+      end
+
+      it 'should have zero eccentricity' do
+        @orbit.eccentricity.should be_within(0.000001).of(0.0)
+      end
+
+      it 'should have the parent body gravitational parameter' do
+        @orbit.gravitational_parameter.should be_within_four_sigma_of(@gravitational_parameter)
+      end
+
+      it 'should have the right specific kinetic energy' do
+        @orbit.specific_kinetic_energy(@orbital_velocity).should be_within_four_sigma_of(@orbital_specific_kinetic_energy)
+      end
+
+      it 'should have the right specific potential energy' do
+        @orbit.specific_potential_energy(@orbital_radius).should be_within_four_sigma_of(@orbital_specific_potential_energy)
+      end
+
+      it 'should have total specific energy that is the sum of kinetic and poential specific energy' do
+        @orbit.specific_energy.should be_within_four_sigma_of( @orbital_specific_kinetic_energy + @orbital_specific_potential_energy )
+      end
+
+      it 'should have the right rotational momentum' do
+        @orbit.specific_angular_momentum.should be_within_four_sigma_of( @orbital_specific_angular_momentum )
+      end
+
+      it 'should have a semimajor_axis equal to the radius' do
+        @orbit.semimajor_axis.should be_within_six_sigma_of(@orbital_radius)
+      end
+
+      it 'should have a semiminor_axis equal to the radius' do
+        @orbit.semiminor_axis.should be_within_six_sigma_of(@orbital_radius)
+      end
+
+      it 'should have a periapsis equal to the radius' do
+        @orbit.periapsis.should be_within_six_sigma_of(@orbital_radius)
+      end
+
+      it 'should have an apoapsis equal to the radius' do
+        @orbit.apoapsis.should be_within_six_sigma_of(@orbital_radius)
+      end
+
+      it 'should have the expected period' do
+        @orbit.period.should be_within_four_sigma_of(@orbital_period)
+      end
+
+      it 'should have the expected mean_angular_velocity' do
+        @orbit.mean_angular_velocity.should be_within_four_sigma_of(2.0*Math::PI / @orbital_period)
+      end
+
+      it 'should have the correct periapsis_velocity' do
+        @orbit.periapsis_velocity.should be_within_four_sigma_of(@orbital_velocity)
+      end
+
+      it 'should have the correct apoapsis_velocity' do
+        @orbit.apoapsis_velocity.should be_within_four_sigma_of(@orbital_velocity)
+      end
+
+    end
+
+    describe 'Elliptical Orbit' do
+      before(:all, &BeforeFactory.earth)
+      before(:all, &BeforeFactory.geostationary_transfer_orbit)
+
+      it 'should be of kind elliptical' do
+        @orbit.kind.should == :elliptical
+      end
+
+      [
+        :periapsis,
+        :apoapsis,
+        :periapsis_velocity,
+        :apoapsis_velocity,
+        :eccentricity,
+        :semimajor_axis
+      ].each do |parameter|
+        it "should calculate the correct #{parameter} value" do
+          expected_value = instance_variable_get("@#{parameter}")
+          @orbit.send(parameter).should be_within_three_sigma_of(expected_value)
+        end
+      end
+
+    end
+
+    describe 'Parabolic Orbit' do
+      before(:all, &BeforeFactory.earth)
+      before(:all, &BeforeFactory.earth_escape_orbit)
+
+      it 'should have the correct escape velocity' do
+        @orbit.periapsis_velocity.should be_within_six_sigma_of(@escape_velocity)
+      end
+
+      it 'should be of kind :parabolic' do
+        @orbit.kind.should == :parabolic
+      end
+
+      it 'should have an eccentricity of 1' do
+        @orbit.eccentricity.should be_within_six_sigma_of(1.0)
+      end
+
+      it 'should have a total specific energy of zero' do
+        @orbit.specific_energy.should be_within(1e-6).of(0.0)
+      end
+
+    end
+
+    describe 'Hyperbolic Orbit' do
+      before(:all, &BeforeFactory.earth)
+      before(:all, &BeforeFactory.earth_hyperbolic_orbit)
+
+      it 'should be of kind :hyperbolic' do
+        @orbit.kind.should == :hyperbolic
+      end
+
+      it 'should have an eccentricity greater than 1' do
+        @orbit.eccentricity.should > 1.0
+        @orbit.eccentricity.should be_within_four_sigma_of(@eccentricity)
+      end
+
+    end
+
+  end
+
+  describe 'Eccentricity Independent Quantities' do
+
+    before(:all) do
+      @primary_planetoid = KerbalDyn::Planetoid.new('Kerbin', :mass => 5.29e22, :radius => 600e3)
+      @secondary_planetoid = KerbalDyn::Planetoid.new('Mun', :mass => 9.76e20, :radius => 200e3)
+      @semimajor_axis = 12000e3
+      @secondary_soi = 2430e3
+      @primary_soi = 59.26e6
+      @orbit = KerbalDyn::Orbit.new(@primary_planetoid, :secondary_body => @secondary_planetoid, :semimajor_axis => @semimajor_axis, :eccentricity => 0.0)
+    end
+
+    it 'should calculate SOI of primary body' do
+      @orbit.primary_body_sphere_of_influence.should be_within_four_sigma_of(@primary_soi)
+    end
+
+    it 'should cacluate SOI of secondary body' do
+      @orbit.secondary_body_sphere_of_influence.should be_within_four_sigma_of(@secondary_soi)
+    end
+
+    it 'should default to the secondary body SOI' do
+      @orbit.sphere_of_influence.should be_within_four_sigma_of(@secondary_soi)
+    end
+
+  end
+
+  describe 'Orbit Initializers and Factory Methods' do
+    before(:all, &BeforeFactory.earth)
+
+    describe 'constructing orbits from periapsis and periapsis velocity' do
+      before(:all, &BeforeFactory.geostationary_transfer_orbit)
+
+      it 'should create from the initializer' do
+        orbit = KerbalDyn::Orbit.new(@planetoid, :periapsis => @periapsis, :periapsis_velocity => @periapsis_velocity)
+        [:periapsis, :apoapsis, :periapsis_velocity, :apoapsis_velocity, :eccentricity, :semimajor_axis].each do |parameter|
+          orbit.send(parameter).should be_within_three_sigma_of( instance_variable_get("@#{parameter}") )
+        end
+      end
+
+    end
+
+    describe 'constructing orbits from periapsis and apoapsis' do
+      before(:all, &BeforeFactory.geostationary_transfer_orbit)
+
+      it 'should create from the initializer' do
+        orbit = KerbalDyn::Orbit.new(@planetoid, :periapsis => @periapsis, :apoapsis => @apoapsis)
+        [:periapsis, :apoapsis, :periapsis_velocity, :apoapsis_velocity, :eccentricity, :semimajor_axis].each do |parameter|
+          orbit.send(parameter).should be_within_three_sigma_of( instance_variable_get("@#{parameter}") )
+        end
+      end
+
+    end
+
+    describe 'constructing orbits from semimajor_axis and eccentricity' do
+      before(:all, &BeforeFactory.geostationary_transfer_orbit)
+
+      it 'should create from the initializer' do
+        orbit = KerbalDyn::Orbit.new(@planetoid, :semimajor_axis => @semimajor_axis, :eccentricity => @eccentricity)
+        [:periapsis, :apoapsis, :periapsis_velocity, :apoapsis_velocity, :eccentricity, :semimajor_axis].each do |parameter|
+          orbit.send(parameter).should be_within_three_sigma_of( instance_variable_get("@#{parameter}") )
+        end
+      end
+
+    end
+
+    describe 'constructing cicular orbits from a radius' do
+      before(:all, &BeforeFactory.earth_geostationary_orbit)
+
+      it 'should be creatable from the initializer' do
+        orbit = KerbalDyn::Orbit.new(@planetoid, :radius => @geostationary_orbit_radius)
+        orbit.eccentricity.should be_within(1e-9).of(0.0)
+        orbit.periapsis.should be_within_four_sigma_of(@geostationary_orbit_radius)
+        orbit.periapsis_velocity.should be_within_four_sigma_of(@geostationary_orbit_velocity)
+        orbit.apoapsis.should be_within_four_sigma_of(@geostationary_orbit_radius)
+        orbit.apoapsis_velocity.should be_within_four_sigma_of(@geostationary_orbit_velocity)
+      end
+
+      it 'should be creatable from the factory method' do
+        orbit = KerbalDyn::Orbit.circular_orbit(@planetoid, @geostationary_orbit_radius)
+        orbit.eccentricity.should be_within(1e-9).of(0.0)
+        orbit.periapsis.should be_within_four_sigma_of(@geostationary_orbit_radius)
+        orbit.periapsis_velocity.should be_within_four_sigma_of(@geostationary_orbit_velocity)
+        orbit.apoapsis.should be_within_four_sigma_of(@geostationary_orbit_radius)
+        orbit.apoapsis_velocity.should be_within_four_sigma_of(@geostationary_orbit_velocity)
+      end
+
+      it 'should construct using the orbital period' do
+        orbit = KerbalDyn::Orbit.circular_orbit_of_period(@planetoid, @orbital_period)
+        orbit.eccentricity.should be_within(1e-9).of(0.0)
+        orbit.periapsis.should be_within_four_sigma_of(@geostationary_orbit_radius)
+        orbit.periapsis_velocity.should be_within_four_sigma_of(@geostationary_orbit_velocity)
+        orbit.apoapsis.should be_within_four_sigma_of(@geostationary_orbit_radius)
+        orbit.apoapsis_velocity.should be_within_four_sigma_of(@geostationary_orbit_velocity)
+      end
+
+    end
+
+    describe 'constructing geostationary orbits' do
+      before(:all, &BeforeFactory.earth_geostationary_orbit)
+
+      it 'should construct geostationary orbit' do
+        orbit = KerbalDyn::Orbit.geostationary_orbit(@planetoid)
+        orbit.eccentricity.should be_within(1e-9).of(0.0)
+        orbit.periapsis.should be_within_four_sigma_of(@geostationary_orbit_radius)
+        orbit.apoapsis.should be_within_four_sigma_of(@geostationary_orbit_radius)
+        orbit.apoapsis_velocity.should be_within_four_sigma_of(@geostationary_orbit_velocity)
+        orbit.periapsis_velocity.should be_within_four_sigma_of(@geostationary_orbit_velocity)
+      end
+
+    end
+
+    describe 'constructing escape orbits' do
+
+      it 'should construct an escape orbit' do
+        @periapsis = (@planetoid.radius * 2.0) # Just picked one at pseudo-random.
+        orbit = KerbalDyn::Orbit.escape_orbit(@planetoid, @periapsis)
+        orbit.eccentricity.should be_within(1e-9).of(1.0)
+        orbit.specific_energy.should be_within(1e-6).of(0.0)
+      end
+
+    end
+
+  end
+
+  describe 'Orbit Library' do
+
+    PLANET_TEST_DATA.each do |planet_key, test_data|
+      data = test_data[:orbit]
+
+      describe "#{data[:name]}" do
+
+        before(:all) do
+          @library_method = planet_key
+          @orbit = KerbalDyn::Orbit.send(@library_method)
+        end
+
+        it 'should be memoized' do
+          unique_ids = [@orbit, KerbalDyn::Orbit.send(@library_method)].map {|obj| obj.object_id}.uniq
+          unique_ids.length.should == 1
+        end
+
+        it 'should be frozen' do
+          @orbit.should be_frozen
+        end
+
+        it "should have the primary_body #{data[:primary_body]}" do
+          @orbit.primary_body.should == KerbalDyn::Planetoid.send( data[:primary_body] )
+        end
+
+        it "should have the secondary_body #{data[:secondary_body]}" do
+          @orbit.secondary_body.should == KerbalDyn::Planetoid.send( data[:secondary_body] )
+        end
+
+
+        data.each do |property, expected_value|
+          next if [:primary_body, :secondary_body, :name].include?(property)
+          it "should have #{property} of #{expected_value}" do
+            value = @orbit.send(property)
+            case expected_value
+            when Float
+              if( expected_value.abs < 1e-15 )
+                value.should be_within(1e-15).of(expected_value)
+              else
+                value.should be_within_five_sigma_of(expected_value)
+              end
+            else
+              value.should == expected_value
+            end
+          end
+        end
+
+      end
+    end
+
+  end
+
+end

data/spec/orbital_maneuver_base_spec.rb

@@ -0,0 +1,74 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe KerbalDyn::OrbitalManeuver::Base do
+
+  before(:all) do
+    @dummy_body = KerbalDyn::Body.test_particle
+    @dummy_orbit = KerbalDyn::Orbit.new(@dummy_body)
+
+    @body = KerbalDyn::Planetoid.kerbin
+    @orbit1 = KerbalDyn::Orbit.new(@body, :radius => 100e3)
+    @orbit2 = KerbalDyn::Orbit.new(@body, :radius => 12000e3)
+    @maneuver = KerbalDyn::OrbitalManeuver::Base.new(@orbit1, @orbit2)
+  end
+
+  it 'should check that the initial and final orbits are orbiting the same body' do
+    @orbit1.primary_body.should == @orbit2.primary_body
+    lambda { KerbalDyn::OrbitalManeuver::Base.new(@orbit1, @orbit2) }.should_not raise_error
+
+    @orbit1.primary_body.should_not == @dummy_orbit.primary_body
+    lambda { KerbalDyn::OrbitalManeuver::Base.new(@orbit1, @dummy_orbit) }.should raise_error
+  end
+
+  it 'should have an initial_orbit' do
+    @maneuver.initial_orbit.should == @orbit1
+  end
+
+  it 'should have a final_orbit' do
+    @maneuver.final_orbit.should == @orbit2
+  end
+
+  it 'should have delta_time' do
+    @maneuver.should respond_to(:delta_time)
+  end
+
+  it 'should map delta_t to delta_time' do
+    # Override delta_time just like a subclass would.
+    maneuver = @maneuver.dup.tap {|m| m.stub(:delta_time){:jeb}}
+
+    # The real test.
+    maneuver.delta_t.should == maneuver.delta_time
+  end
+
+  describe 'delta_v' do
+
+    class SettableDeltaVelocitiesTestOrbitalManeuver < KerbalDyn::OrbitalManeuver::Base
+      attr_reader :delta_velocities
+      attr_writer :delta_velocities
+    end
+
+    it 'should give a list of delta velocities' do
+      KerbalDyn::OrbitalManeuver::Base.new(@dummy_orbit, @dummy_orbit).delta_velocities.should == []
+    end
+
+    it 'should give the sums of the absolute velocities as delta_v' do
+      maneuver = SettableDeltaVelocitiesTestOrbitalManeuver.new(@dummy_orbit, @dummy_orbit).tap {|m| m.delta_velocities = [5, -2, 4, 0]}
+      maneuver.delta_velocity.should == 11
+      maneuver.delta_v.should == 11
+    end
+
+    it 'should sum an empty velocity list to zero' do
+      maneuver = SettableDeltaVelocitiesTestOrbitalManeuver.new(@dummy_orbit, @dummy_orbit).tap {|m| m.delta_velocities = []}
+      maneuver.delta_velocity.should == 0
+      maneuver.delta_v.should == 0
+    end
+
+    it 'should sum a single negative velocity to its absolute value' do
+      maneuver = SettableDeltaVelocitiesTestOrbitalManeuver.new(@dummy_orbit, @dummy_orbit).tap {|m| m.delta_velocities = [-2]}
+      maneuver.delta_velocity.should == 2
+      maneuver.delta_v.should == 2
+    end
+
+  end
+
+end