kerbaldyn 0.7.0

data/lib/kerbaldyn/part/rcs_fuel_tank.rb

@@ -0,0 +1,10 @@
+module KerbalDyn
+  module Part
+    # A class respresenting all RCS fuel tanks.
+    #
+    # Most of its methods are defined in the Mixin::FuelTank module.
+    class RCSFuelTank < Base
+      include Mixin::FuelTank
+    end
+  end
+end

data/lib/kerbaldyn/part/solid_rocket.rb

@@ -0,0 +1,30 @@
+module KerbalDyn
+  module Part
+    # A class respresenting booster rockets
+    #
+    # Some of its methods are defined in the Mixin::FuelTank module.
+    class SolidRocket < Base
+      include Mixin::FuelTank
+
+      def thrust
+        return self['thrust'].to_f
+      end
+
+      def heat_production
+        return self['heatProduction'].to_f
+      end
+
+      # The fuel consumption in m^3/s
+      #
+      # To convert to liters/second, multiply by 1000
+      def fuel_consumption
+        return self['fuelConsumption'].to_f / 1000.0
+      end
+
+      def burn_time
+        return self.capacity / self.fuel_consumption
+      end
+
+    end
+  end
+end

data/lib/kerbaldyn/part_library.rb

@@ -0,0 +1,55 @@
+require 'pathname'
+
+module KerbalDyn
+  # PartLibrary is an array like list of Part objects with convenience methods
+  # for common operations.
+  class PartLibrary
+    include Enumerable
+
+    # Loads parts from a given directory into the library.
+    def self.load_parts(directory)
+      dir = Pathname.new(directory)
+      raise nil unless dir.directory?
+
+      parts = dir.children.reject do |part_dir|
+        # Reject if it starts with a dot or is not a directory.
+        (part_dir.basename.to_s =~ /^\./) || !part_dir.directory?
+      end.inject([]) do |parts, part_dir|
+        parts << Part::Base.load_part(part_dir)
+      end
+
+      return self.new(parts)
+    end
+
+    # Initialize with an array of parts or a list of parts.
+    def initialize(*parts)
+      @parts = parts.to_a.flatten
+    end
+
+    # Iterates over each part using a block.
+    #
+    # This is the root for all Enumerable methods.
+    def each(&block)
+      return @parts.each(&block)
+    end
+
+    # The lenght
+    def length
+      return @parts.length
+    end
+
+    # Returns the part with the given index or directory name
+    def [](val)
+      case val
+      when Numeric
+        return @parts[val]
+      else
+        return @parts.find {|part| part.directory_name == val}
+      end
+    end
+
+  end
+end
+
+#$lib = KerbalDyn::PartLibrary.load_parts("/Users/jreinecke/Downloads/NovaPunch1_3beta/NovaPunch/Parts")
+#$lib = KerbalDyn::PartLibrary.load_parts("/Users/jreinecke/Downloads/KSPDefaultParts")

data/lib/kerbaldyn/planetoid.rb

@@ -0,0 +1,214 @@
+module KerbalDyn
+
+  # Planetoid is the superclass of any planetary object.  It is primarily used
+  # to build existing planetoids via factory methods to calculate orbit
+  # characteristics around the planetoid.
+  #
+  # Most interesting parameters are included through the DerivedParameters module.
+  class Planetoid < Body
+
+    # For data read in from data files, this private method DRYs the process.
+    def self.make(planet_ref)
+      data = Data.fetch(:planet_data)[planet_ref][:planetoid]
+      name = data[:name]
+      parameters = data.reject {|k,v| k == :name}
+      return self.new(name, parameters).freeze
+    end
+
+    class << self
+      private :make
+    end
+
+    # :category: Library Methods
+    # The Kerbal Sun.
+    def self.kerbol
+      # TODO: Refactor to calculate these from data on-the-fly (need to output that kind of data first).
+      #
+      # Grav Parameter calculated from semimajor axis and velocity vector dumps via mu = a*v**2, and is good to around the 15th digit.
+      # Radius calculated by subtracting Kerbin Apa from Apr in data dump
+      return @kerbol ||= self.new('Kerbol', :gravitational_parameter => 1172332794832492300.0, :radius => 261600000).freeze
+    end
+
+    # :category: Library Methods
+    #The Earth-like Homeworld.
+    def self.kerbin
+      return @kerbin ||= make(__method__)
+    end
+
+    # :category: Library Methods
+    # The Moon equivalient; orbits Kerbin.
+    def self.mun
+      return @mun ||= make(__method__)
+    end
+
+    # :category: Library Methods
+    # A small outter moon of Kerbin; no Solar System equivalent.
+    def self.minmus
+      return @minmus ||= make(__method__)
+    end
+
+    # :category: Library Methods
+    # The inner planet (Mercury like)
+    def self.moho
+      return @moho ||= make(__method__)
+    end
+
+    # :category: Library Methods
+    # The second planet (Venus like)
+    def self.eve
+      return @eve ||= make(__method__)
+    end
+
+    # :category: Library Methods
+    # The asteroid moon of Gilly
+    def self.gilly
+      return @gilly ||= make(__method__)
+    end
+
+    # :category: Library Methods
+    # The fourth planet (Mars like)
+    def self.duna
+      return @duna ||= make(__method__)
+    end
+
+    # :category: Library Methods
+    # The moon of Duna
+    def self.ike
+      return @ike ||= make(__method__)
+    end
+
+    # :category: Library Methods
+    # The fifth planet (Jupiter like)
+    def self.jool
+      return @jool ||= make(__method__)
+    end
+
+    # :category: Library Methods
+    # The first moon of Jool, ocean moon with atmosphere
+    def self.laythe
+      return @laythe ||= make(__method__)
+    end
+
+    # :category: Library Methods
+    # The second moon of Jool, ice moon
+    def self.vall
+      return @vall ||= make(__method__)
+    end
+
+    # :category: Library Methods
+    # The third moon of Jool, rocky
+    def self.tylo
+      return @tylo ||= make(__method__)
+    end
+
+    # :category: Library Methods
+    # The captured asteroid around Jool.
+    def self.bop
+      return @bop ||= make(__method__)
+    end
+
+    def initialize(name, options={})
+      super
+    end
+
+    alias_parameter :radius, :bounding_sphere_radius
+
+    # Returns the gravtiational_parameter (G*M) of the planetoid.
+    def gravitational_parameter
+      Constants::G * self.mass
+    end
+
+    # Sets the gravitational parameter (G*M) by deriving the mass and setting it.
+    def gravitational_parameter=(mu)
+      self.send(:mass=, mu / Constants::G)
+    end
+    private :gravitational_parameter=
+
+    # The rotational period of this body around its axis.
+    def rotational_period
+      return 2.0 * Math::PI / self.angular_velocity
+    end
+
+    # Set the rotational period of this body.
+    def rotational_period=(period)
+      self.angular_velocity = period && (2.0 * Math::PI / period)
+    end
+
+    # Returns the gravitational accelaration at a given radius from the
+    # center of the planet.
+    def gravitational_acceleration(r)
+      return self.gravitational_parameter / r**2
+    end
+
+    # Returns the surface gravity (acceleration) of this planetoid.
+    #
+    # If a value is given, then this is used as the height above the surface
+    # to calculate the gravity.
+    def surface_gravity(h=0.0)
+      return self.gravitational_acceleration( self.radius + h )
+    end
+
+    # The volume of the planetoid.
+    def volume
+      return (4.0/3.0) * Math::PI * self.radius**3
+    end
+
+    # The density of the planetoid.
+    def density
+      return self.mass / self.volume
+    end
+
+    # Equitorial linear velocity of the planetoid.
+    #
+    # If a value is gien, then this is used as the height above the surface for
+    # the calculation.
+    def equitorial_velocity(h=0.0)
+      return self.angular_velocity * (self.radius + h)
+    end
+
+    # Equitorial linear velocity of the planetoid.
+    #
+    # If a value is gien, then this is used as the height above the surface for
+    # the calculation.
+    def equitorial_velocity(h=0.0)
+      return self.angular_velocity * (self.radius + h)
+    end
+
+    # Calculates the escape velocity of the planetoid.
+    def escape_velocity
+      return Math.sqrt( 2.0 * self.gravitational_parameter / self.radius )
+    end
+
+    # ===== Orbit Library Methods =====
+
+    def geostationary_orbit
+      return Orbit.geostationary_orbit(self)
+    end
+
+    def circular_orbit(radius)
+      return Orbit.circular_orbit(self, radius)
+    end
+
+    def circular_orbit_of_period(period)
+      return Orbit.circular_orbit_of_period(self, period)
+    end
+
+    def escape_orbit(periapsis)
+      return Orbit.escape_orbit(self, periapsis)
+    end
+
+    def self.orbit(options={})
+      return Orbit.new(self, options)
+    end
+
+    # ===== ALIASES =====
+
+    alias_method :m, :mass
+    alias_method :r, :radius
+    alias_method :t, :rotational_period
+    alias_method :g, :surface_gravity
+    alias_method :rho, :density
+    alias_method :mu, :gravitational_parameter
+
+  end
+end

data/lib/kerbaldyn/version.rb

@@ -0,0 +1,13 @@
+module KerbalDyn
+  class Version
+    MAJOR = 0
+    MINOR = 7
+    TINY  = 0
+
+    def self.to_s
+      return [MAJOR, MINOR, TINY].join('.')
+    end
+  end
+
+  VERSION = Version.to_s
+end

data/spec/bielliptic_orbital_maneuver_spec.rb

@@ -0,0 +1,60 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe KerbalDyn::OrbitalManeuver::Bielliptic do
+
+  describe 'Test Maneuver' do
+
+    before(:all) do
+      @planetoid = KerbalDyn::Planetoid.new('Gallifrey', :gravitational_parameter => 2.0**12, :radius => 2.0)
+    end
+
+    [
+      {:name => 'Low Transfer Up',  :r1 => 16.0, :r2 => 64.0, :rt =>   4.0, :delta_v => 14.563217871508062, :delta_vs => [-5.88071148746, 3.42648374633,  5.25602263772], :times => [0.0, 1.55227941653, 11.2839695983]},
+      {:name => 'Med Transfer Up',  :r1 => 16.0, :r2 => 64.0, :rt =>  32.0, :delta_v =>  7.769576954455817, :delta_vs => [ 2.47520861407, 3.82634098781,  1.46802735258], :times => [0.0, 5.77147423573, 22.0956685138]},
+      {:name => 'High Transfer Up', :r1 => 16.0, :r2 => 64.0, :rt => 256.0, :delta_v =>  9.228940857774582, :delta_vs => [ 5.95181889824, 1.15783344699, -2.11928851254], :times => [0.0, 77.8535214542, 177.199404112]},
+    ].each do |test_case|
+
+      describe test_case[:name] do
+
+        before(:all) do
+          @initial_orbit = KerbalDyn::Orbit.new(@planetoid, :radius => test_case[:r1])
+          @final_orbit   = KerbalDyn::Orbit.new(@planetoid, :radius => test_case[:r2])
+          @bielliptic = KerbalDyn::OrbitalManeuver::Bielliptic.new(@initial_orbit, @final_orbit, :transfer_radius => test_case[:rt])
+        end
+
+        it "should have the right transfer radius" do
+          @bielliptic.transfer_radius.should be_within_six_sigma_of( test_case[:rt] )
+        end
+
+        it "should calculate the right delta_vs" do
+          test_case[:delta_vs].zip( @bielliptic.delta_velocities ).each do |expected, actual|
+            actual.should be_within_six_sigma_of(expected)
+          end
+        end
+
+        it "should calculate the right delta v" do
+          @bielliptic.delta_v.should > 0.0
+          @bielliptic.delta_v.should be_within_six_sigma_of( test_case[:delta_v] )
+        end
+
+        it "should calculate the right times" do
+          test_case[:times].zip( @bielliptic.times ).each do |expected, actual|
+            if( expected.abs <= 1e-9 )
+              expected.should be_within(1e-9).of(expected)
+            else
+              actual.should be_within_six_sigma_of(expected)
+            end
+          end
+        end
+
+        it "should calculate the right delta_anomaly" do
+          @bielliptic.delta_mean_anomaly.should be_within_six_sigma_of( 2.0 * Math::PI )
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/constants_spec.rb

@@ -0,0 +1,9 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe KerbalDyn::Constants do
+
+  it "should define Newton's gravitational constant" do
+    KerbalDyn::Constants::G.should be_kind_of(Numeric)
+  end
+
+end

data/spec/hohmann_orbital_maneuver_spec.rb

@@ -0,0 +1,385 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe KerbalDyn::OrbitalManeuver::Hohmann do
+
+  # I'm purposefully violating a purist OrbitalManeuver::Base Unit Test for the sake of time,
+  # since the necessary tests involve implementing the same two methods that that Hohmann does.
+  describe "Standard Hohmann, including testing OrbitalManeuver::Base methods with a real transfer." do
+
+    before(:all) do
+      # Set all the testable data with hard-set values.
+      @initial = {:mean_velocity => 16.0, :semimajor_axis => 16.0}
+      @final = {:mean_velocity => 8.0, :semimajor_axis => 64.0}
+      @transfer = {:periapsis => 16.0, :periapsis_velocity => 20.2385770251, :apoapsis => 64.0, :apoapsis_velocity => 5.05964425627}
+      @time = 12.41823533225
+      @delta_vs = [4.23857702508, 2.94035574373]
+      @delta_v = 7.178932768808223
+
+      # Build the test transfer object up from basic pieces.
+      # TODO: Stub these classes to make a truly independent class.
+      @planetoid = KerbalDyn::Planetoid.new('Gallifrey', :gravitational_parameter => 2.0**12, :radius => 2.0)
+      @initial_orbit = KerbalDyn::Orbit.new(@planetoid, :radius => @initial[:semimajor_axis])
+      @final_orbit = KerbalDyn::Orbit.new(@planetoid, :radius => @final[:semimajor_axis])
+      @hohmann = KerbalDyn::OrbitalManeuver::Hohmann.new(@initial_orbit, @final_orbit)
+    end
+
+    it 'should produce the transfer orbit' do
+      transfer_orbit = @hohmann.transfer_orbit
+      @transfer.each {|k,v| transfer_orbit.send(k).should be_within_six_sigma_of(v)}
+    end
+
+    it 'should produce the list of orbits' do
+      orbits = @hohmann.orbits
+
+      orbits.length.should == 3
+      orbits[0].should == @hohmann.initial_orbit
+      orbits[1].should == @hohmann.transfer_orbit
+      orbits[2].should == @hohmann.final_orbit
+    end
+
+    it 'should produce the list of burn events' do
+      burn_events = @hohmann.burn_events
+
+      burn_events.length.should == 2
+
+      burn_events.first.tap do |be|
+        be.initial_velocity.should be_within_six_sigma_of( @initial[:mean_velocity] )
+        be.final_velocity.should be_within_six_sigma_of( @transfer[:periapsis_velocity] )
+        be.orbital_radius.should be_within_six_sigma_of( @initial[:semimajor_axis] )
+        be.time.should be_within(1e-9).of(0.0)
+        be.mean_anomaly.should be_within(1e-9).of(0.0)
+      end
+
+      burn_events.last.tap do |be|
+        be.initial_velocity.should be_within_six_sigma_of( @transfer[:apoapsis_velocity] )
+        be.final_velocity.should be_within_six_sigma_of( @final[:mean_velocity] )
+        be.orbital_radius.should be_within_six_sigma_of( @final[:semimajor_axis] )
+        be.time.should be_within_six_sigma_of(@time)
+        be.mean_anomaly.should be_within_six_sigma_of(Math::PI)
+      end
+    end
+
+    it 'should know if it is moving ot a higher orbit' do
+      @hohmann.moving_to_higher_orbit?.should be_true
+    end
+
+    it 'should produce the list of before/after velocities' do
+      velocities = @hohmann.velocities
+      expected_velocities = [ [@initial[:mean_velocity], @transfer[:periapsis_velocity]], [@transfer[:apoapsis_velocity], @final[:mean_velocity]] ]
+
+      [0,1].each do |i|
+        [0,1].each do |j|
+          velocities[i][j].should be_within_six_sigma_of(expected_velocities[i][j])
+        end
+      end
+    end
+
+    it 'should produce the list of delta velocities' do
+      @hohmann.delta_velocities.zip(@delta_vs).each do |actual, expected|
+        actual.should be_within_six_sigma_of(expected)
+      end
+    end
+
+    it 'should produce the list of impulse burn time stamps' do
+      @hohmann.times.first.should be_within(1e-9).of(0.0)
+      @hohmann.times.last.should be_within_six_sigma_of(@time)
+    end
+
+    it 'should produce the list of impulse burn radii' do
+      @hohmann.orbital_radii.zip([@initial[:semimajor_axis], @final[:semimajor_axis]]).each do |actual, expected|
+        actual.should be_within_six_sigma_of(expected)
+      end
+    end
+
+    it 'should produce the list of impulse burn mean anomalies' do
+      @hohmann.mean_anomalies.first.should be_within(1e-9).of(0.0)
+      @hohmann.mean_anomalies.last.should be_within_six_sigma_of(Math::PI)
+    end
+
+    it 'should produce the final delta velocity' do
+      @hohmann.delta_velocity.should >= 0.0
+      @hohmann.delta_velocity.should be_within_six_sigma_of(@delta_v)
+      @hohmann.delta_v.should == @hohmann.delta_velocity
+    end
+
+    it 'should produce the delta_t' do
+      @hohmann.delta_t.should be_within_six_sigma_of(@time)
+    end
+
+    it 'should produce the delta anomaly' do
+      @hohmann.delta_mean_anomaly.should be_within_six_sigma_of(Math::PI)
+    end
+
+    it 'should produce the mean lead angle' do
+      @hohmann.mean_lead_angle.should be_within_six_sigma_of(1.5893132370591518)
+    end
+
+    it 'should produce the mean lead time' do
+      @hohmann.mean_lead_time.should be_within_six_sigma_of(5.364425222994782)
+    end
+
+    it 'should produce the relative anomaly delta' do
+      @hohmann.relative_anomaly_delta.should be_within_six_sigma_of(-5.497787143782138)
+    end
+
+  end
+
+  describe "Descending Hohmann" do
+
+    before(:all) do
+      # Set all the testable data with hard-set values.
+      @initial = {:mean_velocity => 8.0, :semimajor_axis => 64.0}
+      @final = {:mean_velocity => 16.0, :semimajor_axis => 16.0}
+      @transfer = {:periapsis => 16.0, :periapsis_velocity => 20.2385770251, :apoapsis => 64.0, :apoapsis_velocity => 5.05964425627}
+      @time = 12.41823533225
+      @delta_vs = [-2.94035574373, -4.23857702508]
+      @delta_v = 7.178932768808223
+
+      # Build the test transfer object up from basic pieces.
+      # TODO: Stub these classes to make a truly independent class.
+      @planetoid = KerbalDyn::Planetoid.new('Gallifrey', :gravitational_parameter => 2.0**12, :radius => 2.0)
+      @initial_orbit = KerbalDyn::Orbit.new(@planetoid, :radius => @initial[:semimajor_axis])
+      @final_orbit = KerbalDyn::Orbit.new(@planetoid, :radius => @final[:semimajor_axis])
+      @hohmann = KerbalDyn::OrbitalManeuver::Hohmann.new(@initial_orbit, @final_orbit)
+    end
+
+    it 'should produce the transfer orbit' do
+      transfer_orbit = @hohmann.transfer_orbit
+      @transfer.each {|k,v| transfer_orbit.send(k).should be_within_six_sigma_of(v)}
+    end
+
+    it 'should produce the list of orbits' do
+      orbits = @hohmann.orbits
+
+      orbits.length.should == 3
+      orbits[0].should == @hohmann.initial_orbit
+      orbits[1].should == @hohmann.transfer_orbit
+      orbits[2].should == @hohmann.final_orbit
+    end
+
+    it 'should produce the list of burn events' do
+      burn_events = @hohmann.burn_events
+
+      burn_events.length.should == 2
+
+      burn_events.first.tap do |be|
+        be.initial_velocity.should be_within_six_sigma_of( @initial[:mean_velocity] )
+        be.final_velocity.should be_within_six_sigma_of( @transfer[:apoapsis_velocity] )
+        be.orbital_radius.should be_within_six_sigma_of( @initial[:semimajor_axis] )
+        be.time.should be_within(1e-9).of(0.0)
+        be.mean_anomaly.should be_within(1e-9).of(0.0)
+      end
+
+      burn_events.last.tap do |be|
+        be.initial_velocity.should be_within_six_sigma_of( @transfer[:periapsis_velocity] )
+        be.final_velocity.should be_within_six_sigma_of( @final[:mean_velocity] )
+        be.orbital_radius.should be_within_six_sigma_of( @final[:semimajor_axis] )
+        be.time.should be_within_six_sigma_of(@time)
+        be.mean_anomaly.should be_within_six_sigma_of(Math::PI)
+      end
+    end
+
+    it 'should know if it is moving ot a higher orbit' do
+      @hohmann.moving_to_higher_orbit?.should be_false
+    end
+
+    it 'should produce the list of delta velocities' do
+      @hohmann.delta_velocities.zip(@delta_vs).each do |actual, expected|
+        actual.should be_within_six_sigma_of(expected)
+      end
+    end
+
+    it 'should produce the final delta velocity' do
+      @hohmann.delta_velocity.should >= 0.0
+      @hohmann.delta_velocity.should be_within_six_sigma_of(@delta_v)
+      @hohmann.delta_v.should == @hohmann.delta_velocity
+    end
+
+  end
+
+  describe "Earth lower-to-higher orbit" do
+
+    before(:all, &BeforeFactory.earth)
+
+    before(:all) do
+      # The starting circ orbit.
+      @r1 = 6678e3
+      @v1 = 7.73e3
+
+      # The final circ orbit.
+      @r2 = 42164e3
+      @v2 = 3.07e3
+
+      # The transfer orbit apoapsis and periapsis velocities
+      @vp = 10.15e3
+      @va =  1.61e3
+
+      # The deltas
+      @dv1 =  2.42e3
+      @dv2 =  1.46e3
+      @dv  =  3.88e3
+
+
+      @orbit1 = KerbalDyn::Orbit.new(@planetoid, :semimajor_axis => @r1, :eccentricity => 0.0)
+      @orbit2 = KerbalDyn::Orbit.new(@planetoid, :semimajor_axis => @r2, :eccentricity => 0.0)
+
+      @hohmann = KerbalDyn::OrbitalManeuver::Hohmann.new(@orbit1, @orbit2)
+    end
+
+    it 'should calculate burn one from velocity' do
+      @hohmann.initial_orbit.apoapsis_velocity.should be_within_two_sigma_of(@v1)
+      @hohmann.velocities[0][0].should be_within_two_sigma_of(@v1)
+    end
+
+    it 'should calculate burn one to velocity' do
+      @hohmann.transfer_orbit.periapsis_velocity.should be_within_two_sigma_of(@vp)
+      @hohmann.velocities[0][1].should be_within_two_sigma_of(@vp)
+    end
+
+    it 'should calculate burn two from velocity' do
+      @hohmann.transfer_orbit.apoapsis_velocity.should be_within_two_sigma_of(@va)
+      @hohmann.velocities[1][0].should be_within_two_sigma_of(@va)
+    end
+
+    it 'should calculate burn two to velocity' do
+      @hohmann.final_orbit.apoapsis_velocity.should be_within_two_sigma_of(@v2)
+      @hohmann.velocities[1][1].should be_within_two_sigma_of(@v2)
+    end
+
+    it 'should calculate burn one delta velocity' do
+      @hohmann.delta_velocities[0].should be_within_two_sigma_of(@dv1)
+    end
+
+    it 'should calculate burn two delta velocity' do
+      @hohmann.delta_velocities[1].should be_within_two_sigma_of(@dv2)
+    end
+
+    it 'should calculate total delta velocity' do
+      @hohmann.delta_v.should be_within_two_sigma_of(@dv)
+    end
+
+    it 'should calculate the lead angle for intercept' do
+      # Value calculated several times, several different ways to cross-check
+      @hohmann.mean_lead_angle.should be_within_two_sigma_of(1.756)
+    end
+
+    it 'should calculate the lead time for intercept' do
+      # Value calculated
+      @hohmann.mean_lead_time.should be_within_two_sigma_of(4175.58)
+    end
+
+    it 'should calculate the realtive anomaly change per complete orbit' do
+      delta_theta = -5.887 #separation change per complete rotation ofinitial orbit as compared to something in the final orbit; negative since the lower orbit should close the gap.
+      @hohmann.relative_anomaly_delta.should be_within_two_sigma_of(delta_theta)
+    end
+
+    it 'should recognize as a move to a lower orbit' do
+      @hohmann.moving_to_higher_orbit?.should be_true
+    end
+
+  end
+
+  describe "Earth higher-to-lower orbit" do
+
+    before(:all, &BeforeFactory.earth)
+
+    before(:all) do
+      # The final circ orbit.
+      @r1 = 42164e3
+      @v1 = 3.07e3
+
+      # The starting circ orbit.
+      @r2 = 6678e3
+      @v2 = 7.73e3
+
+      # The transfer orbit apoapsis and periapsis velocities
+      @vp = 10.15e3
+      @va =  1.61e3
+
+      # The deltas
+      @dv1 =  -1.46e3
+      @dv2 =  -2.42e3
+      @dv  =  3.88e3
+
+
+      @orbit1 = KerbalDyn::Orbit.new(@planetoid, :semimajor_axis => @r1, :eccentricity => 0.0)
+      @orbit2 = KerbalDyn::Orbit.new(@planetoid, :semimajor_axis => @r2, :eccentricity => 0.0)
+
+      @hohmann = KerbalDyn::OrbitalManeuver::Hohmann.new(@orbit1, @orbit2)
+    end
+
+    it 'should calculate burn one from velocity' do
+      @hohmann.initial_orbit.apoapsis_velocity.should be_within_two_sigma_of(@v1)
+      @hohmann.velocities[0][0].should be_within_two_sigma_of(@v1)
+    end
+
+    it 'should calculate burn one to velocity' do
+      @hohmann.transfer_orbit.apoapsis_velocity.should be_within_two_sigma_of(@va)
+      @hohmann.velocities[0][1].should be_within_two_sigma_of(@va)
+    end
+
+    it 'should calculate burn two from velocity' do
+      @hohmann.transfer_orbit.periapsis_velocity.should be_within_two_sigma_of(@vp)
+      @hohmann.velocities[1][0].should be_within_two_sigma_of(@vp)
+    end
+
+    it 'should calculate burn two to velocity' do
+      @hohmann.final_orbit.apoapsis_velocity.should be_within_two_sigma_of(@v2)
+      @hohmann.velocities[1][1].should be_within_two_sigma_of(@v2)
+    end
+
+    it 'should calculate burn one delta velocity' do
+      @hohmann.delta_velocities[0].should be_within_two_sigma_of(@dv1)
+    end
+
+    it 'should calculate burn two delta velocity' do
+      @hohmann.delta_velocities[1].should be_within_two_sigma_of(@dv2)
+    end
+
+    it 'should calculate total delta velocity' do
+      @hohmann.delta_v.should be_within_two_sigma_of(@dv)
+    end
+
+    it 'should calculate the lead angle for intercept' do
+      # Value calculated several times, several different ways to cross-check
+      # This is a large negative number because the lower orbit gets nearly 3.5 periods in during the transfer, which is nearly 22 radians.
+      @hohmann.mean_lead_angle.should be_within_two_sigma_of(-18.83)
+    end
+
+    it 'should calculate the lead time for intercept' do
+      # The lead angle, -18.828, is so insanely close to three times around the circle, that about 20s is actually the lead time!
+      @hohmann.mean_lead_time.should be_within_two_sigma_of(19.73)
+    end
+
+    it 'should calculate the realtive anomaly change per complete orbit' do
+      # This is large because the inner planet gets nearly 16 loops (nearly 100 radians) in for each of the slow orbit's
+      delta_theta = 93.40
+      @hohmann.relative_anomaly_delta.should be_within_two_sigma_of(delta_theta)
+    end
+
+    it 'should recognize as a move to a lower orbit' do
+      @hohmann.moving_to_higher_orbit?.should be_false
+    end
+
+  end
+
+  describe 'Null transition' do
+    before(:all, &BeforeFactory.earth)
+
+    before(:all) do
+      @orbit1 = KerbalDyn::Orbit.new(@planetoid, :semimajor_axis => 1000e3, :eccentricity => 0.0)
+      @orbit2 = KerbalDyn::Orbit.new(@planetoid, :semimajor_axis => 1000e3, :eccentricity => 0.0)
+      @hohmann = KerbalDyn::OrbitalManeuver::Hohmann.new(@orbit1, @orbit2)
+    end
+
+    it 'should have zero relative anomaly delta' do
+      @hohmann.relative_anomaly_delta.should be_within(1e-6).of(0.0)
+    end
+
+    it 'should have zero lead angle' do
+      @hohmann.mean_lead_angle.should be_within(1e-6).of(0.0)
+    end
+
+  end
+
+end