ballistics-ng 0.1.0.1

data/lib/ballistics.rb

@@ -0,0 +1,77 @@
+require 'ballistics/ext'
+
+module Ballistics
+  TABLE_FIELDS = {
+    range: {
+      label: "Range",
+      format: "%i",
+    },
+    time: {
+      label: "Time",
+      format: "%0.3f",
+    },
+    velocity: {
+      label: "FPS",
+      format: "%0.1f",
+    },
+    moa_correction: {
+      label: "MOA",
+      format: "%0.1f",
+    },
+    path: {
+      label: "Path",
+      format: "%0.1f",
+    },
+  }
+
+  def self.table(trajectory: nil, fields: nil, opts: {})
+    trajectory ||= self.trajectory(opts)
+    fields ||= [:range, :time, :velocity, :path]
+
+    # Create an array of field labels and format strings once
+    labels = []
+    formats = []
+    fields.each { |sym|
+      cfg = TABLE_FIELDS.fetch(sym)
+      labels << cfg.fetch(:label)
+      formats << cfg.fetch(:format)
+    }
+
+    # Iterate over trajectory structure and return a multiline string
+    labels.join("\t") + "\n" + trajectory.map { |hsh|
+      formats.join("\t") % fields.map { |sym| hsh.fetch(sym.to_s) }
+    }.join("\n")
+  end
+
+  def self.zero_angle(opts = {})
+    opts[:y_intercept] ||= 0
+    args = [
+      :drag_number,
+      :ballistic_coefficient,
+      :velocity,
+      :sight_height,
+      :zero_range,
+      :y_intercept,
+    ].map { |arg| opts.fetch(arg) }
+
+    Ballistics::Ext.zero_angle(*args)
+  end
+
+  def self.trajectory(opts = {})
+    opts[:zero_angle] ||= self.zero_angle(opts)
+    args = [
+      :drag_number,
+      :ballistic_coefficient,
+      :velocity,
+      :sight_height,
+      :shooting_angle,
+      :zero_angle,
+      :wind_speed,
+      :wind_angle,
+      :max_range,
+      :interval,
+    ].map { |arg| opts.fetch(arg) }
+
+    Ballistics::Ext.trajectory(*args)
+  end
+end

data/lib/ballistics/atmosphere.rb

@@ -0,0 +1,110 @@
+require 'bigdecimal'
+require 'bigdecimal/util'
+require 'ballistics/yaml'
+
+# http://www.exteriorballistics.com/ebexplained/4th/51.cfm
+
+class Ballistics::Atmosphere
+  MANDATORY = {
+    "altitude" => :float,   # feet
+    "humidity" => :percent, # float between 0 and 1
+    "pressure" => :float,   # inches of mercury
+    "temp"     => :float,   # degrees fahrenheit
+  }
+
+  # US Army standard, used by most commercial ammunition specs
+  ARMY = {
+    "altitude" => 0,
+    "humidity" => 0.78,
+    "pressure" => 29.5275,
+    "temp"     => 59,
+  }
+
+  # International Civil Aviation Organization
+  ICAO = {
+    "altitude" => 0,
+    "humidity" => 0,
+    "pressure" => 29.9213,
+    "temp"     => 59,
+  }
+
+  # altitude coefficients
+  ALTITUDE_A = -4e-15.to_d
+  ALTITUDE_B = 4e-10.to_d
+  ALTITUDE_C = -3e-5.to_d
+  ALTITUDE_D = 1.to_d
+
+  # humidity coefficients
+  VAPOR_A = 4e-6.to_d
+  VAPOR_B = -0.0004.to_d
+  VAPOR_C = 0.0234.to_d
+  VAPOR_D = -0.2517.to_d
+
+  DRY_AIR_INCREASE  = 0.3783.to_d
+  DRY_AIR_REDUCTION = 0.9950.to_d
+  RANKLINE_CORRECTION = 459.4.to_d
+  TEMP_ALTITUDE_CORRECTION = -0.0036.to_d # degrees per foot
+
+  def self.altitude_factor(altitude)
+    altitude = altitude.to_d
+    1 / (ALTITUDE_A * altitude ** 3 +
+         ALTITUDE_B * altitude ** 2 +
+         ALTITUDE_C * altitude      +
+         ALTITUDE_D)
+  end
+
+  def self.humidity_factor(temp, pressure, humidity)
+    vpw = VAPOR_A * temp ** 3 +
+          VAPOR_B * temp ** 2 +
+          VAPOR_C * temp      +
+          VAPOR_D
+    DRY_AIR_REDUCTION * pressure /
+      (pressure - DRY_AIR_INCREASE * humidity * vpw)
+  end
+
+  def self.pressure_factor(pressure)
+    pressure = pressure.to_d
+    (pressure - ARMY["pressure"]) / ARMY["pressure"]
+  end
+
+  def self.temp_factor(temp, altitude)
+    std_temp = ARMY["temp"] + altitude * TEMP_ALTITUDE_CORRECTION
+    (temp - std_temp) / (RANKLINE_CORRECTION + std_temp)
+  end
+
+  def self.translate(bc, altitude:, humidity:, pressure:, temp:)
+    bc.to_d *
+      self.altitude_factor(altitude) *
+      self.humidity_factor(temp, pressure, humidity) *
+      (self.temp_factor(temp, altitude) -
+       self.pressure_factor(pressure) + 1)
+  end
+
+  def self.icao
+    self.new ICAO
+  end
+
+  def self.army
+    self.new ARMY
+  end
+
+  attr_reader(*MANDATORY.keys)
+  attr_reader(:yaml_data, :extra)
+
+  def initialize(hsh = ARMY.dup)
+    @yaml_data = hsh
+    MANDATORY.each { |field, type|
+      val = hsh[field] || hsh[field.to_sym] or raise("#{field} not provided")
+      Ballistics::YAML.check_type!(val, type)
+      self.instance_variable_set("@#{field}", val.to_d)
+    }
+  end
+
+  def translate(ballistic_coefficient)
+    self.class.translate(ballistic_coefficient,
+                         altitude: @altitude,
+                         humidity: @humidity,
+                         pressure: @pressure,
+                         temp: @temp)
+  end
+end

data/lib/ballistics/cartridge.rb

@@ -0,0 +1,177 @@
+require 'ballistics/yaml'
+
+class Ballistics::Cartridge
+  MANDATORY = {
+    "name" => :string,
+    "case" => :string,
+    "projectile" => :reference,
+  }
+  OPTIONAL = {
+    "desc" => :string,
+    "powder_grains" => :float,
+    "powder_type" => :string,
+  }
+
+  # used to guesstimate muzzle velocities for unknown barrel lengths
+  BURN_LENGTH = {
+    '300 BLK' => 9,
+    '5.56' => 20,
+    '.223' => 20,
+    '.308' => 24,
+  }
+
+  # Load a built-in YAML file and instantiate cartridge objects
+  # Return a hash of cartridge objects keyed by the cartridge id as in the YAML
+  #
+  def self.find(short_name)
+    objects = {}
+    Ballistics::YAML.load_built_in('cartridges', short_name).each { |id, hsh|
+      obj = self.new(hsh)
+      if block_given?
+        objects[id] = obj if yield obj
+      else
+        objects[id] = obj
+      end
+    }
+    objects
+  end
+
+  # This is a helper method to perform loading of cartridges and projectiles
+  # and to perform the cross ref.  This works only with built in cartridge and
+  # projectile data.  To do this for user-supplied data files, the user should
+  # perform the cross_ref explicitly
+  #
+  def self.find_with_projectiles(chamber)
+    require 'ballistics/projectile'
+
+    cartridges = self.find(chamber)
+    projectiles = Ballistics::Projectile.find(chamber)
+    self.cross_ref(cartridges, projectiles)
+    cartridges
+  end
+
+  # A cartridge object starts with a string identifier for its projectile
+  # Given a hash of cartridge objects (keyed by cartridge id)
+  #   and a hash of projectile objects (keyed by projectile id)
+  # Set the cartridge's projectile to the projectile object identified
+  #   by the string value
+  # The cartridge objects in the cartridges hash are updated in place
+  # The return value reports what was updated
+  #
+  def self.cross_ref(cartridges, projectiles)
+    retval = {}
+    cartridges.values.each { |c|
+      if c.projectile.is_a?(String)
+        proj_id = c.projectile
+        proj = projectiles[proj_id]
+        if proj
+          c.projectile = proj
+          retval[:updated] ||= []
+          retval[:updated] << proj_id
+        else
+          warn "#{proj_id} not found in projectiles"
+        end
+      else
+        warn "c.projectile is not a string"
+      end
+    }
+    retval
+  end
+
+  # Given a single data point (barrel_length, muzzle_velocity)
+  #   and a known burn length
+  # Guess a muzzle velocity for an unknown length
+  #
+  def self.guess_mv(known_length, known_mv, burn_length, unknown_length)
+    inch_diff = known_length - unknown_length
+    known_bf = burn_length.to_f / known_length
+    unknown_bf = burn_length.to_f / unknown_length
+    # assume 1% FPS per inch; adjust for burn_length and take the average
+    fps_per_inch = known_mv * (known_bf + unknown_bf) / 2 / 100
+    known_mv - inch_diff * fps_per_inch
+  end
+
+  # Match and extract e.g. "16" from "16_inch_fps"
+  BARREL_LENGTH_REGEX = /([0-9]+)_inch_fps/i
+
+  attr_reader(*MANDATORY.keys)
+  attr_reader(*OPTIONAL.keys)
+  attr_reader :muzzle_velocity, :yaml_data, :extra
+  attr_writer :projectile
+
+  def initialize(hsh)
+    @yaml_data = hsh
+    MANDATORY.each { |field, type|
+      val = hsh.fetch(field)
+      Ballistics::YAML.check_type!(val, type)
+      self.instance_variable_set("@#{field}", val)
+    }
+
+    OPTIONAL.each { |field, type|
+      if hsh.key?(field)
+        val = hsh[field]
+        Ballistics::YAML.check_type!(val, type)
+        self.instance_variable_set("@#{field}", val)
+      end
+    }
+
+    # Keep track of fields that we don't expect
+    @extra = {}
+    (hsh.keys - MANDATORY.keys - OPTIONAL.keys).each { |k| @extra[k] = hsh[k] }
+
+    # Extract muzzle velocities per barrel length and remove from @extra
+    # We need at least one
+    #
+    @muzzle_velocity = {}
+    extracted = []
+    @extra.each { |key, val|
+      matches = key.match(BARREL_LENGTH_REGEX)
+      if matches
+        bl = matches[1].to_f.round
+        @muzzle_velocity[bl] = val
+        extracted << key
+      end
+    }
+    extracted.each { |k| @extra.delete(k) }
+    raise "no valid muzzle velocity" if @muzzle_velocity.empty?
+  end
+
+  # estimate muzzle velocity for a given barrel length
+  def mv(barrel_length, burn_length = nil)
+    [barrel_length, barrel_length.floor, barrel_length.ceil].each { |candidate|
+      mv = @muzzle_velocity[candidate]
+      return mv if mv
+    }
+    burn_length ||= BURN_LENGTH.fetch(@case)
+    known_lengths = @muzzle_velocity.keys
+
+    case known_lengths.length
+    when 0
+      raise "no muzzle velocities available"
+    when 1
+      known_length = known_lengths.first
+      self.class.guess_mv(known_length,
+                          @muzzle_velocity[known_length],
+                          burn_length,
+                          barrel_length)
+    else
+      # ok, now we need to interpolate if we can
+      raise "not implemented yet"
+    end
+  end
+
+  def multiline
+    lines = ["CARTRIDGE: #{@name}", "========="]
+    fields = {
+      "Case" => @case,
+    }
+    @muzzle_velocity.keys.sort.each { |bar_len|
+      fields["MV @ #{bar_len}"] = @muzzle_velocity[bar_len]
+    }
+    fields["Desc"] = @desc if @desc
+    fields.each { |name, val|
+      lines << [name.rjust(9, ' '), val].join(': ')
+    }
+    lines.join("\n")
+  end
+end

data/lib/ballistics/cartridges/300_blk.yaml

@@ -0,0 +1,159 @@
+# MANDATORY
+# $id:
+#   name:
+#   case:
+#   projectile: # ref to projectiles.yaml
+# AT LEAST ONE OF
+#   16_inch_fps:
+#   20_inch_fps:
+#   24_inch_fps:
+# OPTIONAL
+#   desc:
+#   powder_type:
+#   powder_grains:
+#   $n_inch_fps:
+
+# FLAT BASE PROJECTILES
+
+barnes_90_range_ar:
+  name: Barnes 300 BLK 90gr Range AR (90gr OTFB)
+  case: 300 BLK
+  projectile: barnes_90_otfb
+  16_inch_fps: 2550
+  desc: Target, training, competition
+
+barnes_110_vor_tx:
+  name: Barnes 300 BLK 110gr VOR-TX
+  case: 300 BLK
+  projectile: barnes_110_tac_tx_300_blk
+  16_inch_fps: 2350
+  10_inch_fps: 2180
+  desc: Hunting round for penetration and expansion
+
+hornady_110_v_max_black:
+  name: Hornady 300 BLK 110gr V-MAX BLACK
+  case: 300 BLK
+  projectile: hornady_110_v_max_black
+  16_inch_fps: 2375
+  10_inch_fps: 2250
+  desc: Varmint round for a black rifle
+
+hpr_110_tac_tx:
+  name: HPR 300 BLK 110gr TAC-TX
+  case: 300 BLK
+  projectile: barnes_110_tac_tx_300_blk
+  10_inch_fps: 2170
+  16_inch_fps: 2300
+  desc: Accurate and consistent load
+
+wilson_110_tac_tx:
+  name: Wilson Combat 300 BLK 110gr TAC-TX
+  case: 300 BLK
+  projectile: barnes_110_tac_tx_300_blk
+  10_inch_fps: 2240
+  16_inch_fps: 2400
+  desc: Fast, accurate, and consistent load
+
+remington_120_umc_otfb:
+  name: Remington 300 BLK 120gr UMC OTFB
+  case: 300 BLK
+  projectile: remington_120_umc_otfb
+  16_inch_fps: 2200
+  11_inch_fps: 2080
+  9_inch_fps: 2000
+  desc: Value ammo
+
+hornady_125_hp:
+  name: Hornady 300 BLK 125gr HP American Gunner
+  case: 300 BLK
+  projectile: hornady_125_hp_match
+  24_inch_fps: 2175
+  desc: Target, hunting, self defense
+
+remington_125_premier_mkfb:
+  name: Remington Premier Match 300 BLK 125gr MatchKing Flat Base
+  case: 300 BLK
+  projectile: sierra_125_mk
+  16_inch_fps: 2215
+  desc: Match ammo
+
+hornady_135_ftx:
+  name: Hornady 300 BLK 135gr FTX
+  case: 300 BLK
+  projectile: hornady_135_ftx
+  24_inch_fps: 2085
+  desc: Expanding round for hunting, personal defense
+
+hornady_208_a_max_black:
+  name: Hornady 300 BLK 208gr A-MAX BLACK
+  case: 300 BLK
+  projectile: hornady_208_a_max_black
+  16_inch_fps: 1020
+  10_inch_fps: 915
+  desc: Optimized for accuracy in a black rifle
+
+remington_220_umc_otfb:
+  name: Remington 300 BLK 220gr UMC OTFB
+  case: 300 BLK
+  projectile: remington_220_umc_otfb
+  16_inch_fps: 1050
+  10_inch_fps: 1005
+  desc: Value / training round
+
+remington_220_high_perf_otfb:
+  name: Remington 300 BLK 220gr High Performance OTFB
+  case: 300 BLK
+  projectile: remington_220_otfb
+  16_inch_fps: 1015
+  desc: Match style round
+
+# BOAT TAIL PROJECTILES
+
+hornady_110_gmx:
+  name: Hornady 300 BLK 110gr GMX Full Boar
+  case: 300 BLK
+  projectile: hornady_110_gmx
+  24_inch_fps: 2350
+  desc: Penetrating hunting round
+
+barnes_120_vor_tx:
+  name: Barnes 300 BLK 120gr VOR-TX
+  case: 300 BLK
+  projectile: barnes_120_tac_tx
+  16_inch_fps: 2150
+  desc: Hunting round for penetration and expansion
+
+remington_130_hog_hammer:
+  name: Remington 300 BLK 130gr Hog Hammer
+  case: 300 BLK
+  projectile: barnes_130_tsx
+  24_inch_fps: 2075
+  desc: Hog hunting round for penetration and expansion
+
+remington_130_htp:
+  name: Remington 300 BLK 130gr HTP
+  case: 300 BLK
+  projectile: barnes_130_tsx
+  16_inch_fps: 2075
+  desc: Hunting round for penetration and expansion
+
+remington_220_premier_mkbthp:
+  name: Remington 300 BLK 220gr Premier Match SMK
+  case: 300 BLK
+  projectile: sierra_220_hpbt_mk
+  16_inch_fps: 1015
+  desc: Match round
+
+silencerco_220_smk:
+  name: SilencerCo 300 BLK 220gr Sierra MatchKing
+  case: 300 BLK
+  projectile: sierra_220_hpbt_mk
+  16_inch_fps: 1030
+  desc: Match round
+
+wilson_220_smk:
+  name: Wilson 300 BLK 220gr Sierra MatchKing
+  case: 300 BLK
+  projectile: sierra_220_hpbt_mk
+  16_inch_fps: 1025
+  desc: Match round with factory new Remington 300 BLK case