kerbaldyn 0.7.0

data/spec/parameter_attributes_spec.rb

@@ -0,0 +1,82 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe KerbalDyn::Mixin::ParameterAttributes do
+
+  class ParameterAttributesTestClass
+    include KerbalDyn::Mixin::ParameterAttributes
+
+    def initialize(foo)
+      self.foo = foo
+    end
+
+    attr_parameter :foo
+    alias_parameter :bar, :foo
+
+    attr_parameter :alpha, :beta, :gamma
+  end
+
+  describe 'attr_parameter' do
+
+    before(:each) do
+      @obj = ParameterAttributesTestClass.new(42)
+    end
+
+    it 'should supply parameter getter' do
+      @obj.should respond_to(:foo)
+      @obj.foo.should == 42
+    end
+
+    it 'should supply parameter setter' do
+      @obj.should respond_to(:foo=)
+      @obj.foo = 88
+      @obj.foo.should == 88
+    end
+
+    [Integer, Float, Rational, Complex].each do |type|
+      it "should convert parameter of type #{type} as a float" do
+        value = Kernel.send(type.name.to_sym, 88)
+        value.should be_kind_of(type)
+
+        @obj.foo = value
+
+        @obj.foo.should be_kind_of(Float)
+        @obj.foo.should be_within_six_sigma_of(88.0)
+      end
+    end
+
+    it 'should accept nil' do
+      @obj.foo = nil
+      @obj.foo.should == nil
+    end
+
+    it 'should accept multiple arguments' do
+      @obj.should respond_to :alpha
+      @obj.should respond_to :beta
+      @obj.should respond_to :gamma
+    end
+
+  end
+
+  describe 'alias_parameter' do
+
+    before(:each) do
+      @obj = ParameterAttributesTestClass.new(42)
+    end
+
+    it "should read aliased parameter value" do
+      @obj.should respond_to(:bar)
+      @obj.bar.should == @obj.foo
+      @obj.foo = 88
+      @obj.bar.should == @obj.foo
+    end
+
+    it "should set aliased parameter value" do
+      @obj.should respond_to(:bar=)
+      @obj.bar = 88
+      @obj.bar.should == @obj.foo
+    end
+
+  end
+
+end
+

data/spec/part_library_spec.rb

@@ -0,0 +1,21 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe KerbalDyn::PartLibrary do
+
+  it 'should be enumerable'
+
+  it 'should respond to length'
+
+  it 'should have convenience methods for making sub libraries by module'
+
+  it 'should export as JSON'
+
+  it 'should export as CSV'
+
+  describe 'parser' do
+
+    it 'should parse a directory of parts into a library'
+
+  end
+
+end

data/spec/part_spec.rb

@@ -0,0 +1,218 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe KerbalDyn::Part do
+
+  before(:all) do
+    @liquid_engine_attr = {"name"=>"liquidEngine", "module"=>"LiquidFuelEngine", "author"=>"Mrbrownce", "mesh"=>"model.mu", "scale"=>"0.1", "node_stack_top"=>"0.0, 7.21461, 0.0, 0.0, 1.0, 0.0", "node_stack_bottom"=>"0.0, -7.27403, 0.0, 0.0, 1.0, 0.0", "fx_exhaustFlame_blue"=>"0.0, -10.3, 0.0, 0.0, 1.0, 0.0, active", "fx_exhaustLight_blue"=>"0.0, -10.3, 0.0, 0.0, 0.0, 1.0, active", "fx_smokeTrail_light"=>"0.0, -10.3, 0.0, 0.0, 1.0, 0.0, active", "sound_vent_medium"=>"activate", "sound_rocket_hard"=>"active", "sound_vent_soft"=>"deactivate", "cost"=>"850", "category"=>"0", "subcategory"=>"0", "title"=>"LV-T30 Liquid Fuel Engine", "manufacturer"=>"Jebediah Kerman's Junkyard and Spaceship Parts Co.", "description"=>"Although criticized by some due to its not unsignificant use of so-called \"pieces found lying about\", the LV-T series has proven itself as a comparatively reliable engine. The T30 model boasts a failure ratio below the 50% mark. This has been considered a major improvement over previous models by engineers and LV-T enthusiasts.", "attachRules"=>"1,0,1,0,0", "mass"=>"1.25", "dragModelType"=>"default", "maximum_drag"=>"0.2", "minimum_drag"=>"0.2", "angularDrag"=>"2", "crashTolerance"=>"7", "maxTemp"=>"3600", "maxThrust"=>"215", "minThrust"=>"0", "heatProduction"=>"400", "Isp"=>"320", "vacIsp"=>"370"}
+    @liquid_engine2_attr = {"name"=>"liquidEngine2", "module"=>"LiquidFuelEngine", "author"=>"Mrbrownce", "mesh"=>"model.mu", "scale"=>"0.1", "node_stack_top"=>"0.0, 7.21461, 0.0, 0.0, 1.0, 0.0", "node_stack_bottom"=>"0.0, -5.74338, 0.0, 0.0, 1.0, 0.0", "fx_exhaustFlame_blue"=>"0.0, -5.74338, 0.0, 0.0, 1.0, 0.0, active", "fx_exhaustLight_blue"=>"0.0, -5.74338, 0.0, 0.0, 0.0, 1.0, active", "fx_smokeTrail_light"=>"0.0, -5.74338, 0.0, 0.0, 1.0, 0.0, active", "sound_vent_medium"=>"activate", "sound_rocket_hard"=>"active", "sound_vent_soft"=>"deactivate", "cost"=>"950", "category"=>"0", "subcategory"=>"0", "title"=>"LV-T45 Liquid Fuel Engine", "manufacturer"=>"Jebediah Kerman's Junkyard and Spaceship Parts Co.", "description"=>"The LV-T45 engine was considered another breakthrough in the LV-T series, due to its Thrust Vectoring feature. The LV-T45 can deflect its thrust to aid in craft control. All these added mechanics however, make for a slightly smaller and less powerful engine in comparison with earlier LV-T models.", "attachRules"=>"1,0,1,0,0", "mass"=>"1.5", "dragModelType"=>"default", "maximum_drag"=>"0.2", "minimum_drag"=>"0.2", "angularDrag"=>"2", "crashTolerance"=>"7", "maxTemp"=>"3600", "maxThrust"=>"200", "minThrust"=>"0", "heatProduction"=>"440", "fuelConsumption"=>"7", "Isp"=>"320", "vacIsp"=>"370", "thrustVectoringCapable"=>"True", "gimbalRange"=>"1.0"}
+    @fuel_tank_attr = {"name"=>"fuelTank", "module"=>"FuelTank", "author"=>"Mrbrownce", "mesh"=>"model.mu", "scale"=>"0.1", "node_stack_top"=>"0.0, 7.72552, 0.0, 0.0, 1.0, 0.0", "node_stack_bottom"=>"0.0, -7.3, 0.0, 0.0, 1.0, 0.0", "node_attach"=>"5.01, 0.0, 0.0, 1.0, 0.0, 0.0, 1", "cost"=>"850", "category"=>"0", "subcategory"=>"0", "title"=>"FL-T400 Fuel Tank", "manufacturer"=>"Jebediah Kerman's Junkyard and Spaceship Parts Co.", "description"=>"The FL series was received as a substantial upgrade over previous fuel containers used in the Space Program, generally due to its ability to keep the fuel unexploded more often than not. Fuel tanks are useless if there isn't a Liquid Engine attached under it. They can also be stacked with other fuel tanks to increase the amount of fuel for the engine below.", "attachRules"=>"1,1,1,1,0", "mass"=>"2.25", "dragModelType"=>"default", "maximum_drag"=>"0.2", "minimum_drag"=>"0.3", "angularDrag"=>"2", "crashTolerance"=>"6", "breakingForce"=>"50", "breakingTorque"=>"50", "maxTemp"=>"2900", "fuel"=>"400.0", "dryMass"=>"0.25", "fullExplosionPotential"=>"0.9", "emptyExplosionPotential"=>"0.1"}
+    @rcs_tank_attr = {"name"=>"RCSFuelTank", "module"=>"RCSFuelTank", "author"=>"Mrbrownce || HarvesteR", "mesh"=>"model.mu", "scale"=>"0.1", "node_stack_top"=>"0.0, 4.64624, 0.0, 0.0, 1.0, 0.0", "node_stack_bottom"=>"0.0, 0.23193, 0.0, 0.0, 1.0, 0.0", "cost"=>"800", "category"=>"0", "subcategory"=>"0", "title"=>"FL-R25 RCS Fuel Tank", "manufacturer"=>"Jebediah Kerman's Junkyard and Spaceship Parts Co.", "description"=>"These fuel tanks carry pressurized gas propellant for RCS thrusters. New advances in plumbing technology made it possible to route RCS lines to any point in the ship. So unlike liquid fuel tanks, RCS Fuel tanks can be placed anywhere.", "attachRules"=>"1,0,1,1,0", "mass"=>"0.5", "dragModelType"=>"default", "maximum_drag"=>"0.2", "minimum_drag"=>"0.2", "angularDrag"=>"2", "crashTolerance"=>"12", "maxTemp"=>"2900", "fuel"=>"200", "dryMass"=>"0.1", "fullExplosionPotential"=>"0.7", "emptyExplosionPotential"=>"0.1"}
+    @booster_attr = {"name"=>"solidBooster", "module"=>"SolidRocket", "author"=>"Il Carnefice", "mesh"=>"model.mu", "scale"=>"0.1", "node_stack_bottom"=>"0.0, -12.5127, 0.0, 0.0, 1.0, 0.0, 1", "node_stack_top"=>"0.0, 10.2547, 0.0, 0.0, 1.0, 0.0, 1", "node_attach"=>"0.0, 0.0, -5, 0.0, 0.0, 1.0, 1", "fx_exhaustFlame_yellow"=>"0.0, -11.2673, 0.0, 0.0, 1.0, 0.0, active", "fx_exhaustSparks_yellow"=>"0.0, -11.2673, 0.0, 0.0, 1.0, 0.0, active", "fx_smokeTrail_medium"=>"0.0, -11.2673, 0.0, 0.0, 1.0, 0.0, active", "sound_vent_medium"=>"activate", "sound_rocket_hard"=>"active", "sound_vent_soft"=>"deactivate", "cost"=>"450", "category"=>"0", "subcategory"=>"0", "title"=>"RT-10 Solid Fuel Booster", "description"=>"While considered by some to be little more than \"a trash bin full o' boom\", The RT-10 is used in many space programs, whenever the need to save cash is greater than the need to keep astronauts alive. Use with caution, though. Once lit, solid fuel motors cannot be put out until the fuel runs out.", "attachRules"=>"1,1,1,1,0", "mass"=>"1.8", "dragModelType"=>"default", "maximum_drag"=>"0.3", "minimum_drag"=>"0.2", "angularDrag"=>"2", "crashTolerance"=>"7", "maxTemp"=>"3600", "thrust"=>"250", "dryMass"=>"0.36", "heatProduction"=>"550", "fuelConsumption"=>"4", "internalFuel"=>"100", "fullExplosionPotential"=>"0.8", "emptyExplosionPotential"=>"0.1", "thrustCenter"=>"0, -0.5, 0", "thrustVector"=>"0, 1, 0"}
+  end
+
+  describe KerbalDyn::Part::Base do
+
+    describe 'properties' do
+
+      before(:each) do
+        @attributes = {'name' => 'fooThruster', 'module' => 'LiquidFuelEngine', 'category' => '0'}
+        @part = KerbalDyn::Part::Base.new(@attributes)
+      end
+
+      # Rather than test every single property, we test those that have non-trivial
+      # accessors.
+
+      it 'should provide string and symbol access to attributes' do
+        @part['name'].should == @attributes['name']
+        @part[:name].should == @attributes['name']
+      end
+
+      it 'should provide category name' do
+        @part.category.should == KerbalDyn::Part::CATEGORIES['Propulsion']
+        @part.category_name.should == 'Propulsion'
+      end
+
+      it 'should provide module class' do
+        @part.module_class.should == KerbalDyn::Part::LiquidFuelEngine
+      end
+
+      it 'should copy the attributes passed to it' do
+        attributes = @attributes.dup
+        part = KerbalDyn::Part::Base.new(attributes)
+
+        part.attributes.object_id.should_not == attributes.object_id
+
+        part['name'].should == 'fooThruster'
+        attributes['name'] == 'barThruster'
+        part['name'].should_not == 'barThruster'
+      end
+
+      it 'should convert to hash that is not the attributes hash itself' do
+        hash = @part.to_hash
+
+        hash.should == @part.attributes
+        hash.object_id.should_not == @part.attributes.object_id
+      end
+
+      it 'should export as JSON' do
+        part_json = @part.to_json
+        attributes_json = @part.to_hash.to_json
+
+        part_json.should == attributes_json
+      end
+
+      it 'should export as CSV' # This will need a predefined set of properties to output.
+
+    end
+
+    describe 'loader' do
+
+      before(:all) do
+        @parts_directory = File.join(File.dirname(__FILE__), 'support', 'parts')
+        @liquid_engine_part_dir = File.join(@parts_directory, 'liquidEngine1')
+        @part_dir = @liquid_engine_part_dir
+      end
+
+      before(:each) do
+        @part = KerbalDyn::Part::Base.load_part(@part_dir)
+      end
+
+      it 'should load parts from part directories' do
+        @part.should be_kind_of(KerbalDyn::Part::Base)
+      end
+
+      it 'should instantiate as the module attribute class' do
+        @part.class.name.should =~ Regexp.new( 'KerbalDyn::Part::' + @part[:module] + "$")
+      end
+
+      it 'should default to instantiating as generic'
+
+      it 'should return nil if no part was found' do
+        dir_path = File.join(@parts_directory, 'tardis') # Doesn't exist.
+        part = KerbalDyn::Part::Base.load_part(dir_path)
+        part.should == nil
+      end
+
+      it 'should log parse errors'
+
+    end
+
+  end
+
+  describe KerbalDyn::Part::Generic do
+
+    it 'should be a subclass of Base' do
+      KerbalDyn::Part::Generic < KerbalDyn::Part::Base
+    end
+
+  end
+
+  describe KerbalDyn::Part::FuelTank do
+
+    before(:each) do
+      @fuel_tank = KerbalDyn::Part::FuelTank.new(@fuel_tank_attr)
+    end
+
+    it 'should calculate capacity in m^3' do
+      @fuel_tank.capacity.should be_within_six_sigma_of(0.4)
+    end
+
+    it 'should calculate fuel mass' do
+      @fuel_tank.fuel_mass.should be_within_six_sigma_of(2.0)
+    end
+
+    it 'should calculate fuel density in kg/m^3' do
+      @fuel_tank.fuel_density.should be_within_six_sigma_of(5.0)
+    end
+
+  end
+
+  describe KerbalDyn::Part::RCSFuelTank do
+
+    before(:each) do
+      @rcs_tank = KerbalDyn::Part::FuelTank.new(@rcs_tank_attr)
+    end
+
+    it 'should calculate capacity in m^3' do
+      @rcs_tank.capacity.should be_within_six_sigma_of(0.2)
+    end
+
+    it 'should calculate fuel mass' do
+      @rcs_tank.fuel_mass.should be_within_six_sigma_of(0.4)
+    end
+
+    it 'should calculate fuel density in kg/m^3' do
+      @rcs_tank.fuel_density.should be_within_six_sigma_of(2.0)
+    end
+
+  end
+
+  describe KerbalDyn::Part::LiquidFuelEngine do
+
+    before(:each) do
+      @liquid_engine = KerbalDyn::Part::LiquidFuelEngine.new(@liquid_engine_attr)
+      @liquid_engine2 = KerbalDyn::Part::LiquidFuelEngine.new(@liquid_engine2_attr)
+    end
+
+    it 'should give Isp at sealevel' do
+      measured = 320.7
+      @liquid_engine.isp.should be_within_three_sigma_of(measured)
+    end
+
+    it 'should give vacuum Isp' do
+      specified = 370.0
+      @liquid_engine.vac_isp.should be_within_six_sigma_of(specified)
+    end
+
+    it 'should calculate mass flow rate' do
+      expected = (215.0/320.0) / 9.8066 # Not sure what the 5th digit of g should be.
+      @liquid_engine.mass_flow_rate.should be_within_three_sigma_of(expected)
+    end
+
+    it 'should calculate vacuum mass flow rate' do
+      expected = (215.0/370.0) / 9.8066 # Not sure what hte 5th digit of g should be.
+      @liquid_engine.vac_mass_flow_rate.should be_within_three_sigma_of(expected)
+    end
+
+    it 'should calculate fuel consumption in m^3/s' do
+      fuel_tank = KerbalDyn::Part::FuelTank.new(@fuel_tank_attr)
+      measured = 13.7 # in liters/second
+      @liquid_engine.fuel_consumption(fuel_tank).should be_within_three_sigma_of(measured/1000.0)
+    end
+
+    it 'should calculate vacuum fuel consumption in m^3/s' do
+      fuel_tank = KerbalDyn::Part::FuelTank.new(@fuel_tank_attr)
+      @liquid_engine.vac_fuel_consumption(fuel_tank).should be_within_two_sigma_of(0.0119)
+    end
+
+  end
+
+  describe KerbalDyn::Part::SolidRocket do
+
+    before(:each) do
+      @booster = KerbalDyn::Part::SolidRocket.new(@booster_attr)
+    end
+
+    it 'should calculate capacity in m^3' do
+      @booster.capacity.should be_within_six_sigma_of(0.1)
+    end
+
+    it 'should calculate fuel mass' do
+      @booster.fuel_mass.should be_within_six_sigma_of(1.44)
+    end
+
+    it 'should calculate fuel density in kg/m^3' do
+      @booster.fuel_density.should be_within_six_sigma_of(14.4)
+    end
+
+    it 'should calculate fuel consumption in m^3/s' do
+      @booster.fuel_consumption.should be_within_six_sigma_of(0.004)
+    end
+
+    it 'should calculate burn time' do
+      @booster.burn_time.should be_within_six_sigma_of(25.0)
+    end
+
+  end
+
+end

data/spec/planetoid_spec.rb

@@ -0,0 +1,117 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe KerbalDyn::Planetoid do
+
+  describe 'Properties' do
+    before(:each, &BeforeFactory.earth)
+
+    it "should have a name" do
+      @planetoid.name.should == @name
+    end
+
+    [
+      :mass,
+      :radius,
+      :rotational_period,
+      :gravitational_parameter,
+      :surface_gravity,
+      :volume,
+      :density,
+      :angular_velocity,
+      :equitorial_velocity,
+      :escape_velocity,
+    ].each do |method|
+      it "should calculate #{method}" do
+        value = self.instance_variable_get("@#{method}")
+        # Two sigma let's rough calculations (like those that assume a sphere instead of a spheroid) pass.
+        @planetoid.send(method).should be_within_two_sigma_of(value)
+      end
+    end
+
+    [
+      [:gravitational_acceleration, :surface_gravity, :radius],
+    ].each do |method, expected_var, *args_vars|
+      it "should calculate #{method}" do
+        expected = self.instance_variable_get("@#{expected_var}")
+        args = args_vars.map {|var| self.instance_variable_get("@#{var}")}
+        @planetoid.send(method, *args).should be_within_two_sigma_of(expected)
+      end
+    end
+
+  end
+
+
+  describe 'Planetoid Library' do
+
+    describe 'Kerbol' do
+
+      before(:all) do
+        @planet_fact  = KerbalDyn::Planetoid.kerbol
+        @expected_name = 'Kerbol'
+      end
+
+      it 'should be available via a factory method' do
+        @planet_fact.should be_kind_of(KerbalDyn::Planetoid)
+        @planet_fact.name.should == @expected_name
+      end
+
+      it 'should be a memoized' do
+        # We fetch the constant and the factory method value twice, to be sure they are all the same.
+        unique_ids = [@planet_fact, @planet_fact].map {|obj| obj.object_id}.uniq
+        unique_ids.length.should == 1
+      end
+
+      it 'should be frozen' do
+        @planet_fact.should be_frozen
+      end
+
+      {
+        :radius => 261600000.0,
+        :mass => 1.756830203555361e28,
+        :surface_gravity => 17.13071282744409,
+        :gravitational_parameter => 1.172332794832492300e18,
+        :escape_velocity => 94672.00722134684
+      }.each do |param, value|
+        it "should have a #{param} of #{value}" do
+          @planet_fact.send(param).should be_within_six_sigma_of(value)
+        end
+      end
+
+    end
+
+    PLANET_TEST_DATA.each do |planet_key, test_data|
+      data = test_data[:planetoid]
+
+      describe "#{data[:name]}" do
+
+        before(:all) do
+          @planetoid = KerbalDyn::Planetoid.send(planet_key)
+        end
+
+        it 'should be memoized' do
+          unique_ids = [@planetoid, KerbalDyn::Planetoid.send(planet_key)].map {|obj| obj.object_id}.uniq
+          unique_ids.length.should == 1
+        end
+
+        it 'should be frozen' do
+          @planetoid.should be_frozen
+        end
+
+        data.each do |property, expected_value|
+          it "should have #{property} of #{expected_value}" do
+            case expected_value
+            when Float
+              @planetoid.send(property).should be_within_six_sigma_of(expected_value)
+            else
+              @planetoid.send(property).should == expected_value
+            end
+          end
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,110 @@
+require 'rubygems'
+require 'bundler/setup'
+Bundler.require(:test)
+
+require 'kerbaldyn'
+
+
+require 'json'
+require 'pathname'
+planet_test_data_file = Pathname.new(__FILE__).dirname + 'support' + 'planet_test_data.json'
+PLANET_TEST_DATA = JSON.parse( planet_test_data_file.read, :symbolize_names => true )
+
+
+RSpec::Matchers.define :be_within_error do |err|
+  chain :of do |expected|
+    @expected = expected
+  end
+
+  match do |actual|
+    actual.should be_within( (err*@expected).abs ).of(@expected)
+  end
+end
+
+{:two => 21.977895, :three => 370.398, :four => 15787.0, :five => 1744278.0, :six => 506797346}.each do |level, frac|
+  err = 1.0 / frac.to_f
+  RSpec::Matchers.define "be_within_#{level}_sigma_of".to_sym do |expected|
+    match do |actual|
+      actual.should be_within_error(err).of(expected)
+    end
+  end
+end
+
+class BeforeFactory
+
+  # I looked up real values off of tables for the Earth as test data where possible.
+  def self.earth
+    return Proc.new do
+      @name = 'Earth'
+      @mass = 5.9736e24
+      @radius = 6378.1e3
+      @rotational_period = 86164.091
+      @angular_velocity = 7.2921150e-5
+      @volume = 1.08321e21
+      @density = 5515.0
+      @gravitational_parameter = 398600.4418e9 # 398600.4418e9 is on some tables, but other tables vary starting in the 4th digit!
+      @surface_gravity = 9.780327
+      @escape_velocity = 11.186e3
+      @equitorial_velocity = 465.1
+
+      @options = {
+        :mass => @mass,
+        :radius => @radius,
+        :rotational_period => @rotational_period
+      }
+      @planetoid = KerbalDyn::Planetoid.new(@name, @options)
+    end
+  end
+
+  # I looked up values from tables where possible.
+  def self.earth_geostationary_orbit
+    return Proc.new do
+      @geostationary_orbit_radius = 42164e3
+      @geostationary_orbit_altitude = 35786e3
+      @geostationary_orbit_angular_velocity = 7.2921e-5
+      @geostationary_orbit_velocity = 3074.6
+      @orbital_radius = @geostationary_orbit_radius
+      @orbital_period = @rotational_period
+      @orbital_velocity = @geostationary_orbit_velocity
+      @orbital_specific_kinetic_energy = 4726582.58 # Computed
+      @orbital_specific_potential_energy = -9453572.75875 # Computed
+      @orbital_specific_angular_momentum = 129640229204 # Computed using an alternative formula from a different source.
+      @orbit = KerbalDyn::Orbit.new(@planetoid, :radius => @orbital_radius)
+    end
+  end
+
+  # A third party transfer to geosynchronous orbit from 300km alt example that
+  # can be used for the basis of elliptical orbit tests.
+  def self.geostationary_transfer_orbit
+    return Proc.new do
+      @periapsis = 6678e3
+      @apoapsis = 42164e3
+      @periapsis_velocity = 10150
+      @apoapsis_velocity = 1610
+      @eccentricity = 0.72655
+      @semimajor_axis = 24421e3
+      @orbit = KerbalDyn::Orbit.new(@planetoid, :periapsis => @periapsis, :apoapsis => @apoapsis)
+    end
+  end
+
+  # A pre-calculated and verified parabloic escape orbit from earth.
+  def self.earth_escape_orbit
+    return Proc.new do
+      @periapsis = 6678e3
+      # I used the calculated gavitational parameter for better precision,
+      # since this is a "critical" orbit between elliptical and hyperbolc orbits.
+      @escape_velocity = Math.sqrt( 2.0 * @planetoid.gravitational_parameter / @periapsis )
+      @orbit = KerbalDyn::Orbit.new(@planetoid, :periapsis => @periapsis, :periapsis_velocity => @escape_velocity)
+    end
+  end
+
+  def self.earth_hyperbolic_orbit
+    return Proc.new do
+      @periapsis = 6678e3
+      @periapsis_velocity = 20000
+      @eccentricity = 5.701 #Precomputed
+      @orbit = KerbalDyn::Orbit.new(@planetoid, :periapsis => @periapsis, :periapsis_velocity => @periapsis_velocity)
+    end
+  end
+
+end