driving_physics 0.0.0.2

data/test/car.rb

@@ -0,0 +1,156 @@
+require 'minitest/autorun'
+require 'driving_physics/car'
+
+C = DrivingPhysics::Car
+
+describe C do
+  before do
+    @env = DrivingPhysics::Environment.new
+    @c = C.new(@env)
+  end
+
+  def get_moving
+    @c.controls.brake_pedal = 0.0
+    @c.controls.drive_pedal = 1.0
+    @c.add_fuel 10
+    50.times { @c.tick! }
+    expect(@c.condition.speed).must_be :>, 0.0
+  end
+
+
+  it "initializes" do
+    expect(@c).must_be_instance_of C
+  end
+
+  it "has a string representation" do
+    str = @c.to_s
+    expect(str).must_be_instance_of String
+    expect(str.length).must_be(:>, 5)
+  end
+
+  it "adds fuel and reports overflow" do
+    expect(@c.condition.fuel).must_equal 0.0
+    @c.add_fuel 10.0
+    expect(@c.condition.fuel).must_equal 10.0
+    overflow = @c.add_fuel @c.fuel_capacity
+    expect(@c.condition.fuel).must_equal @c.fuel_capacity
+    expect(overflow).must_equal 10.0
+  end
+
+  it "varies drive_force based on drive_pedal and available fuel" do
+    expect(@c.drive_force).must_equal 0.0  # no pedal
+    @c.controls.drive_pedal = 1.0
+    expect(@c.drive_force).must_equal 0.0  # no fuel
+    @c.add_fuel 10
+
+    expect(@c.drive_force).must_equal @c.max_drive_force  # vroom!
+  end
+
+  it "has a drive vector in direction of @dir" do
+    @c.add_fuel 10
+    @c.controls.drive_pedal = 1.0
+    dv = @c.drive_force_vector
+    expect(dv).must_be_instance_of Vector
+    dvn = dv.normalize
+    [0,1].each { |dim|
+      expect(dvn[dim]).must_be_within_epsilon @c.condition.dir[dim]
+    }
+  end
+
+  it "varies brake_force based on brake_pedal" do
+    expect(@c.brake_force).must_equal 0.0  # no pedal
+    @c.controls.brake_pedal = 1.0
+    expect(@c.brake_force).must_equal @c.max_brake_force
+  end
+
+  it "has a brake vector opposing movement or @dir" do
+    # hmm, no good way to go in reverse
+    # just test against forward movement for now
+    @c.controls.brake_pedal = 1.0
+    bv = @c.brake_force_vector
+    expect(bv).must_be_instance_of Vector
+    bvn = bv.normalize
+    [0,1].each { |dim|
+      expect(bvn[dim]).must_be_within_epsilon @c.condition.dir[dim] * -1
+    }
+
+    get_moving
+
+    @c.controls.drive_pedal = 0.0
+    @c.controls.brake_pedal = 1.0
+    bdir = @c.brake_force_vector.normalize
+    vdir = @c.condition.vel.normalize
+    [0,1].each { |dim|
+      expect(bdir[dim]).must_be_within_epsilon vdir[dim] * -1
+    }
+  end
+
+  it "tracks the mass of remaining fuel" do
+    expect(@c.fuel_mass).must_equal 0.0
+    @c.add_fuel 10
+    expect(@c.fuel_mass).must_be_within_epsilon 7.1
+  end
+
+  it "tracks total_mass including fuel and driver" do
+    expect(@c.total_mass).must_equal @c.mass + @c.driver_mass
+    @c.add_fuel 10
+    expect(@c.total_mass).must_equal @c.mass + @c.fuel_mass + @c.driver_mass
+  end
+
+  it "computes the total weight based on G" do
+    expect(@c.weight).must_be_within_epsilon 10535.0
+  end
+
+  it "computes resistance forces based on instance variables" do
+    air = @c.air_resistance
+    expect(air).must_be_kind_of Vector
+    expect(air.magnitude).must_equal 0.0
+
+    rot = @c.rotational_resistance
+    expect(rot).must_be_kind_of Vector
+    expect(rot.magnitude).must_equal 0.0
+
+    roll = @c.rolling_resistance
+    expect(roll).must_be_kind_of Vector
+    expect(roll.magnitude).must_be :>, 0
+  end
+
+  describe C::Condition do
+    before do
+      @cond = @c.condition
+    end
+
+    it "intializes" do
+      expect(@cond).must_be_kind_of C::Condition
+    end
+
+    it "has a string representation" do
+      str = @cond.to_s
+      expect(str).must_be_kind_of String
+      expect(str.length).must_be :>, 5
+    end
+
+    it "has a lateral direction clockwise from @dir" do
+      lat = @cond.lat_dir
+      expect(lat).must_be_kind_of Vector
+      expect(lat.magnitude).must_be_within_epsilon 1.0
+      expect(lat.independent?(@cond.dir)).must_equal true
+    end
+
+    it "has a movement_dir based on velocity, or @dir when stopped" do
+      md = @cond.movement_dir
+      expect(md).must_be_kind_of Vector
+      expect(md.magnitude).must_be_within_epsilon 1.0
+      expect(md).must_equal @cond.dir
+
+      get_moving
+      md = @cond.movement_dir
+      expect(md).must_be_kind_of Vector
+      expect(md.magnitude).must_be_within_epsilon 1.0
+      vd = @cond.vel.normalize
+      [0,1].each { |dim|
+        expect(md[dim]).must_be_within_epsilon vd[dim]
+      }
+    end
+  end
+end

data/test/driving_physics.rb

@@ -0,0 +1,29 @@
+require 'minitest/autorun'
+require 'driving_physics'
+
+describe DrivingPhysics do
+  it "displays elapsed ms in a friendly form" do
+    expect(DrivingPhysics.elapsed_display 12572358).must_equal "03:29:32.358"
+  end
+
+  it "calculates kph from m/s" do
+    expect(DrivingPhysics.kph 23.2).must_equal 83.52
+  end
+
+  describe "Scalar Physics" do
+    # these functions also work with vectors
+    it "uses F=ma to calculate acceleration given force and mass" do
+      expect(DrivingPhysics.acc 7000, 1000).must_equal 7.0
+    end
+
+    it "calculates a new velocity given acceleration" do
+      expect(DrivingPhysics.vel 0.0, 7.0).must_be_within_epsilon 0.007
+      expect(DrivingPhysics.vel 1.1, 7.1).must_be_within_epsilon 1.1071
+    end
+
+    it "calculates a new position given velocity" do
+      expect(DrivingPhysics.pos 0.0, 3.0).must_be_within_epsilon 0.003
+      expect(DrivingPhysics.pos 2.2, 3.5).must_be_within_epsilon 2.2035
+    end
+  end
+end

data/test/scalar_force.rb

@@ -0,0 +1,30 @@
+require 'minitest/autorun'
+require 'driving_physics/scalar_force'
+
+include DrivingPhysics
+
+describe ScalarForce do
+  # i.e. multiply this number times speed^2 to approximate drag force
+  it "calculates a reasonable drag constant" do
+    expect(ScalarForce.air_resistance 1).must_be_within_epsilon DRAG
+  end
+
+  # ROT_COF's value is from observing that rotational resistance
+  # matches air resistance at roughly 30 m/s in street cars
+  it "approximates a reasonable rotational resistance constant" do
+    expect(30 * ScalarForce.air_resistance(1)).must_be_within_epsilon ROT_COF
+  end
+
+  it "approximates a positive drag force" do
+    expect(ScalarForce.air_resistance 30).must_be_within_epsilon 383.13
+  end
+
+  it "approximates a positive rotational resistance force" do
+    expect(ScalarForce.rotational_resistance 30).must_be_within_epsilon 383.13
+  end
+
+  it "approximates a positive rolling resistance force" do
+    nf = 1000 * G
+    expect(ScalarForce.rolling_resistance nf).must_be_within_epsilon 98.0
+  end
+end

data/test/tire.rb

@@ -0,0 +1,125 @@
+require 'driving_physics/tire'
+require 'minitest/autorun'
+
+include DrivingPhysics
+
+describe Tire do
+  TP = Tire::TemperatureProfile
+
+  describe TP do
+    before do
+      @tp = TP.new
+    end
+
+    it "initializes with two same-sized arrays" do
+      expect(@tp).must_be_kind_of TP
+      expect(TP.new([0,1,2,3], [0,1.0,0.7,0.4])).wont_be_nil
+      expect { TP.new('', '') }.must_raise ArgumentError
+      expect { TP.new([]) }.must_raise ArgumentError
+      expect { TP.new([0], []) }.must_raise ArgumentError
+      expect { TP.new([], [0.0]) }.must_raise ArgumentError
+    end
+
+    it "determines a grip number from a temp number" do
+      { -500 => TP::MIN_GRIP,
+        -100 => 0.1,
+        -0.0001 => 0.1,
+        0.0 => 0.5
+      }.each { |temp, gf| expect(@tp.grip_factor(temp)).must_equal gf }
+    end
+
+    it "has a critical_temp above the temp for 100%" do
+      expect(@tp.critical_temp).must_be(:>, 90)
+      expect(@tp.critical_temp).must_equal 105
+    end
+
+    it "has a map that increases to 100% and decreases below 80%" do
+      expect {
+        TP.new([0,1,2,3,4], [0.0,0.1,0.2,0.3,0.4])
+      }.must_raise TP::Error
+
+      expect {
+        TP.new([0,1,2,3,4], [0.0, 1.0, 0.99, 0.98, 0.97])
+      }.must_raise TP::Error
+    end
+  end
+
+  before do
+    @t = Tire.new
+  end
+
+  it "initializes with default values without a block" do
+    expect(@t).must_be_kind_of Tire
+  end
+
+  it "accepts a block to initialize with custom values" do
+    t = Tire.new { |x|
+      x.tread_mm = 9999
+      x.g_factor = -0.1234
+    }
+
+    expect(t.tread_mm).must_equal 9999
+    expect(t.g_factor).must_equal(-0.1234)
+  end
+
+  it "knows when the tread is gone" do
+    expect(@t.tread_left?).must_equal true
+
+    @t.condition.tread_mm = 0.00001
+    expect(@t.tread_left?).must_equal true
+
+    @t.condition.tread_mm = 0.0
+    expect(@t.tread_left?).must_equal false
+  end
+
+  it "has 50% grip when down to the cords" do
+    expect(@t.tread_factor).must_equal 1.0
+
+    @t.condition.tread_mm = 0.0
+    expect(@t.tread_factor).must_be_within_epsilon 0.5
+  end
+
+  it "has less than 10% tread factor when the cords start to wear" do
+    expect(@t.tread_factor).must_equal 1.0
+
+    @t.condition.tread_mm = 5.0
+    expect(@t.tread_factor).must_equal 1.0
+
+    @t.condition.tread_mm = 0.0
+    expect(@t.tread_factor).must_be_within_epsilon 0.5
+
+    @t.condition.cords_mm = 0.9
+    expect(@t.tread_factor).must_be_within_epsilon 0.45
+  end
+
+  it "has decreasing heat cycle factor" do
+    expect(@t.condition.heat_cycles).must_equal 0
+    expect(@t.heat_cycle_factor).must_equal 1.0
+
+    @t.condition.heat_cycles = 20
+    expect(@t.heat_cycle_factor).must_be(:<, 1.0)
+  end
+
+  it "has a temp factor according to temperature profile" do
+    expect(@t.condition.temp_c).must_equal 25
+    expect(@t.temp_factor).must_equal 0.75
+
+    @t.condition.temp_c = 90
+    expect(@t.temp_factor).must_equal 1.0
+  end
+
+  it "incorporates temp, heat_cycles, and tread depth into available grip" do
+    @t.condition.temp_c = 60
+    expect(@t.temp_factor).must_be_within_epsilon 0.8
+
+    @t.condition.heat_cycles = 10
+    expect(@t.heat_cycle_factor).must_be_within_epsilon 0.96
+
+    @t.condition.tread_mm = 5.0
+    expect(@t.tread_factor).must_equal 1.0
+    expect(@t.max_g).must_be_within_epsilon 0.768
+
+    @t.condition.tread_mm = 0.0
+    expect(@t.max_g).must_be_within_epsilon 0.384
+  end
+end

data/test/vector_force.rb

@@ -0,0 +1,90 @@
+require 'minitest/autorun'
+require 'driving_physics/vector_force'
+
+include DrivingPhysics
+
+describe VectorForce do
+  before do
+    @drive_force = Vector[7000.0, 0.0]
+    @v = Vector[3.0, 0]
+    @mass = 1000
+    @weight = @mass * G
+  end
+
+  it "generates uniformly random numbers centered on zero" do
+    hsh = {}
+    110_000.times {
+      num = DrivingPhysics.random_centered_zero(5)
+      hsh[num] ||= 0
+      hsh[num] += 1
+    }
+    # note, this will fail occasionally due to chance
+    hsh.values.each { |count|
+      expect(count).must_be(:>=, 9000)
+      expect(count).must_be(:<=, 11000)
+    }
+  end
+
+  it "coerces magnitude=0 to magnitude=1" do
+    a = Array.new(999) { DrivingPhysics.random_centered_zero(0) }
+    expect(a.all? { |i| i == 0 }).must_equal false
+  end
+
+  it "generates a random unit vector" do
+    low_res = DrivingPhysics.random_unit_vector(2, resolution: 1)
+    if low_res[0] == 0.0
+      expect(low_res[1].abs).must_equal 1.0
+    elsif low_res[0].abs == 1.0
+      expect(low_res[1]).must_equal 0.0
+    elsif low_res[0].abs.round(3) == 0.707
+      expect(low_res[1].abs.round(3)) == 0.707
+    else
+      p low_res
+      raise "unexpected"
+    end
+
+    9.times {
+      high_res = DrivingPhysics.random_unit_vector(3, resolution: 9)
+      expect(high_res.magnitude).must_be_within_epsilon 1.0
+    }
+  end
+
+  it "calculates air resistance as the square of velocity" do
+    df = VectorForce.air_resistance(@v,
+                                    frontal_area: 3,
+                                    drag_cof: 0.1,
+                                    air_density: 0.5)
+
+    # double the velocity, drag force goes up by 4
+    df2 = VectorForce.air_resistance(@v * 2,
+                                     frontal_area: 3,
+                                     drag_cof: 0.1,
+                                     air_density: 0.5)
+
+    expect(df2).must_equal df * 4
+  end
+
+  it "calculates the rolling resistance as a function of the normal force" do
+    rr = VectorForce.rolling_resistance(@weight, dir: @v)
+
+    # double the normal force, rolling resistance goes up by 2 (linear)
+    rr2 = VectorForce.rolling_resistance(@weight * 2, dir: @v)
+
+    expect(rr2).must_equal rr * 2
+  end
+
+  it "calculates the rotational resistance as a function of velocity" do
+    rr = VectorForce.rotational_resistance(@v)
+    rr2 = VectorForce.rotational_resistance(@v * 2)
+    expect(rr2).must_equal rr * 2
+  end
+
+  it "sums resistance forces" do
+    rf = VectorForce.all_resistance(@v, dir: @v, nf_mag: @weight)
+    # opposite direction
+    expect(rf.normalize).must_equal(-1 * @v.normalize)
+
+    # smaller magnitude
+    expect(rf.magnitude).must_be(:<, @drive_force.magnitude)
+  end
+end

data/test/wheel.rb

@@ -0,0 +1,177 @@
+require 'minitest/autorun'
+require 'driving_physics/wheel'
+
+W = DrivingPhysics::Wheel
+
+describe W do
+  describe "Wheel.traction" do
+    it "calculates traction force from normal force and coeff of friction" do
+      scalar_nf = 9800 # N
+      cof = 1.1
+      scalar_t = W.traction(scalar_nf, cof)
+      expect(scalar_t).must_equal 10780.0
+
+      vector_nf = Vector[9800, 0]
+      vector_t = W.traction(vector_nf, cof)
+      expect(vector_t).must_equal Vector[10780.0, 0.0]
+    end
+  end
+
+  describe "Wheel.volume" do
+    it "calculates the volume (m^3) of disk given radius and width" do
+      cubic_m = W.volume(1.0, 1.0)
+      expect(cubic_m).must_equal Math::PI
+
+      cubic_m = W.volume(0.35, 0.2)
+      expect(cubic_m).must_be_within_epsilon 0.076969
+    end
+  end
+
+  describe "Wheel.volume_l" do
+    it "calculates the volume (L) of a disk given radius and width" do
+      liters = W.volume_l(1.0, 1.0)
+      expect(liters).must_equal Math::PI * 1000
+
+      liters = W.volume_l(0.35, 0.2)
+      expect(liters).must_be_within_epsilon 76.96902
+    end
+  end
+
+  describe "Wheel.density" do
+    it "calculates the density (kg/L) given mass and volume" do
+      expect(W.density(25.0, 25.0)).must_equal 1.0
+      expect(W.density(50.0, 25.0)).must_equal 2.0
+    end
+  end
+
+  describe "Wheel.mass" do
+    it "calculates the mass (kg) of a disk given radius, width, and density" do
+      expect(W.mass(0.35, 0.2, W::DENSITY)).must_be_within_epsilon 25.015
+    end
+  end
+
+  describe "Wheel.rotational_inertia" do
+    it "calculates rotational inertia for a disk given radius and mass" do
+      expect(W.rotational_inertia(0.35, 25.0)).must_be_within_epsilon 1.53125
+    end
+  end
+
+  describe "Wheel.alpha" do
+    it "calculates angular acceleration from torque and inertia" do
+      scalar_torque = 1000
+      inertia = W.rotational_inertia(0.35, 25.0)
+      expect(W.alpha scalar_torque, inertia).must_be_within_epsilon 653.061
+
+      vector_torque = Vector[0, 0, 1000]
+      vector_alpha = W.alpha vector_torque, inertia
+      expect(vector_alpha).must_be_instance_of Vector
+      expect(vector_alpha.size).must_equal 3
+      expect(vector_alpha[2]).must_be_within_epsilon 653.06
+    end
+  end
+
+  describe "Wheel.torque_vector" do
+    it "calculates a torque in the 3rd dimension given 2D force and radius" do
+      force = Vector[1000, 0]
+      radius = Vector[0, 5]
+      torque = W.torque_vector(force, radius)
+      expect(torque).must_be_instance_of Vector
+      expect(torque.size).must_equal 3
+      expect(torque[2]).must_be_within_epsilon 5000.0
+    end
+  end
+
+  describe "Wheel.force_vector" do
+    it "calculates a (3D) force given 3D torque and 2D radius" do
+      # let's invert the Wheel.torque_vector case from above:
+      torque = Vector[0, 0, 5000]
+      radius = Vector[0, 5]
+      force = W.force_vector(torque, radius)
+      expect(force).must_be_instance_of Vector
+      expect(force.size).must_equal 3
+      expect(force[0]).must_be_within_epsilon 1000.0
+
+      # now let's rotate the radius into the x-dimension
+      # right hand rule, positive torque means thumb into screen, clockwise
+      # negative-x radius means positive-y force
+      torque = Vector[0, 0, 500]
+      radius = Vector[-5, 0]
+      force = W.force_vector(torque, radius)
+      expect(force).must_be_instance_of Vector
+      expect(force.size).must_equal 3
+      expect(force[1]).must_be_within_epsilon 100.0
+    end
+  end
+
+  describe "instance methods" do
+    before do
+      @env = DrivingPhysics::Environment.new
+      @w = W.new(@env)
+    end
+
+    it "initializes" do
+      expect(@w).must_be_instance_of W
+      expect(@w.density).must_equal W::DENSITY # sanity check
+      expect(@w.mass).must_be_within_epsilon 25.01
+
+      with_mass = W.new(@env, mass: 99.01)
+      expect(with_mass.mass).must_equal 99.01
+      expect(with_mass.density).wont_equal W::DENSITY
+    end
+
+    it "has a string representation" do
+      str = @w.to_s
+      expect(str).must_be_instance_of String
+      expect(str.length).must_be(:>, 5)
+    end
+
+    it "loses radius as it wears" do
+      expect(@w.radius).must_equal 350.0
+      @w.wear!(50)
+      expect(@w.radius).must_equal 300.0
+    end
+
+    it "calculates mass from current radius" do
+      expect(@w.mass).must_be_within_epsilon 25.01
+      @w.wear!(50)
+      expect(@w.mass).must_be_within_epsilon 18.378
+    end
+
+    it "has volume" do
+      expect(@w.volume).must_be_within_epsilon 0.07697
+      expect(@w.volume_l).must_be_within_epsilon 76.96902
+    end
+
+    it "has inertia" do
+      expect(@w.rotational_inertia).must_be_within_epsilon 1.5321
+    end
+
+    it "has traction force based on normal force" do
+      scalar_nf = 9800
+      expect(@w.traction scalar_nf).must_equal 10780.0
+      expect(@w.traction scalar_nf, static: false).must_equal 6860.0
+
+      vector_nf = Vector[9800, 0]
+      expect(@w.traction vector_nf).must_equal Vector[10780.0, 0.0]
+      expect(@w.traction vector_nf, static: false).
+        must_equal Vector[6860.0, 0.0]
+    end
+
+    it "determines (e.g. thrust) force based on axle torque" do
+      expect(@w.force 1000).must_be_within_epsilon 2857.143
+      @w.wear! 50
+      expect(@w.force 1000).must_be_within_epsilon 3333.333
+    end
+
+    it "determines tractable torque" do
+      scalar_nf = 9800
+      expect(@w.tractable_torque scalar_nf).must_be_within_epsilon 3773.0
+      kin_tq = @w.tractable_torque scalar_nf, static: false
+      expect(kin_tq).must_be_within_epsilon 2401.0
+
+      # not sure about how torque vectors work, but the "math" "works":
+      vector_nf = Vector[9800, 0]
+      expect(@w.tractable_torque(vector_nf)[0]).must_be_within_epsilon 3773.0
+    end
+  end
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: driving_physics
+version: !ruby/object:Gem::Version
+  version: 0.0.0.2
+platform: ruby
+authors:
+- Rick Hull
+autorequire:
+bindir: bin
+cert_chain: []
+date: 1980-01-01 00:00:00.000000000 Z
+dependencies: []
+description: WIP
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- VERSION
+- demo/car.rb
+- demo/scalar_force.rb
+- demo/tire.rb
+- demo/vector_force.rb
+- demo/wheel.rb
+- driving_physics.gemspec
+- lib/driving_physics.rb
+- lib/driving_physics/car.rb
+- lib/driving_physics/environment.rb
+- lib/driving_physics/imperial.rb
+- lib/driving_physics/scalar_force.rb
+- lib/driving_physics/tire.rb
+- lib/driving_physics/vector_force.rb
+- lib/driving_physics/wheel.rb
+- test/car.rb
+- test/driving_physics.rb
+- test/scalar_force.rb
+- test/tire.rb
+- test/vector_force.rb
+- test/wheel.rb
+homepage: https://github.com/rickhull/driving_physics
+licenses:
+- LGPL-3.0
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: '2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.26
+signing_key:
+specification_version: 4
+summary: WIP
+test_files: []