driving_physics 0.0.0.3 → 0.0.2.1

data/lib/driving_physics/tire.rb

@@ -0,0 +1,120 @@
+require 'driving_physics/disk'
+
+module DrivingPhysics
+
+  # a Tire is a Disk with lighter density and meaningful surface friction
+
+  class Tire < Disk
+    # 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
+
+    attr_accessor :mu_s, :mu_k, :omega_friction, :base_friction, :roll_cof
+
+    def initialize(env)
+      @env = env
+      @radius = 0.35
+      @width  = 0.2
+      @density = DENSITY
+      @temp = @env.air_temp
+      @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?
+    end
+
+    def to_s
+      [[format("%d mm x %d mm (RxW)", @radius * 1000, @width * 1000),
+        format("%.1f kg  %.1f C", self.mass, @temp),
+        format("cF: %.1f / %.1f", @mu_s, @mu_k),
+       ].join(" | "),
+      ].join("\n")
+    end
+
+    def wear!(amount)
+      @radius -= amount
+    end
+
+    def heat!(amount_deg_c)
+      @temp += amount_deg_c
+    end
+
+    def traction(nf, static: true)
+      self.class.traction(nf, static ? @mu_s : @mu_k)
+    end
+
+    # require a normal_force to be be passed in
+    def rotating_friction(omega, normal_force:)
+      super(omega, normal_force: normal_force)
+    end
+
+    # rolling loss in terms of axle torque
+    def rolling_friction(omega, normal_force:)
+      return omega if omega.zero?
+      mag = omega.abs
+      sign = omega / mag
+      -1 * sign * (normal_force * @roll_cof) * @radius
+    end
+
+    # inertial loss in terms of axle torque when used as a drive wheel
+    def inertial_loss(axle_torque, 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, driven_mass)
+        alpha = acc / @radius
+        force_loss = self.implied_torque(alpha) / @radius
+      }
+      force_loss * @radius
+    end
+
+    def net_torque(axle_torque, mass:, omega:, normal_force:)
+      # friction forces oppose omega
+      net = axle_torque +
+            self.rolling_friction(omega, normal_force: normal_force) +
+            self.rotating_friction(omega, normal_force: normal_force)
+
+      # inertial loss has interdependencies; calculate last
+      # it opposes net torque, not omega
+      sign = net / net.abs
+      net - sign * self.inertial_loss(net, driven_mass: mass)
+    end
+
+    def net_tractable_torque(axle_torque,
+                             mass:, omega:, normal_force:, static: true)
+      net = self.net_torque(axle_torque,
+                            mass: mass,
+                            omega: omega,
+                            normal_force: normal_force)
+      tt = self.tractable_torque(normal_force, static: static)
+      net > tt ? tt : net
+    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
+    end
+  end
+end

data/lib/driving_physics/vector_force.rb

@@ -84,12 +84,25 @@ module DrivingPhysics
                             frontal_area: FRONTAL_AREA,
                             drag_cof: DRAG_COF,
                             air_density: AIR_DENSITY)
+      return velocity if velocity.zero?
       -1 * 0.5 * frontal_area * drag_cof * air_density *
        velocity * velocity.magnitude
     end
 
-    def self.rotational_resistance(velocity, rot_cof: ROT_COF)
-      -1 * velocity * rot_cof
+    # return a force opposing velocity, representing friction / hysteresis
+    def self.rotational_resistance(velocity,
+                                   rot_const: ROT_CONST,
+                                   rot_cof: ROT_COF)
+      return velocity if velocity.zero?
+      -1 * velocity * rot_cof + -1 * velocity.normalize * rot_const
+    end
+
+    # return a torque opposing omega, representing friction / hysteresis
+    def self.omega_resistance(omega,
+                              rot_const: ROT_TQ_CONST,
+                              rot_cof: ROT_TQ_COF)
+      return 0 if omega == 0.0
+      omega * ROT_TQ_COF + ROT_TQ_CONST
     end
 
     # dir is drive_force vector or velocity vector; will be normalized

data/lib/driving_physics.rb

@@ -26,6 +26,7 @@ module DrivingPhysics
   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
 
   #
@@ -35,6 +36,7 @@ module DrivingPhysics
   MINS_PER_HOUR = 60
   SECS_PER_HOUR = SECS_PER_MIN * MINS_PER_HOUR
 
+  # HH::MM::SS.mmm
   def self.elapsed_display(elapsed_ms)
     elapsed_s, ms = elapsed_ms.divmod 1000
 

data/test/disk.rb

@@ -0,0 +1,132 @@
+require 'minitest/autorun'
+require 'driving_physics/disk'
+
+D = DrivingPhysics::Disk
+
+describe D 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)
+      expect(cubic_m).must_equal Math::PI
+
+      cubic_m = D.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)
+      expect(liters).must_equal Math::PI * 1000
+
+      liters = D.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
+    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
+    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
+    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
+
+      skip # Vector
+      vector_torque = Vector[0, 0, 1000]
+      vector_alpha = D.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
+      skip # Vector
+      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
+      skip # Vector
+      # 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)
+    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(with_mass.mass).must_equal 99.01
+      expect(with_mass.density).wont_equal D::DENSITY
+    end
+
+    it "has a string representation" do
+      str = @disk.to_s
+      expect(str).must_be_instance_of String
+      expect(str.length).must_be(:>, 5)
+    end
+
+    it "has volume" do
+      expect(@disk.volume).must_be_within_epsilon 0.07697
+      expect(@disk.volume_l).must_be_within_epsilon 76.96902
+    end
+
+    it "has inertia" do
+      skip
+      expect(@disk.rotational_inertia).must_be_within_epsilon 1.5321
+    end
+  end
+end

data/test/scalar_force.rb

@@ -6,25 +6,27 @@ 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
+    expect(ScalarForce.air_resistance 1).must_be_within_epsilon(-1 * 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
+    expect(30 * ScalarForce.air_resistance(1)).
+      must_be_within_epsilon(-1 * ROT_COF)
   end
 
   it "approximates a positive drag force" do
-    expect(ScalarForce.air_resistance 30).must_be_within_epsilon 383.13
+    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
+    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
+    expect(ScalarForce.rolling_resistance nf).must_be_within_epsilon(-98.0)
   end
 end

data/test/{wheel.rb → tire.rb}

@@ -1,92 +1,96 @@
 require 'minitest/autorun'
-require 'driving_physics/wheel'
+require 'driving_physics/tire'
 
-W = DrivingPhysics::Wheel
+T = DrivingPhysics::Tire
 
-describe W do
-  describe "Wheel.traction" do
+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 = W.traction(scalar_nf, cof)
+      scalar_t = T.traction(scalar_nf, cof)
       expect(scalar_t).must_equal 10780.0
 
+      skip # Vector
       vector_nf = Vector[9800, 0]
-      vector_t = W.traction(vector_nf, cof)
+      vector_t = T.traction(vector_nf, cof)
       expect(vector_t).must_equal Vector[10780.0, 0.0]
     end
   end
 
-  describe "Wheel.volume" do
+  describe "Tire.volume" do
     it "calculates the volume (m^3) of disk given radius and width" do
-      cubic_m = W.volume(1.0, 1.0)
+      cubic_m = T.volume(1.0, 1.0)
       expect(cubic_m).must_equal Math::PI
 
-      cubic_m = W.volume(0.35, 0.2)
+      cubic_m = T.volume(0.35, 0.2)
       expect(cubic_m).must_be_within_epsilon 0.076969
     end
   end
 
-  describe "Wheel.volume_l" do
+  describe "Tire.volume_l" do
     it "calculates the volume (L) of a disk given radius and width" do
-      liters = W.volume_l(1.0, 1.0)
+      liters = T.volume_l(1.0, 1.0)
       expect(liters).must_equal Math::PI * 1000
 
-      liters = W.volume_l(0.35, 0.2)
+      liters = T.volume_l(0.35, 0.2)
       expect(liters).must_be_within_epsilon 76.96902
     end
   end
 
-  describe "Wheel.density" do
+  describe "Tire.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
+      expect(T.density(25.0, 25.0)).must_equal 1.0
+      expect(T.density(50.0, 25.0)).must_equal 2.0
     end
   end
 
-  describe "Wheel.mass" do
+  describe "Tire.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
+      expect(T.mass(0.35, 0.2, T::DENSITY)).must_be_within_epsilon 25.015
     end
   end
 
-  describe "Wheel.rotational_inertia" do
+  describe "Tire.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
+      expect(T.rotational_inertia(0.35, 25.0)).must_be_within_epsilon 1.53125
     end
   end
 
-  describe "Wheel.alpha" do
+  describe "Tire.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
+      inertia = T.rotational_inertia(0.35, 25.0)
+      expect(T.alpha scalar_torque, inertia).must_be_within_epsilon 653.061
 
+      skip # Vector
       vector_torque = Vector[0, 0, 1000]
-      vector_alpha = W.alpha vector_torque, inertia
+      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
 
-  describe "Wheel.torque_vector" do
+  describe "Tire.torque_vector" do
     it "calculates a torque in the 3rd dimension given 2D force and radius" do
+      skip # Vector
       force = Vector[1000, 0]
       radius = Vector[0, 5]
-      torque = W.torque_vector(force, radius)
+      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
 
-  describe "Wheel.force_vector" do
+  describe "Tire.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:
+      # let's invert the Tire.torque_vector case from above:
+      skip # Vector
       torque = Vector[0, 0, 5000]
       radius = Vector[0, 5]
-      force = W.force_vector(torque, radius)
+      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
@@ -96,7 +100,7 @@ describe W do
       # negative-x radius means positive-y force
       torque = Vector[0, 0, 500]
       radius = Vector[-5, 0]
-      force = W.force_vector(torque, radius)
+      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
@@ -106,72 +110,78 @@ describe W do
   describe "instance methods" do
     before do
       @env = DrivingPhysics::Environment.new
-      @w = W.new(@env)
+      @tire = T.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
+      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
 
-      with_mass = W.new(@env, mass: 99.01)
+      with_mass = T.new(@env) { |w|
+        w.mass = 99.01
+      }
       expect(with_mass.mass).must_equal 99.01
-      expect(with_mass.density).wont_equal W::DENSITY
+      expect(with_mass.density).wont_equal T::DENSITY
     end
 
     it "has a string representation" do
-      str = @w.to_s
+      str = @tire.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
+      old_r = @tire.radius
+      wear_amt = 50/1000r
+      @tire.wear! wear_amt
+      expect(@tire.radius).must_equal old_r - wear_amt
     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
+      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 volume" do
-      expect(@w.volume).must_be_within_epsilon 0.07697
-      expect(@w.volume_l).must_be_within_epsilon 76.96902
+      expect(@tire.volume).must_be_within_epsilon 0.07697
+      expect(@tire.volume_l).must_be_within_epsilon 76.96902
     end
 
     it "has inertia" do
-      expect(@w.rotational_inertia).must_be_within_epsilon 1.5321
+      expect(@tire.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
+      expect(@tire.traction scalar_nf).must_equal 10780.0
+      expect(@tire.traction scalar_nf, static: false).must_equal 6860.0
 
+      skip # Vector
       vector_nf = Vector[9800, 0]
-      expect(@w.traction vector_nf).must_equal Vector[10780.0, 0.0]
-      expect(@w.traction vector_nf, static: false).
+      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(@w.force 1000).must_be_within_epsilon 2857.143
-      @w.wear! 50
-      expect(@w.force 1000).must_be_within_epsilon 3333.333
+      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
 
     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(@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
 
       # not sure about how torque vectors work, but the "math" "works":
+      skip # Vector
       vector_nf = Vector[9800, 0]
-      expect(@w.tractable_torque(vector_nf)[0]).must_be_within_epsilon 3773.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.3
+  version: 0.0.2.1
 platform: ruby
 authors:
 - Rick Hull
@@ -19,20 +19,36 @@ files:
 - README.md
 - Rakefile
 - VERSION
+- demo/car.rb
+- demo/disk.rb
+- demo/gearbox.rb
+- demo/motor.rb
+- demo/mruby/disk.rb
+- demo/mruby/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/mruby.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/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