kerbaldyn 0.7.0

data/lib/kerbaldyn/orbital_maneuver/bielliptic.rb

@@ -0,0 +1,61 @@
+module KerbalDyn
+  module OrbitalManeuver
+    class Bielliptic < Base
+
+      # A special 3-burn orbital maneuver between two circular orbits through
+      # the transfer_radius options.
+      #
+      # Note that all orbits are circularized before being used.
+      #
+      # The first burn moves from the initial orbit to the transfer radius,
+      # the second burn (at the transfer radius) moves the periapsis of the
+      # transfer orbit to the final orbit.  The thrid burn circularizes
+      # to the final orbit.
+      def initialize(initial_orbit, final_orbit, options={})
+        options = {:transfer_radius => final_orbit.semimajor_axis}.merge(options)
+        super(initial_orbit.circularize, final_orbit.circularize, options)
+      end
+
+      attr_accessor :transfer_radius
+      private :transfer_radius=
+
+      def initial_transfer_orbit
+        r1 = self.initial_orbit.periapsis
+        rt = self.transfer_radius
+        return Orbit.new(self.initial_orbit.primary_body, :periapsis => [r1,rt].min, :apoapsis => [r1,rt].max)
+      end
+
+      def final_transfer_orbit
+        r2 = self.final_orbit.periapsis
+        rt = self.transfer_radius
+        return Orbit.new(self.initial_orbit.primary_body, :periapsis => [r2,rt].min, :apoapsis => [r2,rt].max)
+      end
+
+      def orbits
+        return [self.initial_orbit, self.initial_transfer_orbit, self.final_transfer_orbit.second, self.final_orbit]
+      end
+
+      def burn_events
+        r1 = self.initial_orbit.periapsis
+        r2 = self.final_orbit.periapsis
+        rt = self.transfer_radius
+
+        ito = self.initial_transfer_orbit
+        v11, v12 = (rt >= r1) ? [ito.periapsis_velocity, ito.apoapsis_velocity] : [ito.apoapsis_velocity, ito.periapsis_velocity]
+
+        fto = self.final_transfer_orbit
+        v21, v22 = (rt < r2) ? [fto.periapsis_velocity, fto.apoapsis_velocity] : [fto.apoapsis_velocity, fto.periapsis_velocity]
+
+        t1 = self.initial_transfer_orbit.period / 2.0
+        t2 = self.final_transfer_orbit.period / 2.0
+
+        return [
+          BurnEvent.new(:initial_velocity => self.initial_orbit.mean_velocity, :final_velocity => v11, :time => 0.0, :orbital_radius => self.initial_orbit.semimajor_axis, :mean_anomaly => 0.0),
+          BurnEvent.new(:initial_velocity => v12, :final_velocity => v21, :time => t1, :orbital_radius => self.transfer_radius, :mean_anomaly => Math::PI),
+          BurnEvent.new(:initial_velocity => v22, :final_velocity => self.final_orbit.mean_velocity, :time => t1+t2, :mean_anomaly => 2.0 * Math::PI)
+        ]
+      end
+
+    end
+  end
+end

data/lib/kerbaldyn/orbital_maneuver/burn_event.rb

@@ -0,0 +1,57 @@
+module KerbalDyn
+  module OrbitalManeuver
+    # Encapsulates information about a burn event.
+    class BurnEvent
+      include Mixin::ParameterAttributes
+      include Mixin::OptionsProcessor
+
+      # Create a new burn event.
+      #
+      # The following parameters are expected to be given:
+      # [initial_velocity] The velocity before the burn.
+      # [final_velocity] The velocity after the burn.
+      # [time] The time of the burn.
+      # [orbital_radius] The orbital radius at the time of the burn.
+      # [mean_anomaly] The mean anomaly at the time of the burn.
+      #
+      # The following parameters are optional.
+      # [epoch] Used to offset the time.
+      def initialize(options={})
+        process_options(options, :epoch => 0.0)
+      end
+
+      # The velocity before burn.
+      attr_parameter :initial_velocity
+
+      # The velocity after the burn.
+      attr_parameter :final_velocity
+
+      # The time for the burn.
+      attr_parameter :time
+
+      # The epoch for when time is zero. (optional)
+      attr_parameter :epoch
+
+      # The orbital radius at the time of the burn.
+      attr_parameter :orbital_radius
+
+      # The mean anomaly at the time of the burn.
+      attr_parameter :mean_anomaly
+
+      # Returns the change in velocity for this maneuver.
+      #
+      # Note that the sign may be meaningful to the maneuver.  For example,
+      # a retrograde burn is usually negative.
+      def delta_velocity
+        return self.final_velocity - self.initial_velocity
+      end
+      alias_method :delta_v, :delta_velocity
+
+      # Gives the time of this event in epoch time if epoch was set.
+      def epoch_time
+        return time + epoch
+      end
+
+    end
+  end
+end

data/lib/kerbaldyn/orbital_maneuver/hohmann.rb

@@ -0,0 +1,48 @@
+module KerbalDyn
+  module OrbitalManeuver
+    # A special 2-burn orbital maneuver between two circular orbits.
+    #
+    # Note that all orbits are circulairzed before being used.
+    #
+    # The first burn moves the opposite side of the orbit to the radius of
+    # the destination orbit, and the second burn--done when reaching the destination
+    # radius--moves the opposite side (where you started) to circularize your
+    # orbit.
+    #
+    #--
+    # TODO: To facilitate elliptical orbits, assume coplanar/coaxial, and take options to use periapsis, semimajor_axis, or apoapsis for each orbit.
+    # TODO: ALWAYS use semimajor axis here, so that we can assume circular on lead angle and time; make another class for elliptics and eventually replace this as a subclass with default args.
+    #++
+    class Hohmann < Base
+
+      def initialize(initial_orbit, final_orbit, options={})
+        super(initial_orbit.circularize, final_orbit.circularize, options)
+      end
+
+      # The elliptical orbit used to transfer from the initial_orbit to the
+      # final_orbit.
+      def transfer_orbit
+        r1 = initial_orbit.periapsis
+        r2 = final_orbit.apoapsis
+        # TODO: It should be the Orbit's job to min/max periapsis and apoapsis, and then set angles appropriately.
+        return @transfer_orbit ||= Orbit.new(self.initial_orbit.primary_body, :periapsis => [r1,r2].min, :apoapsis => [r1,r2].max)
+      end
+
+      def orbits
+        return [self.initial_orbit, self.transfer_orbit, self.final_orbit]
+      end
+
+      def burn_events
+        vs = [self.transfer_orbit.periapsis_velocity, self.transfer_orbit.apoapsis_velocity]
+        vs.reverse! if( initial_orbit.semimajor_axis > final_orbit.semimajor_axis )
+        v1,v2 = vs
+
+        return [
+          BurnEvent.new(:initial_velocity => self.initial_orbit.mean_velocity, :final_velocity => v1, :time => 0.0, :orbital_radius => self.initial_orbit.semimajor_axis, :mean_anomaly => 0.0),
+          BurnEvent.new(:initial_velocity => v2, :final_velocity => self.final_orbit.mean_velocity, :time => self.transfer_orbit.period/2.0, :orbital_radius => self.final_orbit.semimajor_axis, :mean_anomaly => Math::PI)
+        ]
+      end
+
+    end
+  end
+end

data/lib/kerbaldyn/part.rb

@@ -0,0 +1,15 @@
+module KerbalDyn
+  module Part
+    CATEGORIES = {'Propulsion' => 0, 'Command & Control' => 1, 'Structural & Aerodynamic' => 2, 'Utility & Scientific' => 3, 'Decals' => 4, 'Crew' => 5}.freeze
+  end
+end
+
+
+require_relative 'part/mixin'
+
+require_relative 'part/base'
+require_relative 'part/generic'
+require_relative 'part/fuel_tank'
+require_relative 'part/liquid_fuel_engine'
+require_relative 'part/rcs_fuel_tank'
+require_relative 'part/solid_rocket'

data/lib/kerbaldyn/part/base.rb

@@ -0,0 +1,154 @@
+require 'pathname'
+require 'json'
+
+module KerbalDyn
+  module Part
+    # The base-class for all rocket parts.  Instances are always of another
+    # type, which is determined by the +module+ attribute.  For parts that
+    # don't have special implementations, the Generic part class is used.
+    class Base
+
+      # Load the part from a given part directory.  This will automatically
+      # instantiate the correct subclass.
+      def self.load_part(directory)
+        # Process the argument.
+        dir = Pathname.new(directory)
+        return nil unless dir.directory?
+
+        # Get a handle on the spec file.
+        spec_file = dir + 'part.cfg'
+        return nil unless spec_file.file?
+
+        # Initialize the attributes container.
+        attributes = {}
+        line_count = 0
+
+        # Parse the lines.
+        spec_file.read.each_line do |line|
+          line_count += 1
+          line.chomp!
+          line = line.encode('ASCII-8BIT', :invalid => :replace, :replace => '?') unless line.valid_encoding?
+
+          case line
+          when /^\s*$/
+            # Blank
+          when /^\s*\/\//
+            # Comments
+          when /^(.*)=(.*)/
+            key,value = line.split('=', 2).map {|s| s.strip}
+            attributes[key] = value
+          else
+            STDERR.puts "Unhandled line in #{spec_file.to_s}:#{line_count}: #{line.inspect}"
+          end
+        end
+
+        # Now instantiate the right kind of part.
+        return self.module_class(attributes['module']).new(attributes)
+      end
+
+      # Return the class to instantiate for a given +module+ attribute.
+      def self.module_class(module_name)
+        ref_mod = Module.nesting[1]
+        if( ref_mod.constants.include?(module_name.to_sym) )
+          return ref_mod.const_get(module_name.to_sym)
+        else
+          return ref_mod.const_get(:Generic)
+        end
+      end
+
+      # Initialize the part from the hash.  Note that this does NOT auto-select
+      # the subclass.
+      def initialize(attributes)
+        @attributes = attributes.dup
+      end
+
+      # Return the raw attributes hash.
+      #
+      # Generally speaking it is better to use to_hash to keep from accidentally
+      # altering the part by altering the attributes hash by reference.  That
+      # being said, this is provided for special/power use cases.
+      attr_reader :attributes
+
+      # Return the raw attribute value by string or symbol.
+      #
+      # It is generally preferrable to use the accessor method.
+      def [](attr)
+        return self.attributes[attr.to_s]
+      end
+
+      # Return a the part parameters as a hash.
+      #
+      # Currently this is implemented as a raw dump of the attributes hash,
+      # but in the future it is planned to convert numeric types appropriately.
+      def to_hash
+        return attributes.dup
+      end
+
+      # Returns a JSON encoded form of the to_hash result.
+      def to_json
+        return self.to_hash.to_json
+      end
+
+      def name
+        return self['name']
+      end
+
+      def title
+        return self['title']
+      end
+
+      def description
+        return self['description']
+      end
+
+      def category
+        return self['category'].to_i
+      end
+
+      def category_name
+        return CATEGORIES.invert[self.category]
+      end
+
+      def module
+        return self['module']
+      end
+
+      def module_class
+        return self.class.module_class(self.module)
+      end
+
+      def mass
+        return self['mass'].to_f
+      end
+
+      def maximum_drag
+        return self['maximum_drag'] && self['maximum_drag'].to_f
+      end
+
+      def drag
+        return self.maximum_drag
+      end
+
+      def minimum_drag
+        return self['minimum_drag'] && self['minimum_drag'].to_f
+      end
+
+      def max_temp
+        return self['maxTemp'].to_f
+      end
+
+      def crash_tolerance
+        return self['crashTolerance'].to_f
+      end
+
+      def impact_tolerance
+        return self.crash_tolerance
+      end
+
+      def cost
+        return self['cost'].to_i
+      end
+
+    end
+  end
+end

data/lib/kerbaldyn/part/fuel_tank.rb

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

data/lib/kerbaldyn/part/generic.rb

@@ -0,0 +1,10 @@
+module KerbalDyn
+  module Part
+    # Parts without specific subclasses are defined as being of type Generic.
+    #
+    # At this time Generic parts are functionally no different than Base part,
+    # however this is reserved to change in the future.
+    class Generic < Base
+    end
+  end
+end

data/lib/kerbaldyn/part/liquid_fuel_engine.rb

@@ -0,0 +1,69 @@
+module KerbalDyn
+  module Part
+    class LiquidFuelEngine < Base
+      # The surface gravity, as used for Isp calculations; this was determined experimentally.
+      IspSurfaceGravity = 9.8072
+
+      def max_thrust
+        return self['maxThrust'].to_f
+      end
+      alias_method :thrust, :max_thrust
+
+      def min_thrust
+        return self['minThrust'].to_f
+      end
+
+      def isp
+        return self['Isp'].to_f
+      end
+
+      def vac_isp
+        return self['vacIsp'].to_f
+      end
+
+      def heat_production
+        return self['heatProduction'].to_f
+      end
+
+      # Calculated mass fuel flow.
+      #
+      # To calculate the fuel flow in liters, one must multiply by 1000.0 and
+      # divide by the fuel tank density
+      def mass_flow_rate
+        return self.max_thrust / (self.isp * IspSurfaceGravity)
+      end
+
+      # Calculated mass fuel flow.
+      def vac_mass_flow_rate
+        return self.max_thrust / (self.vac_isp * IspSurfaceGravity)
+      end
+
+      # This is the volume-wise fuel flow.  Multiply by 1000.0 to get liters/s
+      # instead of m^3/s.
+      #
+      # It needs a fuel tank to calculate from, as fuel densities vary by
+      # tank.
+      def fuel_consumption(tank)
+        return self.mass_flow_rate / tank.fuel_density
+      end
+
+      # This is the volume-wise fuel flow.  Multiply by 1000.0 to get liters/s
+      # instead of m^3/s.
+      #
+      # It needs a fuel tank to calculate from, as fuel densities vary by
+      # tank.
+      def vac_fuel_consumption(tank)
+        return self.vac_mass_flow_rate / tank.fuel_density
+      end
+
+      def thrust_vectored?
+        return self['thrustVectoringCapable'].to_s.downcase == 'true'
+      end
+
+      def gimbal_range
+        return self['gimbal_range'].to_s
+      end
+
+    end
+  end
+end

data/lib/kerbaldyn/part/mixin.rb

@@ -0,0 +1 @@
+require_relative 'mixin/fuel_tank'

data/lib/kerbaldyn/part/mixin/fuel_tank.rb

@@ -0,0 +1,35 @@
+module KerbalDyn
+  module Part
+    module Mixin
+      module FuelTank
+
+        # Fuel capacity in m^3 to match mks requirement,
+        # even though the game seems to display liters.
+        #
+        # Note that 1 m^3 = 1000 liters
+        def fuel
+          return (self['fuel'] || self['internalFuel']).to_f / 1000.0
+        end
+        alias_method :internal_fuel, :fuel
+        alias_method :capacity, :fuel
+
+        def dry_mass
+          return self['dryMass'].to_f
+        end
+
+        # The mass of the fuel.
+        def fuel_mass
+          return self.mass - self.dry_mass
+        end
+
+        # Calculated density in kg/m^3.
+        #
+        # Note that 1 m^3 = 1000 liters
+        def fuel_density
+          return self.fuel_mass / self.capacity
+        end
+
+      end
+    end
+  end
+end