driving_physics 0.0.0.2 → 0.0.1.2

data/lib/driving_physics/tire.rb

@@ -1,288 +1,120 @@
-# NOTE: This entire file will likely be replaced or removed.
-#       It was created early on, before taking a true physics / formulaic
-#       approach.  Just treat it as a toy / PoC for now.  It does not
-#       currently behave as desired.
-#
+require 'driving_physics/disk'
 
-require 'driving_physics'
-
-# treat instances of this class as immutable
-# Tire::Condition has mutable attributes
-#
 module DrivingPhysics
-  class Tire
-    class Error < RuntimeError; end
 
-    attr_accessor :roll_cof,
-                  :tread_mm,
-                  :cords_mm,
-                  :radius_mm,
-                  :g_factor,
-                  :max_heat_cycles,
-                  :temp_profile,
-                  :condition
+  # 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
-      @roll_cof = ROLL_COF
-      @tread_mm = 10
-      @cords_mm = 1
-      @radius_mm = 350
-      @g_factor = 1.0
-      @max_heat_cycles = 50
-      @temp_profile = TemperatureProfile.new
+    def initialize(env)
+      @env = env
+      @radius = 350/1000r # m
+      @width  = 200/1000r # m
+      @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
+      @roll_cof = DrivingPhysics::ROLL_COF
 
       yield self if block_given?
-      @condition = Condition.new(tread_mm: @tread_mm, cords_mm: @cords_mm)
     end
 
     def to_s
-      [[format("Grip: %.2f / %.1f G", max_g, @g_factor),
-        format("Radius: %d mm", @radius_mm),
-        format("cRR: %.3f", @roll_cof),
-       ].join(' | '),
-       @condition,
+      [[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 tread_left?
-      @condition.tread_mm > 0.0
+    def wear!(amount)
+      @radius -= amount
     end
 
-    # cords give half the traction as tread
-    def tread_factor
-      tread_left? ? 1.0 : 0.5 * @condition.cords_mm / @cords_mm
+    def heat!(amount_deg_c)
+      @temp += amount_deg_c
     end
 
-    # up to max_heat_cycles, the grip decays down to 80%
-    # beyond max_heat_cycles, the grip decay plateaus at 80%
-    def heat_cycle_factor
-      heat_cycles = [@condition.heat_cycles, @max_heat_cycles].min.to_f
-      heat_pct = heat_cycles / @max_heat_cycles
-      1.0 - 0.2 * heat_pct
+    def traction(nf, static: true)
+      self.class.traction(nf, static ? @mu_s : @mu_k)
     end
 
-    def temp_factor
-      @temp_profile.grip_factor(@condition.temp_c)
+    # require a normal_force to be be passed in
+    def rotating_friction(omega, normal_force:)
+      super(omega, normal_force: normal_force)
     end
 
-    def max_g
-      @g_factor * temp_factor * heat_cycle_factor * tread_factor
+    # 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
 
-    # treat instances of this class as immutable
-    class TemperatureProfile
-      class Error < DrivingPhysics::Tire::Error; end
-
-      TEMPS = [-100, 0, 25, 50, 75, 80, 85, 95, 100, 105, 110, 120, 130, 150]
-      GRIPS = [0.1, 0.5, 0.75, 0.8, 0.9, 0.95, 1.0,
-               0.95, 0.9, 0.75, 0.5, 0.25, 0.1, 0.05]
-      MIN_GRIP = 0.01
-
-      attr_reader :critical_temp
-
-      def initialize(deg_ary = TEMPS, grip_ary = GRIPS)
-        if !deg_ary.is_a?(Array) or !grip_ary.is_a?(Array)
-          raise(ArgumentError, "two arrays are required")
-        end
-        if deg_ary.count != grip_ary.count
-          raise(ArgumentError, "arrays don't match")
-        end
-        @deg_c = deg_ary
-        @grip_pct = grip_ary
-        @critical_temp = nil
-        determine_critical_temp!
-      end
-
-      def grip_factor(temp_c)
-        pct = MIN_GRIP
-        @deg_c.each_with_index { |deg, i|
-          pct = @grip_pct[i] if temp_c >= deg
-          break if temp_c < deg
-        }
-        pct
-      end
-
-      def to_s
-        lines = []
-        @deg_c.each_with_index { |deg, i|
-          lines << [deg, @grip_pct[i]].join("\t")
-        }
-        lines.join("\n")
-      end
-
-      private
-      def determine_critical_temp!
-        return @critical_temp if @critical_temp
-        reached_100 = false
-        # go up to 100% grip, then back down to less than 80%
-        @deg_c.each_with_index { |deg, i|
-          next if !reached_100 and @grip_pct[i] < 1.0
-          reached_100 = true if @grip_pct[i] == 1.0
-          if reached_100 and @grip_pct[i] <= 0.8
-            @critical_temp = deg
-            break
-          end
-        }
-        raise(Error, "bad profile, can't find 100% grip") unless reached_100
-        raise(Error, "bad profile, no critical temp") unless @critical_temp
-      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
 
-    # treat attributes of this class as *mutable*
-    class Condition
-      class Error < DrivingPhysics::Tire::Error; end
-      class Destroyed < Error; end
-
-      attr_accessor :tread_mm,
-                    :cords_mm,
-                    :temp_c,
-                    :heat_cycles,
-                    :debug_temp,
-                    :debug_wear
-
-      def initialize(temp_c: AIR_TEMP, tread_mm:, cords_mm:)
-        @tread_mm = tread_mm.to_f
-        @cords_mm = cords_mm.to_f
-        @temp_c = temp_c.to_f
-        @heat_cycles = 0
-        @hottest_temp = @temp_c
-        @debug_temp = false
-        @debug_wear = false
-      end
-
-      def to_s
-        [format("Temp: %.1f C", @temp_c),
-         format("Tread: %.2f (%.1f) mm", @tread_mm, @cords_mm),
-         format("Cycles: %d", @heat_cycles),
-        ].join(' | ')
-      end
-
-      def temp_tick(ambient_temp:, g:, slide_speed:,
-                    mass:, tire_mass:, critical_temp:)
-        # env:
-        # * mass (kg) (e.g. 1000 kg)
-        # * tire_mass (kg) (e.g. 10 kg)
-        # * critical temp (c) (e.g. 100c)
-        # * g (e.g. 1.0 g)
-        # * slide_speed (m/s) (typically 0.1, up to 1 or 10 or 50)
-        # * ambient_temp (c) (e.g. 30c)
-
-        # g gives a target temp between 25 and 100
-        # at 0g, tire tends to ambient temp
-        # at 1g, tire tends to 100 c
-        # that 100c upper target also gets adjusted due to ambient temps
-
-        target_hot = critical_temp + 5
-        ambient_diff = AIR_TEMP - ambient_temp
-        target_hot -= (ambient_diff / 2)
-        puts "target_hot=#{target_hot}" if @debug_temp
-
-        if slide_speed <= 0.1
-          target_g_temp = ambient_temp + (target_hot - ambient_temp) * g
-        else
-          target_g_temp = target_hot
-        end
-        puts "target_g_temp=#{target_g_temp}" if @debug_temp
+    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)
 
-        slide_factor = slide_speed * 5
-        target_slide_temp = target_g_temp + slide_factor
-
-        puts "target_slide_temp=#{target_slide_temp}" if @debug_temp
-
-        # temp_tick is presumed to be +1.0 or -1.0 (100th of a degree)
-        # more mass biases towards heat
-        # more tire mass biases for smaller tick
-
-        tick = @temp_c < target_slide_temp ? 1.0 : -1.0
-        tick += slide_speed / 10
-        puts "base tick: #{tick}" if @debug_temp
-
-        mass_factor = (mass - 1000).to_f / 1000
-        if mass_factor < 0
-          # lighter car cools quicker; heats slower
-          tick += mass_factor
-        else
-          # heavier car cools slower, heats quicker
-          tick += mass_factor / 10
-        end
-        puts "mass tick: #{tick}" if @debug_temp
-
-        tire_mass_factor = (tire_mass - 10).to_f / 10
-        if tire_mass_factor < 0
-          # lighter tire has bigger tick
-          tick -= tire_mass_factor
-        else
-          # heavier tire has smaller tick
-          tire_mass_factor = (tire_mass - 10).to_f / 100
-          tick -= tire_mass_factor
-        end
-        puts "tire mass tick: #{tick}" if @debug_temp
-        puts if @debug_temp
-
-        tick
-      end
-
-      def wear_tick(g:, slide_speed:, mass:, critical_temp:)
-        # cold tires wear less
-        tick = [0, @temp_c.to_f / critical_temp].max
-        puts "wear tick: #{tick}" if @debug_wear
-
-        # lower gs reduce wear in the absence of sliding
-        tick *= g if slide_speed <= 0.1
-        puts "g wear tick: #{tick}" if @debug_wear
-
-        # slide wear
-        tick += slide_speed
-        puts "slide wear tick: #{tick}" if @debug_wear
-        puts if @debug_wear
-        tick
-      end
-
-
-      def tick!(ambient_temp:, g:, slide_speed:,
-                mass:, tire_mass:, critical_temp:)
-
-        # heat cycle:
-        # when the tire goes above the critical temp and then
-        # cools significantly below the critical temp
-        # track @hottest_temp
-
-        @temp_c += temp_tick(ambient_temp: ambient_temp,
-                             g: g,
-                             slide_speed: slide_speed,
-                             mass: mass,
-                             tire_mass: tire_mass,
-                             critical_temp: critical_temp) / 100
-        @hottest_temp = @temp_c if @temp_c > @hottest_temp
-        if @hottest_temp > critical_temp and @temp_c < critical_temp * 0.8
-          @heat_cycles += 1
-          @hottest_temp = @temp_c
-        end
-
-        # a tire should last for 30 minutes at 1g sustained
-        # with minimal sliding
-        # 100 ticks / sec
-        # 6000 ticks / min
-        # 180_000 ticks / 30 min
-        # 10mm = 180_000 ticks
-        # wear_tick is nominally 1 / 18_000 mm
+      # 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
 
-        wt = wear_tick(g: g,
-                       slide_speed: slide_speed,
-                       mass: mass,
-                       critical_temp: critical_temp)
+    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
 
-        if @tread_mm > 0
-          @tread_mm -= wt / 18000
-          @tread_mm = 0 if @tread_mm < 0
-        else
-          # cords wear 2x faster
-          @cords_mm -= wt * 2 / 18000
-          if @cords_mm <= 0
-            raise(Destroyed, "no more cords")
-          end
-        end
-      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,129 @@
+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
+
+      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
+      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)
+    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