ballistics-ng 0.1.0.1

data/lib/ballistics/util.rb

@@ -0,0 +1,67 @@
+require 'bigdecimal'
+require 'bigdecimal/util'
+
+module Ballistics
+  # weight in grains
+  # velocity in ft / s
+  # acceleration in ft / s^2
+  # caliber in inches
+
+  GRAINS_PER_LB = 7000.to_d
+  G = 32.175.to_d            # gravitational acceleration
+
+  def self.lbs(grains)
+    grains.to_d / GRAINS_PER_LB
+  end
+
+  def self.grains(lbs)
+    lbs.to_d * GRAINS_PER_LB
+  end
+
+  def self.mass(weight)
+    weight.to_d / G
+  end
+
+  # Sectional density, according to the SpeerReloading Manual No. 13,
+  # is defined as: "A bullet's weight in pounds divided by the square of
+  # its diameter in inches." Note that SD is independent of a bullet's
+  # shape. All bullets of the same caliber and weight will have the same
+  # SD, regardless of their shape or composition.
+  #
+  def self.sectional_density(weight, caliber)
+    self.lbs(weight) / caliber.to_d ** 2
+  end
+
+  # 1/2 m v^2
+  #
+  def self.kinetic_energy(velocity, weight)
+    self.mass(self.lbs(weight)) * velocity.to_d ** 2 / 2
+  end
+
+  # http://www.chuckhawks.com/taylor_KO_factor.htm
+  # tl;dr don't use this
+  #
+  def self.taylor_ko(velocity, weight, caliber)
+    self.lbs(weight) * velocity.to_d * caliber.to_d
+  end
+
+  def self.recoil_impulse(proj_weight, charge_weight, proj_v, charge_v=4000)
+    self.mass(self.lbs(proj_weight.to_d * proj_v.to_d +
+                       charge_weight.to_d * charge_v.to_d))
+  end
+
+  def self.free_recoil(proj_weight, charge_weight,
+                       proj_v, gun_lbs, charge_v=4000)
+    self.recoil_impulse(proj_weight, charge_weight, proj_v, charge_v) /
+      self.mass(gun_lbs)
+  end
+
+  # 1/2 m(gun) * fr^2
+  #
+  def self.recoil_energy(proj_weight, charge_weight,
+                         proj_v, gun_lbs, charge_v=4000)
+    fr = self.free_recoil(proj_weight, charge_weight,
+                          proj_v, gun_lbs, charge_v)
+    self.mass(gun_lbs) * fr ** 2 / 2
+  end
+end

data/lib/ballistics/yaml.rb

@@ -0,0 +1,57 @@
+require 'yaml'
+
+# We don't depend on the Ballistics module, so it may not have been loaded yet
+module Ballistics; end
+
+module Ballistics::YAML
+  class UnknownType < RuntimeError; end
+  class TypeMismatch < RuntimeError; end
+  class LoadError < RuntimeError; end
+  class MandatoryFieldError; end
+
+  # Return a hash keyed by subdir with array values
+  # Array contains short names for the subdir's yaml files
+  # e.g. { 'cartridges' => ['300_blk'] }
+  #
+  BUILT_IN = {}
+  Dir[File.join(__dir__, '*')].each { |fn|
+    if File.directory? fn
+      yaml_files = Dir[File.join(fn, '*.yaml')]
+      if !yaml_files.empty?
+        BUILT_IN[File.basename fn] =
+          yaml_files.map { |y| File.basename(y, '.yaml') }
+      end
+    end
+  }
+
+  def self.load_built_in(dir, short_name)
+    files = BUILT_IN[dir] or raise(LoadError, "unknown dir: #{dir}")
+    filename = [short_name, 'yaml'].join('.')
+    if files.include?(short_name)
+      ::YAML.load_file(File.join(__dir__, dir, filename))
+    else
+      raise(LoadError, "unknown short name: #{short_name}")
+    end
+  end
+
+  def self.check_type?(val, type)
+    case type
+    when :string, :reference
+      val.is_a?(String)
+    when :float
+      val.is_a?(Numeric)
+    when :percent
+      val.is_a?(Numeric) and val >= 0 and val <= 1
+    when :count
+      val.is_a?(1.class) and val >= 0
+    when :int
+      val.is_a?(1.class)
+    else
+      raise UnknownType, type
+    end
+  end
+
+  def self.check_type!(val, type)
+    self.check_type?(val, type) or raise(TypeMismatch, [val, type].join(' '))
+  end
+end

data/test/atmosphere.rb

@@ -0,0 +1,26 @@
+require 'minitest/autorun'
+require 'ballistics/atmosphere'
+
+include Ballistics
+
+describe Atmosphere do
+  before do
+    @altitude = 5430
+    @humidity = 0.48
+    @pressure = 29.93
+    @temp = 40
+  end
+
+  it "translates a ballistic coefficient" do
+    Atmosphere.translate(0.338,
+                         altitude: @altitude,
+                         humidity: @humidity,
+                         pressure: @pressure,
+                         temp: @temp).round(3).must_equal 0.392
+
+    Atmosphere.new("altitude" => @altitude,
+                   "humidity" => @humidity,
+                   "pressure" => @pressure,
+                   "temp" => @temp).translate(0.338).round(3).must_equal 0.392
+  end
+end

data/test/ballistics.rb

@@ -0,0 +1,31 @@
+require 'minitest/autorun'
+require 'ballistics'
+
+describe Ballistics do
+  it "calculates the expected zero angle" do
+    opts = {
+      drag_number: 1,
+      ballistic_coefficient: 0.5,
+      velocity: 1200,
+      sight_height: 1.6,
+      zero_range: 100,
+    }
+    Ballistics.zero_angle(opts).round(6).must_equal 0.227188
+  end
+
+  it "calculates the expected trajectory" do
+    opts = {
+      drag_number: 1,
+      ballistic_coefficient: 0.5,
+      velocity: 2250,
+      sight_height: 2.6,
+      zero_range: 50,
+      wind_speed: 10,
+      wind_angle: 90,
+      max_range: 1000,
+      interval: 25,
+      shooting_angle: 0,
+    }
+    Ballistics.trajectory(opts).must_be_kind_of Array
+  end
+end

data/test/cartridge.rb

@@ -0,0 +1,121 @@
+require 'minitest/autorun'
+require 'ballistics/cartridge'
+
+include Ballistics
+
+describe Cartridge do
+  before do
+    @test_data = {
+      "name" => "Test Cartridge",
+      "case" => "test case",
+      "projectile" => "test_projectile",
+      "20_inch_fps" => 2000,
+      "desc" => "Test Cartridge for test purposes",
+    }
+    @extra_data = {
+      "foo" => "bar",
+    }
+  end
+
+  describe "BARREL_LENGTH_REGEX" do
+    it "must match and extract barrel lengths" do
+      ["16_inch_fps", "1_inch_fps", "21_inch_fps"].each { |valid|
+        rgx = Cartridge::BARREL_LENGTH_REGEX
+        matches = rgx.match valid
+        matches.wont_be_nil
+        matches.captures.wont_be_empty
+      }
+    end
+  end
+
+  describe "new instance" do
+    before do
+      @cart = Cartridge.new(@test_data)
+      @cart_ex = Cartridge.new(@test_data.merge(@extra_data))
+    end
+
+    it "must raise with insufficient parameters" do
+      params = {}
+      proc { Cartridge.new params }.must_raise Exception
+      # Accumulate the mandatory fields in params
+      # Note, a field matching Cartridge::BARREL_LENGTH_REGEX is also mandatory
+      Cartridge::MANDATORY.keys.each { |mfield|
+        params[mfield] = @test_data[mfield]
+        proc { Cartridge.new params }.must_raise Exception
+      }
+      mv = { "15_inch_fps" => 15 }
+      proc { Cartridge.new mv }.must_raise Exception
+      Cartridge.new(params.merge(mv)).must_be_kind_of Cartridge
+    end
+
+    it "must have a name" do
+      @cart.name.wont_be_nil
+      @cart.name.must_equal @test_data["name"]
+    end
+
+    it "must have a case" do
+      @cart.case.wont_be_nil
+      @cart.case.must_equal @test_data["case"]
+    end
+
+    it "must have a projectile" do
+      @cart.projectile.wont_be_nil
+      @cart.projectile.must_equal @test_data["projectile"]
+    end
+
+    it "must have a muzzle velocity" do
+      mv = @cart.muzzle_velocity
+      mv.wont_be_nil
+      mv.must_be_kind_of Hash
+      mv.wont_be_empty
+      ["16", "20"].each { |barrel_length|
+        test_mv = @test_data[barrel_length]
+        if test_mv
+          mv[barrel_length].must_equal test_mv
+        else
+          mv[barrel_length].must_be_nil
+        end
+      }
+    end
+
+    it "must accept optional fields" do
+      Cartridge::OPTIONAL.keys.each { |k|
+        if @test_data.key? k
+          @cart.send(k).must_equal @test_data[k]
+        else
+          @cart.send(k).must_be_nil
+        end
+      }
+    end
+
+    it "must retain initializing data" do
+      @cart.yaml_data.must_equal @test_data
+      @cart_ex.yaml_data.must_equal @test_data.merge(@extra_data)
+    end
+
+    it "must retain extra data" do
+      @cart.extra.must_be_empty
+      @cart_ex.extra.wont_be_empty
+      @cart_ex.extra.must_equal @extra_data
+    end
+  end
+
+  describe "muzzle velocity" do
+    before do
+      # we need a valid case -- e.g. 300 BLK
+      @cart = Cartridge.new(@test_data.merge("case" => "300 BLK"))
+    end
+
+    it "must estimate an unknown muzzle velocity" do
+      # sanity checks
+      Cartridge::BURN_LENGTH[@cart.case].wont_be_nil
+      @test_data["20_inch_fps"].wont_be_nil
+      @test_data["19_inch_fps"].must_be_nil
+      @test_data["21_inch_fps"].must_be_nil
+
+      @cart.mv(20).must_equal @test_data["20_inch_fps"]
+      @cart.mv(20.9).must_equal @test_data["20_inch_fps"]
+      @cart.mv(19.1).must_equal @test_data["20_inch_fps"]
+    end
+  end
+end

data/test/gun.rb

@@ -0,0 +1,85 @@
+require 'minitest/autorun'
+require 'ballistics/gun'
+
+include Ballistics
+
+describe Gun do
+  before do
+    @test_data = {
+      "name" => "Test Gun",
+      "chamber" => "test chamber",
+      "barrel_length" => 16,
+      "sight_height" => 1.5,
+      "zero_range" => 100,
+    }
+
+    @extra_data = {
+      "foo" => "bar",
+    }
+  end
+
+  describe "new instance" do
+    before do
+      @gun = Gun.new(@test_data)
+      @gun_ex = Gun.new(@test_data.merge(@extra_data))
+    end
+
+    it "must have a name" do
+      @gun.name.wont_be_nil
+      @gun.name.must_equal @test_data["name"]
+    end
+
+    it "must have a chamber" do
+      @gun.chamber.wont_be_nil
+      @gun.chamber.must_equal @test_data["chamber"]
+    end
+
+    it "must have a barrel_length" do
+      @gun.barrel_length.wont_be_nil
+      @gun.barrel_length.must_equal @test_data["barrel_length"]
+    end
+
+    it "must have a sight_height" do
+      @gun.sight_height.wont_be_nil
+      @gun.sight_height.must_equal @test_data["sight_height"]
+    end
+
+    it "must accept optional fields" do
+      Gun::OPTIONAL.keys.each { |k|
+        if @test_data.key?(k)
+          @gun.send(k).must_equal @test_data[k]
+        else
+          @gun.send(k).must_be_nil
+        end
+      }
+    end
+
+    it "must retain initializing data" do
+      @gun.yaml_data.must_equal @test_data
+      @gun_ex.yaml_data.must_equal @test_data.merge(@extra_data)
+    end
+
+    it "must retain extra data" do
+      @gun.extra.must_be_empty
+      @gun_ex.extra.wont_be_empty
+      @gun_ex.extra.must_equal @extra_data
+    end
+  end
+
+  describe "cartridges" do
+    it "must recognize known cartridges" do
+      ["300 BLK"].each { |valid|
+        # sanity check
+        Gun::CHAMBER_CARTRIDGE.key?(valid).must_equal true
+        gun = Gun.new @test_data.merge("chamber" => valid)
+        gun.cartridges.must_be_kind_of Hash
+      }
+    end
+  end
+
+  it "must reject an unknown cartridge" do
+    invalid = { "chamber" => "501 Levis" }
+    gun = Gun.new @test_data.merge(invalid)
+    proc { gun.cartridges }.must_raise Gun::ChamberNotFound
+  end
+end

data/test/problem.rb

@@ -0,0 +1,137 @@
+require 'minitest/autorun'
+require 'ballistics/problem'
+
+include Ballistics
+
+describe Problem do
+  describe "enrich" do
+    it "tolerates empty input" do
+      hsh = Problem.new.enrich
+      hsh.wont_be_empty
+      hsh.must_equal Problem::DEFAULTS
+    end
+
+    it "infers projectile params" do
+      prj = Projectile.new("name" => "test proj",
+                           "cal" => 0.223,
+                           "grains" => 100,
+                           "g7" => 0.445)
+      hsh = Problem.new(projectile: prj).enrich
+      hsh.wont_be_empty
+      prj.params.each { |sym, val| hsh[sym].must_equal val }
+    end
+  end
+
+  describe "trajectory" do
+    @problem = Problem.new(atmosphere: Atmosphere.new("altitude" => 5430,
+                                                      "humidity" => 0.48,
+                                                      "pressure" => 29.93,
+                                                      "temp" => 40))
+    @opts = {
+      drag_number: 1,
+      ballistic_coefficient: 0.5,
+      velocity: 2850,
+      sight_height: 1.6,
+      wind_speed: 10,
+      wind_angle: 90,
+      zero_range: 200,
+      max_range: 1000,
+      interval: 25,
+    }
+
+    def self.trajectory
+      @trajectory ||= @problem.trajectory(@opts)
+    end
+
+    it "raises with insufficient params" do
+      proc { Problem.trajectory(drag_function: 'G1',
+                                drag_number: 1,
+                                ballistic_coefficient: 0.5,
+                                velocity: 2850) }.must_raise Exception
+    end
+
+    it "has the expected range" do
+      t = self.class.trajectory
+      Hash[2 => 50,
+           4 => 100,
+           8 => 200,
+           12 => 300,
+           16 => 400,
+           20 => 500,
+           40 => 1000,
+          ].each { |i, val|
+        t[i]['range'].must_equal val
+      }
+    end
+
+    it "has the expected path" do
+      t = self.class.trajectory
+      Hash[2 => 0.6,
+           4 => 1.6,
+           8 => 0,
+           12 => -7,
+           16 => -20.1,
+           20 => -40.1,
+           40 => -282.5,
+          ].each { |i, val|
+        t[i]['path'].round(1).must_equal val
+      }
+    end
+
+    it "has the expected velocity" do
+      t = self.class.trajectory
+      Hash[2 => 2769,
+           4 => 2691,
+           8 => 2538,
+           12 => 2390,
+           16 => 2246,
+           20 => 2108,
+           40 => 1500,
+          ].each { |i, val|
+        t[i]['velocity'].to_i.must_equal val
+      }
+    end
+
+    it "has the expected MOA correction" do
+      t = self.class.trajectory
+      Hash[2 => -1.1,
+           4 => -1.5,
+           8 => 0,
+           12 => 2.2,
+           16 => 4.8,
+           20 => 7.7,
+           40 => 27,
+          ].each { |i, val|
+        t[i]['moa_correction'].round(1).must_equal val
+      }
+    end
+
+    it "has the expected windage" do
+      t = self.class.trajectory
+      Hash[2 => 0.2,
+           4 => 0.6,
+           8 => 2.3,
+           12 => 5.2,
+           16 => 9.4,
+           20 => 15.2,
+           40 => 71.3,
+          ].each { |i, val|
+        t[i]['windage'].round(1).must_equal val
+      }
+    end
+
+    it "has the expected MOA correction for windage" do
+      t = self.class.trajectory
+      Hash[2 => 0.3,
+           4 => 0.5,
+           8 => 1.1,
+           12 => 1.6,
+           16 => 2.3,
+           20 => 2.9,
+           40 => 6.8,
+          ].each { |i, val|
+        t[i]['moa_windage'].round(1).must_equal val
+      }
+    end
+  end
+end