driving_physics 0.0.1.2 → 0.0.3.1

data/lib/driving_physics/timer.rb

@@ -0,0 +1,34 @@
+module DrivingPhysics
+  module Timer
+    # don't use `defined?` with mruby
+    if (Process::CLOCK_MONOTONIC rescue false)
+      def self.now
+        Process.clock_gettime Process::CLOCK_MONOTONIC
+      end
+    else
+      def self.now
+        Time.now
+      end
+    end
+
+    def self.since(t)
+      self.now - t
+    end
+
+    def self.elapsed(&work)
+      t = self.now
+      return yield, self.since(t)
+    end
+
+    # HH:MM:SS.mmm
+    def self.display(seconds: 0, ms: 0)
+      ms += (seconds * 1000).round if seconds > 0
+      DrivingPhysics.elapsed_display(ms)
+    end
+
+    def self.summary(start, num_ticks, paused = 0)
+      elapsed = self.since(start) - paused
+      format("%.3f s (%d ticks/s)", elapsed, num_ticks.to_f / elapsed)
+    end
+  end
+end

data/lib/driving_physics/tire.rb

@@ -26,14 +26,14 @@ module DrivingPhysics
 
     def initialize(env)
       @env = env
-      @radius = 350/1000r # m
-      @width  = 200/1000r # m
+      @radius = 0.35
+      @width  = 0.2
       @density = DENSITY
       @temp = @env.air_temp
-      @mu_s = 11/10r # static friction
-      @mu_k =  7/10r # kinetic friction
-      @base_friction = 5/10_000r
-      @omega_friction = 5/100_000r # scales with speed
+      @mu_s = 1.1 # static friction
+      @mu_k = 0.7 # kinetic friction
+      @base_friction = 5.0/10_000
+      @omega_friction = 5.0/100_000
       @roll_cof = DrivingPhysics::ROLL_COF
 
       yield self if block_given?

data/lib/driving_physics/vector_force.rb

@@ -64,6 +64,29 @@ module DrivingPhysics
     dir
   end
 
+  def self.torque_vector(force, radius)
+    if !force.is_a?(Vector) or force.size != 2
+      raise(ArgumentError, "force must be a 2D vector")
+    end
+    if !radius.is_a?(Vector) or radius.size != 2
+      raise(ArgumentError, "radius must be a 2D vector")
+    end
+    force = Vector[force[0], force[1], 0]
+    radius = Vector[radius[0], radius[1], 0]
+    force.cross(radius)
+  end
+
+  def self.force_vector(torque, radius)
+    if !torque.is_a?(Vector) or torque.size != 3
+      raise(ArgumentError, "torque must be a 3D vector")
+    end
+    if !radius.is_a?(Vector) or radius.size != 2
+      raise(ArgumentError, "radius must be a 2D vector")
+    end
+    radius = Vector[radius[0], radius[1], 0]
+    radius.cross(torque) / radius.dot(radius)
+  end
+
   module VectorForce
     #
     # Resistance Forces

data/lib/driving_physics.rb

@@ -1,37 +1,36 @@
+#
+# Units: metric
+#
+# distance: meter
+# velocity: meter / sec
+# acceleration: meter / sec^2
+# volume: Liter
+# temperature: Celsius
+#
 module DrivingPhysics
-  #
-  # Units: metric
-  #
-  # distance: meter
-  # velocity: meter / sec
-  # acceleration: meter / sec^2
-  # volume: Liter
-  # temperature: Celsius
-  #
+  # runtime check; this returns false by default
+  # Vector is not currently/easily available in mruby
+  def self.has_vector?
+    Vector rescue false
+  end
 
-  #
   # environmental defaults
-  #
   HZ = 1000
   TICK = Rational(1) / HZ
   G = 9.8               # m/s^2
   AIR_TEMP = 25         # deg c
   AIR_DENSITY = 1.29    # kg / m^3
-  PETROL_DENSITY = 0.71 # kg / L   TODO: move to car.rb
+  PETROL_DENSITY = 0.71 # kg / L
 
-  #
   # defaults for resistance forces
-  #
-  FRONTAL_AREA = 2.2  # m^2, based roughly on 2000s-era Chevrolet Corvette
-  DRAG_COF = 0.3      # based roughly on 2000s-era Chevrolet Corvette
-  DRAG = 0.4257       # air_resistance at 1 m/s given above numbers
-  ROT_COF = 12.771    # if rotating resistance matches air resistance at 30 m/s
-  ROT_CONST = 0.05    # N opposing drive force / torque
-  ROLL_COF = 0.01     # roughly: street tires on concrete
+  FRONTAL_AREA =  2.2    # m^2, based roughly on 2000s-era Chevrolet Corvette
+  DRAG_COF     =  0.3    # based roughly on 2000s-era Chevrolet Corvette
+  DRAG         =  0.4257 # air_resistance at 1 m/s given above numbers
+  ROT_COF      = 12.771  # if rot matches air at 30 m/s
+  ROT_CONST    =  0.05   # N opposing drive force / torque
+  ROLL_COF     =  0.01   # roughly: street tires on concrete
 
-  #
   # constants
-  #
   SECS_PER_MIN = 60
   MINS_PER_HOUR = 60
   SECS_PER_HOUR = SECS_PER_MIN * MINS_PER_HOUR
@@ -70,4 +69,11 @@ module DrivingPhysics
     alias_method(:omega, :accum)
     alias_method(:theta, :accum)
   end
+
+  def self.unit_interval!(val)
+    if val < 0.0 or val > 1.0
+      raise(ArgumentError, "val #{val.inspect} should be between 0 and 1")
+    end
+    val
+  end
 end

data/test/disk.rb

@@ -1,113 +1,78 @@
 require 'minitest/autorun'
 require 'driving_physics/disk'
+require 'matrix'
 
-D = DrivingPhysics::Disk
+include DrivingPhysics
 
-describe D do
+describe Disk do
   describe "Disk.volume" do
     it "calculates the volume (m^3) of disk given radius and width" do
-      cubic_m = D.volume(1.0, 1.0)
+      cubic_m = Disk.volume(1.0, 1.0)
       expect(cubic_m).must_equal Math::PI
 
-      cubic_m = D.volume(0.35, 0.2)
+      cubic_m = Disk.volume(0.35, 0.2)
       expect(cubic_m).must_be_within_epsilon 0.076969
     end
   end
 
   describe "Disk.volume_l" do
     it "calculates the volume (L) of a disk given radius and width" do
-      liters = D.volume_l(1.0, 1.0)
+      liters = Disk.volume_l(1.0, 1.0)
       expect(liters).must_equal Math::PI * 1000
 
-      liters = D.volume_l(0.35, 0.2)
+      liters = Disk.volume_l(0.35, 0.2)
       expect(liters).must_be_within_epsilon 76.96902
     end
   end
 
   describe "Disk.density" do
     it "calculates the density (kg/L) given mass and volume" do
-      expect(D.density(25.0, 25.0)).must_equal 1.0
-      expect(D.density(50.0, 25.0)).must_equal 2.0
+      expect(Disk.density(25.0, 25.0)).must_equal 1.0
+      expect(Disk.density(50.0, 25.0)).must_equal 2.0
     end
   end
 
   describe "Disk.mass" do
     it "calculates the mass (kg) of a disk given radius, width, and density" do
-      skip
-      expect(D.mass(0.35, 0.2, D::DENSITY)).must_be_within_epsilon 25.015
+      expect(Disk.mass(0.35, 0.2, Disk::DENSITY)).must_be_within_epsilon 76.969
     end
   end
 
   describe "Disk.rotational_inertia" do
     it "calculates rotational inertia for a disk given radius and mass" do
-      expect(D.rotational_inertia(0.35, 25.0)).must_be_within_epsilon 1.53125
+      expect(Disk.rotational_inertia(0.35, 25.0)).must_be_within_epsilon 1.53125
     end
   end
 
   describe "Disk.alpha" do
     it "calculates angular acceleration from torque and inertia" do
       scalar_torque = 1000
-      inertia = D.rotational_inertia(0.35, 25.0)
-      expect(D.alpha scalar_torque, inertia).must_be_within_epsilon 653.061
+      inertia = Disk.rotational_inertia(0.35, 25.0)
+      expect(Disk.alpha scalar_torque, inertia).must_be_within_epsilon 653.061
 
+      skip unless DrivingPhysics.has_vector?
       vector_torque = Vector[0, 0, 1000]
-      vector_alpha = D.alpha vector_torque, inertia
+      vector_alpha = Disk.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 "Disk.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 = D.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 "Disk.force_vector" do
-    it "calculates a (3D) force given 3D torque and 2D radius" do
-      # let's invert the Disk.torque_vector case from above:
-      torque = Vector[0, 0, 5000]
-      radius = Vector[0, 5]
-      force = D.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 = D.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
-      @disk = D.new(@env)
+      @disk = Disk.new(@env)
     end
 
     it "initializes" do
-      skip
-      expect(@disk).must_be_instance_of D
-      expect(@disk.density).must_equal D::DENSITY # sanity check
-      expect(@disk.mass).must_be_within_epsilon 25.01
-
-      with_mass = D.new(@env) { |w|
-        w.mass = 99.01
-      }
+      expect(@disk).must_be_instance_of Disk
+      expect(@disk.density).must_equal Disk::DENSITY # sanity check
+      expect(@disk.mass).must_be_within_epsilon 76.969
+
+      with_mass = Disk.new(@env) { |w| w.mass = 99.01 }
       expect(with_mass.mass).must_equal 99.01
-      expect(with_mass.density).wont_equal D::DENSITY
+      expect(with_mass.density).wont_equal Disk::DENSITY
     end
 
     it "has a string representation" do
@@ -122,8 +87,7 @@ describe D do
     end
 
     it "has inertia" do
-      skip
-      expect(@disk.rotational_inertia).must_be_within_epsilon 1.5321
+      expect(@disk.rotational_inertia).must_be_within_epsilon 4.714
     end
   end
 end

data/test/gearbox.rb

@@ -0,0 +1,36 @@
+require 'minitest/autorun'
+require 'driving_physics/gearbox'
+
+include DrivingPhysics
+
+describe Gearbox do
+  it "has gear ratios" do
+  end
+
+  it "has a final drive" do
+  end
+
+  it "has a neutral gear" do
+  end
+
+  it "has a clutch with state" do
+  end
+
+  it "has mass" do
+  end
+
+  it "has rotating mass" do
+  end
+
+  it "converts crank torque to axle torque" do
+  end
+
+  it "has losses due to inertia and friction" do
+  end
+
+  it "converts crank omega to axle omega (and vice versa)" do
+  end
+
+  it "varies torque delivery based on gear ratio and clutch" do
+  end
+end

data/test/motor.rb

@@ -0,0 +1,236 @@
+require 'minitest/autorun'
+require 'driving_physics/motor'
+
+include DrivingPhysics
+
+describe "interpolate" do
+  it "validates xs and ys match in size" do
+    xs = [0, 5, 10, 15, 20]
+    ys = [10, 10, 10, 10, 5]
+    expect(DrivingPhysics.interpolate(1, xs: xs, ys: ys)).must_equal 10
+    expect { DrivingPhysics.interpolate(1, xs: xs + [10], ys: ys) }.must_raise
+    expect { DrivingPhysics.interpolate(1, xs: xs, ys: ys + [10]) }.must_raise
+  end
+
+  it "validates x is within the range of xs" do
+    xs = [0, 5, 10, 15, 20]
+    ys = [10, 10, 10, 10, 5]
+    expect(DrivingPhysics.interpolate(1, xs: xs, ys: ys)).must_equal 10
+    expect { DrivingPhysics.interpolate(-1, xs: xs, ys: ys) }.must_raise
+    expect { DrivingPhysics.interpolate(25, xs: xs, ys: ys) }.must_raise
+  end
+
+  it "validates the xs are in ascending order" do
+    xs = [0, 5, 10, 15, 20]
+    ys = [10, 10, 10, 10, 5]
+    expect(DrivingPhysics.interpolate(1, xs: xs, ys: ys)).must_equal 10
+    xs[1] = 15
+    expect {
+      DrivingPhysics.interpolate(16, xs: xs, ys: ys)
+    }.must_raise
+  end
+
+  it "performs linear interpolation to yield a y value for a valid x" do
+    xs = [0, 5, 10, 15, 20]
+    ys = [5, 5, 10, 10, 15]
+
+    expect(DrivingPhysics.interpolate(0, xs: xs, ys: ys)).must_equal 5
+    expect(DrivingPhysics.interpolate(1, xs: xs, ys: ys)).must_equal 5
+    expect(DrivingPhysics.interpolate(4, xs: xs, ys: ys)).must_equal 5
+    expect(DrivingPhysics.interpolate(5, xs: xs, ys: ys)).must_equal 5
+    expect(DrivingPhysics.interpolate(6, xs: xs, ys: ys)).must_equal 6
+    expect(DrivingPhysics.interpolate(7, xs: xs, ys: ys)).must_equal 7
+    expect(DrivingPhysics.interpolate(8, xs: xs, ys: ys)).must_equal 8
+    expect(DrivingPhysics.interpolate(9, xs: xs, ys: ys)).must_equal 9
+    expect(DrivingPhysics.interpolate(10, xs: xs, ys: ys)).must_equal 10
+    expect(DrivingPhysics.interpolate(11, xs: xs, ys: ys)).must_equal 10
+    expect(DrivingPhysics.interpolate(12, xs: xs, ys: ys)).must_equal 10
+    expect(DrivingPhysics.interpolate(14, xs: xs, ys: ys)).must_equal 10
+    expect(DrivingPhysics.interpolate(15, xs: xs, ys: ys)).must_equal 10
+    expect(DrivingPhysics.interpolate(16, xs: xs, ys: ys)).must_equal 11
+    expect(DrivingPhysics.interpolate(17, xs: xs, ys: ys)).must_equal 12
+    expect(DrivingPhysics.interpolate(18, xs: xs, ys: ys)).must_equal 13
+    expect(DrivingPhysics.interpolate(19, xs: xs, ys: ys)).must_equal 14
+    expect(DrivingPhysics.interpolate(20, xs: xs, ys: ys)).must_equal 15
+  end
+end
+
+# shorthand
+def tc(rpms, torques)
+  TorqueCurve.new(rpms: rpms, torques: torques)
+end
+
+describe TorqueCurve do
+  before do
+    @default = TorqueCurve.new
+    @rpms =    [500, 1000, 3500, 6000, 7000, 7100]
+    @torques = [  0,  100,  300,  300,  250,    0]
+    @minr = [0, 1]
+    @mint = [0, 0]
+  end
+
+  it "maps rpm values to torque values" do
+    expect(@default.torque(3500)).must_be(:>, 100)
+  end
+
+  describe "initialize" do
+    it "accepts two arrays: rpms, and the corresponding torques" do
+      expect(tc(@rpms, @torques)).must_be_kind_of(TorqueCurve)
+    end
+
+    it "has defaults for rpms and torques" do
+      expect(@default).must_be_kind_of(TorqueCurve)
+    end
+
+    it "validates size match for rpms and torques" do
+      expect(  tc(  @minr, @mint) ).must_be_kind_of TorqueCurve
+      expect { tc(    [0], @mint) }.must_raise
+      expect { tc([0,1,2], @mint) }.must_raise
+      expect { tc(@minr,     [0]) }.must_raise
+      expect { tc(@minr, [0,1,0]) }.must_raise
+
+      rpms = [100, 2000, 30_000]
+      torques = [0, 500, 0]
+
+      expect(  tc( rpms, torques) ).must_be_kind_of TorqueCurve
+      expect { tc( rpms,  [0, 0]) }.must_raise
+      expect { tc([1,2], torques) }.must_raise
+      expect { tc([1,2,3,4], torques) }.must_raise
+    end
+
+
+    describe "rpms" do
+      it "validates rpms are positive" do
+        expect(  tc(    @minr, @mint) ).must_be_kind_of TorqueCurve
+        expect { tc([-10, 10], @mint) }.must_raise
+      end
+
+      it "validates rpms are in ascending order" do
+        expect(  tc( @minr, @mint) ).must_be_kind_of TorqueCurve
+        expect { tc([0, 0], @mint) }.must_raise
+        expect(  tc([99, 100], @mint) ).must_be_kind_of TorqueCurve
+        expect { tc([100, 99], @mint) }.must_raise
+      end
+    end
+
+    describe "torques" do
+      it "validates that torques start and end at zero" do
+        expect(  tc(@minr, @mint) ).must_be_kind_of TorqueCurve
+        expect { tc(@minr, [1,0]) }.must_raise
+        expect { tc(@minr, [0,1]) }.must_raise
+        expect { tc(@minr, [1,1]) }.must_raise
+
+        expect(  tc([1,2,3], [0,500,0]) ).must_be_kind_of TorqueCurve
+        expect { tc([1,2,3], [1,500,0]) }.must_raise
+        expect { tc([1,2,3], [0,500,1]) }.must_raise
+      end
+
+      it "validates that torques are positive" do
+        expect(  tc([1,2,3], [0, 5,0]) ).must_be_kind_of TorqueCurve
+        expect { tc([1,2,3], [0,-5,0]) }.must_raise
+      end
+    end
+  end
+
+  it "finds the peak torque and corresponding RPM" do
+    rpm, torque = *@default.peak
+    expect(rpm).must_be(:>, 1000)
+    expect(rpm).must_be(:<, 10_000)
+    expect(torque).must_be(:>, 0)
+    expect(torque).must_be(:<, 10_000)
+  end
+
+  it "interpolates to find the torque for a valid RPM" do
+    tc = tc(@rpms, @torques)
+    r1 = @rpms[1]
+    r2 = @rpms[2]
+
+    expect(tc.torque(r1)).must_equal @torques[1]
+    expect(tc.torque(r2)).must_equal @torques[2]
+
+    r3 = (r1 + r2) / 2
+    t3 = tc.torque(r3)
+    t3_expect = (@torques[1] + @torques[2]) / 2.0
+
+    expect(t3).must_be :>, @torques[1]
+    expect(t3).must_be :<, @torques[2]
+    expect(t3).must_be :>=, t3_expect.floor
+    expect(t3).must_be :<=, t3_expect.ceil
+  end
+
+  it "tracks min, idle, redline, and max rpms" do
+    expect(@default.min).must_be :>, 0
+    expect(@default.min).must_be :<, 1000
+    expect(@default.idle).must_be :>, @default.min
+    expect(@default.idle).must_be :<, 3000
+    expect(@default.redline).must_be :>, @default.idle
+    expect(@default.redline).must_be :<, 20_000
+    expect(@default.max).must_be :>, @default.redline
+    expect(@default.max).must_be :<, 20_000
+  end
+end
+
+describe Motor do
+  before do
+    @default = Motor.new(Environment.new)
+  end
+
+  it "has a throttle with state" do
+    expect(@default.throttle).must_equal 0.0
+    @default.throttle = 0.5
+    expect(@default.throttle).must_equal 0.5
+    expect(@default.throttle_pct).must_equal "50.0%"
+
+    expect { @default.throttle = 1.5 }.must_raise
+  end
+
+  it "has mass" do
+    expect(@default.mass).must_be :>, 0
+    expect(@default.fixed_mass).must_be :>, 0
+    expect(@default.rotating_mass).must_be :>, 0
+  end
+
+  it "has a torque curve" do
+    expect(@default.torque_curve).must_be_kind_of TorqueCurve
+  end
+
+  it "has idle RPM and redline RPM" do
+    expect(@default.idle).must_be :>, 500
+    expect(@default.idle).must_be :<, 1500
+
+    expect(@default.redline).must_be :>, @default.idle
+    expect(@default.redline).must_be :<, 10_000
+  end
+
+  it "has inertia and energy" do
+    expect(@default.inertia).must_be :>, 0
+    expect(@default.energy(99)).must_be :>, 0
+  end
+
+  it "determines crank alpha from torque" do
+    expect(@default.alpha(50)).must_be :>, 0
+  end
+
+  it "determines torque from crank alpha" do
+    a = @default.alpha(50, omega: 20)
+    t = @default.implied_torque(a)
+    # frictional losses
+    expect(t).must_be :>, 40
+    expect(t).must_be :<, 50
+  end
+
+  it "determines torque based on torque curve, RPM and throttle" do
+    @default.throttle = 1.0
+    expect(@default.torque(1000)).must_be :>, 0
+    expect(@default.torque(3500)).must_be :>, @default.torque(1000)
+  end
+
+  it "has an engine braking effect when the throttle is closed" do
+    @default.throttle = 0
+    expect(@default.torque(3500)).must_be :<, 0
+  end
+
+  it "has a starter motor to get running" do
+    expect(@default.starter_torque).must_be :>, 0
+  end
+end

data/test/powertrain.rb

@@ -0,0 +1,21 @@
+require 'minitest/autorun'
+require 'driving_physics/powertrain'
+
+include DrivingPhysics
+
+describe Powertrain do
+  it "has a motor and a gearbox" do
+  end
+
+  it "has mass" do
+  end
+
+  it "coverts rpm to axle torque" do
+  end
+
+  it "converts rpm to axle omega" do
+  end
+
+  it "determines crank rpm from axle_omega" do
+  end
+end

data/test/scalar_force.rb

@@ -12,8 +12,7 @@ describe ScalarForce do
   # 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(-1 * ROT_COF)
+    _(30 * ScalarForce.air_resistance(1)).must_be_within_epsilon(-1 * ROT_COF)
   end
 
   it "approximates a positive drag force" do
@@ -21,12 +20,10 @@ describe ScalarForce do
   end
 
   it "approximates a positive rotational resistance force" do
-    expect(ScalarForce.rotational_resistance 30).
-      must_be_within_epsilon(-383.13)
+    _(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)
+    _(ScalarForce.rolling_resistance(1000 * G)).must_be_within_epsilon(-98.0)
   end
 end