driving_physics 0.0.0.2 → 0.0.1.2

data/test/tire.rb

@@ -1,125 +1,181 @@
-require 'driving_physics/tire'
 require 'minitest/autorun'
+require 'driving_physics/tire'
 
-include DrivingPhysics
-
-describe Tire do
-  TP = Tire::TemperatureProfile
+T = DrivingPhysics::Tire
 
-  describe TP do
-    before do
-      @tp = TP.new
-    end
+describe T do
+  describe "Tire.traction" do
+    it "calculates traction force from normal force and coeff of friction" do
+      scalar_nf = 9800 # N
+      cof = 1.1
+      scalar_t = T.traction(scalar_nf, cof)
+      expect(scalar_t).must_equal 10780.0
 
-    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
+      vector_nf = Vector[9800, 0]
+      vector_t = T.traction(vector_nf, cof)
+      expect(vector_t).must_equal Vector[10780.0, 0.0]
     end
+  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
+  describe "Tire.volume" do
+    it "calculates the volume (m^3) of disk given radius and width" do
+      cubic_m = T.volume(1.0, 1.0)
+      expect(cubic_m).must_equal Math::PI
 
-    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
+      cubic_m = T.volume(0.35, 0.2)
+      expect(cubic_m).must_be_within_epsilon 0.076969
     end
+  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
+  describe "Tire.volume_l" do
+    it "calculates the volume (L) of a disk given radius and width" do
+      liters = T.volume_l(1.0, 1.0)
+      expect(liters).must_equal Math::PI * 1000
 
-      expect {
-        TP.new([0,1,2,3,4], [0.0, 1.0, 0.99, 0.98, 0.97])
-      }.must_raise TP::Error
+      liters = T.volume_l(0.35, 0.2)
+      expect(liters).must_be_within_epsilon 76.96902
     end
   end
 
-  before do
-    @t = Tire.new
+  describe "Tire.density" do
+    it "calculates the density (kg/L) given mass and volume" do
+      expect(T.density(25.0, 25.0)).must_equal 1.0
+      expect(T.density(50.0, 25.0)).must_equal 2.0
+    end
   end
 
-  it "initializes with default values without a block" do
-    expect(@t).must_be_kind_of Tire
+  describe "Tire.mass" do
+    it "calculates the mass (kg) of a disk given radius, width, and density" do
+      expect(T.mass(0.35, 0.2, T::DENSITY)).must_be_within_epsilon 25.015
+    end
   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)
+  describe "Tire.rotational_inertia" do
+    it "calculates rotational inertia for a disk given radius and mass" do
+      expect(T.rotational_inertia(0.35, 25.0)).must_be_within_epsilon 1.53125
+    end
   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
+  describe "Tire.alpha" do
+    it "calculates angular acceleration from torque and inertia" do
+      scalar_torque = 1000
+      inertia = T.rotational_inertia(0.35, 25.0)
+      expect(T.alpha scalar_torque, inertia).must_be_within_epsilon 653.061
+
+      vector_torque = Vector[0, 0, 1000]
+      vector_alpha = T.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
 
-  it "has 50% grip when down to the cords" do
-    expect(@t.tread_factor).must_equal 1.0
+  describe "Tire.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 = T.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
 
-    @t.condition.tread_mm = 0.0
-    expect(@t.tread_factor).must_be_within_epsilon 0.5
+  describe "Tire.force_vector" do
+    it "calculates a (3D) force given 3D torque and 2D radius" do
+      # let's invert the Tire.torque_vector case from above:
+      torque = Vector[0, 0, 5000]
+      radius = Vector[0, 5]
+      force = T.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 = T.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
 
-  it "has less than 10% tread factor when the cords start to wear" do
-    expect(@t.tread_factor).must_equal 1.0
+  describe "instance methods" do
+    before do
+      @env = DrivingPhysics::Environment.new
+      @tire = T.new(@env)
+    end
 
-    @t.condition.tread_mm = 5.0
-    expect(@t.tread_factor).must_equal 1.0
+    it "initializes" do
+      expect(@tire).must_be_instance_of T
+      expect(@tire.density).must_equal T::DENSITY # sanity check
+      expect(@tire.mass).must_be_within_epsilon 25.01
 
-    @t.condition.tread_mm = 0.0
-    expect(@t.tread_factor).must_be_within_epsilon 0.5
+      with_mass = T.new(@env) { |w|
+        w.mass = 99.01
+      }
+      expect(with_mass.mass).must_equal 99.01
+      expect(with_mass.density).wont_equal T::DENSITY
+    end
 
-    @t.condition.cords_mm = 0.9
-    expect(@t.tread_factor).must_be_within_epsilon 0.45
-  end
+    it "has a string representation" do
+      str = @tire.to_s
+      expect(str).must_be_instance_of String
+      expect(str.length).must_be(:>, 5)
+    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
+    it "loses radius as it wears" do
+      old_r = @tire.radius
+      wear_amt = 50/1000r
+      @tire.wear! wear_amt
+      expect(@tire.radius).must_equal old_r - wear_amt
+    end
 
-    @t.condition.heat_cycles = 20
-    expect(@t.heat_cycle_factor).must_be(:<, 1.0)
-  end
+    it "calculates mass from current radius" do
+      expect(@tire.mass).must_be_within_epsilon 25.01
+      @tire.wear!(50/1000r)
+      expect(@tire.mass).must_be_within_epsilon 18.378
+    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
+    it "has volume" do
+      expect(@tire.volume).must_be_within_epsilon 0.07697
+      expect(@tire.volume_l).must_be_within_epsilon 76.96902
+    end
 
-    @t.condition.temp_c = 90
-    expect(@t.temp_factor).must_equal 1.0
-  end
+    it "has inertia" do
+      expect(@tire.rotational_inertia).must_be_within_epsilon 1.5321
+    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
+    it "has traction force based on normal force" do
+      scalar_nf = 9800
+      expect(@tire.traction scalar_nf).must_equal 10780.0
+      expect(@tire.traction scalar_nf, static: false).must_equal 6860.0
 
-    @t.condition.heat_cycles = 10
-    expect(@t.heat_cycle_factor).must_be_within_epsilon 0.96
+      vector_nf = Vector[9800, 0]
+      expect(@tire.traction vector_nf).must_equal Vector[10780.0, 0.0]
+      expect(@tire.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(@tire.force 1000).must_be_within_epsilon 2857.143
+      @tire.wear! 50/1000r
+      expect(@tire.force 1000).must_be_within_epsilon 3333.333
+    end
 
-    @t.condition.tread_mm = 5.0
-    expect(@t.tread_factor).must_equal 1.0
-    expect(@t.max_g).must_be_within_epsilon 0.768
+    it "determines tractable torque" do
+      scalar_nf = 9800
+      expect(@tire.tractable_torque scalar_nf).must_be_within_epsilon 3773.0
+      kin_tq = @tire.tractable_torque scalar_nf, static: false
+      expect(kin_tq).must_be_within_epsilon 2401.0
 
-    @t.condition.tread_mm = 0.0
-    expect(@t.max_g).must_be_within_epsilon 0.384
+      # not sure about how torque vectors work, but the "math" "works":
+      vector_nf = Vector[9800, 0]
+      expect(@tire.tractable_torque(vector_nf)[0]).
+        must_be_within_epsilon 3773.0
+    end
   end
 end

data/test/vector_force.rb

@@ -74,9 +74,15 @@ describe VectorForce do
   end
 
   it "calculates the rotational resistance as a function of velocity" do
+    rr = VectorForce.rotational_resistance(@v, rot_const: 0)
+    rr2 = VectorForce.rotational_resistance(@v * 2, rot_const: 0)
+    expect(rr2).must_equal rr * 2
+
+    # now with rot_const != 0, the relationship is skewed
     rr = VectorForce.rotational_resistance(@v)
     rr2 = VectorForce.rotational_resistance(@v * 2)
-    expect(rr2).must_equal rr * 2
+    expect(rr2).wont_equal rr * 2   # because of rot_const
+    expect(rr2.magnitude).must_be(:<, (rr * 2).magnitude)
   end
 
   it "sums resistance forces" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: driving_physics
 version: !ruby/object:Gem::Version
-  version: 0.0.0.2
+  version: 0.0.1.2
 platform: ruby
 authors:
 - Rick Hull
@@ -20,25 +20,32 @@ files:
 - Rakefile
 - VERSION
 - demo/car.rb
+- demo/disk.rb
+- demo/gearbox.rb
+- demo/motor.rb
+- demo/powertrain.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/cli.rb
+- lib/driving_physics/disk.rb
 - lib/driving_physics/environment.rb
+- lib/driving_physics/gearbox.rb
 - lib/driving_physics/imperial.rb
+- lib/driving_physics/motor.rb
+- lib/driving_physics/power.rb
+- lib/driving_physics/powertrain.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/disk.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

data/demo/wheel.rb

@@ -1,84 +0,0 @@
-require 'driving_physics/wheel'
-
-include DrivingPhysics
-
-env = Environment.new
-wheel = Wheel.new(env, mass: 25.0)
-
-puts env
-puts wheel
-
-# 1000 kg car
-# 4 tires
-# 250 kg per tire plus tire mass
-
-supported_mass = 1000 # kg
-total_mass = supported_mass + 4 * wheel.mass
-corner_mass = Rational(total_mass) / 4
-normal_force = corner_mass * env.g
-axle_torque = 1000 # N*m
-friction_loss = 0.05 # 5% friction / hysteresis loss
-
-puts [format("Corner mass: %d kg", corner_mass),
-      format("Normal force: %.1f N", normal_force),
-      format("Axle torque: %d Nm", axle_torque),
-     ].join("\n")
-puts
-
-traction = wheel.traction(normal_force)
-drive_force = wheel.force(axle_torque)
-inertial_loss = wheel.inertial_loss(axle_torque, supported_mass)
-friction_loss *= axle_torque # 5% of the axle torque
-
-# drive force = (axle torque - inertia - friction) limited by traction
-
-net_axle_torque = axle_torque - inertial_loss - friction_loss
-net_drive_force = wheel.force(net_axle_torque)
-net_drive_force = traction if net_drive_force > traction  # traction limited
-
-acc = DrivingPhysics.acc(net_drive_force, supported_mass) # translational
-
-puts [format("Traction: %.1f N", traction),
-      format("Drive force: %.1f N", drive_force),
-      format("Inertial loss: %.1f Nm", inertial_loss),
-      format("Friction loss: %.1f Nm", friction_loss),
-      format("Net Axle Torque: %.1f Nm", net_axle_torque),
-      format("Net Drive Force: %.1f N", net_drive_force),
-      format("Acceleration: %.1f m/s/s", acc),
-      format("Alpha: %.2f r/s/s", acc / wheel.radius_m),
-     ].join("\n")
-puts
-
-duration = 100 # sec
-
-dist = 0.0  # meters
-speed = 0.0 # meters/s
-
-theta = 0.0 # radians
-omega = 0.0 # radians/s
-
-(duration * env.hz).times { |i|
-  # accumulate frictional losses with speed (omega)
-  omega_loss_cof = [wheel.omega_friction * omega, 1.0].min
-  slowed_acc = acc - acc * omega_loss_cof
-
-  # translational kinematics
-  speed += slowed_acc * env.tick
-  dist += speed * env.tick
-
-  # rotational kinematics
-  alpha = slowed_acc / wheel.radius_m
-  omega += alpha * env.tick
-  theta += omega * env.tick
-
-  if i < 10 or
-    (i < 10_000 and i%1000 == 0) or
-    (i % 10_000 == 0)
-    puts DrivingPhysics.elapsed_display(i)
-    puts format("Wheel: %.1f r  %.2f r/s  %.3f r/s^2", theta, omega, alpha)
-    puts format("  Car: %.1f m  %.2f m/s  %.3f m/s^2", dist, speed, slowed_acc)
-    puts format("Omega Frictional Loss: %.1f%%", omega_loss_cof * 100)
-    puts "Press [enter]"
-    gets
-  end
-}

data/lib/driving_physics/wheel.rb

@@ -1,191 +0,0 @@
-require 'driving_physics/environment'
-require 'driving_physics/vector_force'
-
-module DrivingPhysics
-  # Rotational complements to acc/vel/pos
-  # alpha - angular acceleration
-  # omega - angular velocity (radians / s)
-  # theta - radians
-
-  class Wheel
-    # Note, this is not the density of solid rubber.  This density
-    # yields a sensible mass for a wheel / tire combo at common radius
-    # and width, assuming a uniform density
-    # e.g. 25kg at 350mm R x 200mm W
-    #
-    DENSITY = 0.325  # kg / L
-
-    # * the traction force opposes the axle torque / drive force
-    #   thus, driving the car forward
-    # * if the drive force exceeds the traction force, slippage occurs
-    # * slippage reduces the available traction force further
-    # * if the drive force is not reduced, the slippage increases
-    #   until resistance forces equal the drive force
-    def self.traction(normal_force, cof)
-      normal_force * cof
-    end
-
-    def self.force(axle_torque, radius_m)
-      axle_torque / radius_m.to_f
-    end
-
-    # in m^3
-    def self.volume(radius_m, width_m)
-      Math::PI * radius_m ** 2 * width_m.to_f
-    end
-
-    # in L
-    def self.volume_l(radius_m, width_m)
-      volume(radius_m, width_m) * 1000
-    end
-
-    def self.density(mass, volume_l)
-      mass.to_f / volume_l
-    end
-
-    def self.mass(radius_m, width_m, density)
-      density * volume_l(radius_m, width_m)
-    end
-
-    # I = 1/2 (m)(r^2) for a disk
-    def self.rotational_inertia(radius_m, mass)
-      mass * radius_m**2 / 2.0
-    end
-    class << self
-      alias_method(:moment_of_inertia, :rotational_inertia)
-    end
-
-    # angular acceleration
-    def self.alpha(torque, inertia)
-      torque / inertia
-    end
-
-    def self.tangential(rotational, radius_m)
-      rotational * radius_m
-    end
-    class << self
-      alias_method(:tangential_a, :tangential)
-      alias_method(:tangential_v, :tangential)
-      alias_method(:tangential_p, :tangential)
-    end
-
-    # vectors only
-    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
-
-    # vectors only
-    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
-
-    attr_reader :env, :radius, :radius_m, :width, :width_m, :density, :temp,
-                :mu_s, :mu_k, :omega_friction
-
-    def initialize(env,
-                   radius: 350, width: 200, density: DENSITY,
-                   temp: nil, mass: nil,
-                   mu_s: 1.1, mu_k: 0.7,
-                   omega_friction: 0.002)
-      @env = env
-      @radius = radius.to_f # mm
-      @radius_m = @radius / 1000
-      @width  = width.to_f  # mm
-      @width_m = @width / 1000
-      @mu_s = mu_s.to_f # static friction
-      @mu_k = mu_k.to_f # kinetic friction
-      @omega_friction = omega_friction # scales with speed
-      @density = mass.nil? ? density : self.class.density(mass, volume_l)
-      @temp = temp.to_f || @env.air_temp
-    end
-
-    def to_s
-      [[format("%d mm (R) x %d mm (W)", @radius, @width),
-        format("Mass: %.1f kg %.3f kg/L", self.mass, @density),
-        format("cF: %.1f / %.1f", @mu_s, @mu_k),
-       ].join(" | "),
-       [format("Temp: %.1f C", @temp),
-       ].join(" | "),
-      ].join("\n")
-    end
-
-    def wear!(amount_mm)
-      @radius -= amount_mm
-      @radius_m = @radius / 1000
-    end
-
-    def heat!(amount_deg_c)
-      @temp += amount_deg_c
-    end
-
-    def mass
-      self.class.mass(@radius_m, @width_m, @density)
-    end
-
-    # in m^3
-    def volume
-      self.class.volume(@radius_m, @width_m)
-    end
-
-    # in L
-    def volume_l
-      self.class.volume_l(@radius_m, @width_m)
-    end
-
-    def rotational_inertia
-      self.class.rotational_inertia(@radius_m, self.mass)
-    end
-    alias_method(:moment_of_inertia, :rotational_inertia)
-
-    def traction(nf, static: true)
-      self.class.traction(nf, static ? @mu_s : @mu_k)
-    end
-
-    def force(axle_torque)
-      self.class.force(axle_torque, @radius_m)
-    end
-
-    # how much torque to accelerate rotational inertia at alpha
-    def inertial_torque(alpha)
-      alpha * self.rotational_inertia
-    end
-
-    # this doesn't take inertial losses or internal frictional losses
-    # into account.  input torque required to saturate traction will be
-    # higher than what this method returns
-    def tractable_torque(nf, static: true)
-      traction(nf, static: static) * @radius_m
-    end
-
-    # inertial loss in terms of axle torque when used as a drive wheel
-    def inertial_loss(axle_torque, total_driven_mass)
-      drive_force = self.force(axle_torque)
-      force_loss = 0
-      # The force loss depends on the acceleration, but the acceleration
-      # depends on the force loss.  Converge the value via 5 round trips.
-      # This is a rough way to compute an integral and should be accurate
-      # to 8+ digits.
-      5.times {
-        acc = DrivingPhysics.acc(drive_force - force_loss, total_driven_mass)
-        alpha = acc / @radius_m
-        force_loss = self.inertial_torque(alpha) / @radius_m
-      }
-      force_loss * @radius_m
-    end
-  end
-end