driving_physics 0.0.0.3 → 0.0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ec6ff08e7731aa8bcb419efee9ab1a96ef7642f3426c7b8a501dae764692d777
-  data.tar.gz: ae217c0e452a764392e5a4df9a0b3280369e21b92d6018ef8d8753c0a6f5f594
+  metadata.gz: 102b8d70a0aa540ee6e56ca24987497c0f272473790180a9f8691418fd1557f6
+  data.tar.gz: d82c3924641569610a538804e9b7cd9df040f8487ff50158e0b227cbf529f3dc
 SHA512:
-  metadata.gz: b8844bf3f8c45aae742bc27cbfe8307b7f61f21a600d1eac7f34248aa9a980f9942f6e4ce51ec2b58834978e4ba1a06aa0153ba4323d4e3448b1f038c39495e2
-  data.tar.gz: b41f09936f696ef4afe82f3be701409abddd6b92add4f39d5d1d42a1a412ce4204b08a411818c339bba6820858a0aae3d5324cdbabff76e2b2256e9228ae1120
+  metadata.gz: '08e0488d1a152f1ca7c432fa60c3bbb06f63ef5674c12ec898de7505e8c054a0eac75280b0b2c78985b1cacf6f7fd2925130a0c48b0564c15cbaca5036e68e30'
+  data.tar.gz: 1df9c64a0d59f48a4d9a13062166516456d685e18cf9f7bc684c0853bd9f71587460d98f14f4fc9c1f0e3a571ee325e09fe9538ab249ca4403071280b8a0eddb

data/README.md

@@ -6,7 +6,18 @@ Physical simulation of how to make a car go around a track quickly, in pure
 Ruby with minimal dependencies.  Physics from first principles, often
 using `Vector` class from `matrix.rb` in stdlib.
 
-Note, this is very much a **Work In Progress**.
+## Work In Progress
+
+This is very much a **Work In Progress**.  Implemented so far:
+
+* Spinning: rotational inertia and friction / hysteresis
+* Tires: traction force via friction and the normal force
+* Vectors: 2D Vector forces and 3D Vector torques
+* Motor: torque curves, rotating mass with friction
+* Gearbox: gear ratios, final drive, rotating mass with friction
+* Powertrain: combines motor and gearbox
+* Car: 4 tires, powertrain, extra mass presents a load to the powertrain
+* Acceleration: via drive traction from "first principles"
 
 ## Rationale
 

data/VERSION

@@ -1 +1 @@
-0.0.0.3
+0.0.1.1

data/demo/car.rb

@@ -0,0 +1,153 @@
+require 'driving_physics/car'
+require 'driving_physics/imperial'
+require 'driving_physics/cli'
+
+include DrivingPhysics
+
+env = Environment.new
+puts env
+
+tire = Tire.new(env)
+motor = Motor.new(env)
+gearbox = Gearbox.new(env)
+pt = Powertrain.new(motor, gearbox)
+car = Car.new(tire: tire, powertrain: pt) { |c|
+  c.mass = 1050.0
+  c.frontal_area = 2.5
+  c.cd = 0.5
+}
+puts car
+CLI.pause
+
+duration = 120
+
+speed = 0.0
+dist = 0.0
+
+tire_omega = 0.0
+tire_theta = 0.0
+
+crank_omega = 0.0
+crank_theta = 0.0
+
+t = Time.now
+num_ticks = duration * env.hz + 1
+
+clutch = :ok
+phase = :ignition
+flag = false
+rpm = 0
+puts <<EOF
+
+#
+# IGNITION
+#
+
+EOF
+
+num_ticks.times { |i|
+  if phase == :ignition
+    # ignition phase
+    crank_alpha = motor.alpha(motor.starter_torque, omega: crank_omega)
+    crank_omega += crank_alpha * env.tick
+    crank_theta += crank_omega * env.tick
+
+    rpm = DrivingPhysics.rpm(crank_omega)
+
+    if i % 100 == 0 or rpm > motor.idle_rpm
+      puts DrivingPhysics.elapsed_display(i)
+      puts format("%d rad  %d rad/s  %d rad/s/s",
+                  crank_theta, crank_omega, crank_alpha)
+      puts "RPM: #{rpm.round}"
+      puts
+    end
+
+    if rpm > motor.idle_rpm
+      pt.select_gear(1)
+      phase = :running
+
+      puts <<EOF
+
+#
+# RUNNING
+#
+
+EOF
+    end
+  elsif phase == :running
+    # track crank_alpha/omega/theta
+
+    ar = car.air_force(speed)
+    rr = car.tire_rolling_force(tire_omega)
+    rf = car.tire_rotational_force(tire_omega)
+
+    force = car.drive_force(rpm) + ar + rr + rf
+
+
+    ir = car.tire_inertial_force(force)
+    force += ir
+
+    acc = DrivingPhysics.acc(force, car.total_mass)
+    speed += acc * env.tick
+    dist += speed * env.tick
+
+    tire_alpha = acc / car.tire.radius
+    tire_omega += tire_alpha * env.tick
+    tire_theta += tire_omega * env.tick
+
+    crank_alpha = tire_alpha / car.powertrain.gearbox.ratio
+    crank_omega += crank_alpha * env.tick
+    crank_theta += crank_omega * env.tick
+
+    axle_torque = car.powertrain.axle_torque(rpm)
+    crank_torque = car.powertrain.motor.torque(rpm)
+
+    if flag or (i < 5000 and i % 100 == 0) or (i % 1000 == 0)
+      puts DrivingPhysics.elapsed_display(i)
+      puts format("  Tire: %.1f r  %.2f r/s  %.3f r/s^2",
+                  tire_theta, tire_omega, tire_alpha)
+      puts format("   Car: %.1f m  %.2f m/s  %.3f m/s^2 (%.1f MPH)",
+                  dist, speed, acc, Imperial.mph(speed))
+      puts format(" Motor: %d RPM  %.1f Nm", rpm, crank_torque)
+      puts format("  Axle: %.1f Nm (%d N)  Net Force: %.1f N",
+                  axle_torque, car.drive_force(rpm), force)
+      puts        "Resist: " + format(%w[Air Roll Spin Inertial].map { |s|
+                                        "#{s}: %.1f N"
+                                      }.join('  '), ar, rr, rf, ir)
+      puts
+      flag = false
+    end
+
+    # tire_omega determines new rpm
+    new_rpm = car.powertrain.crank_rpm(tire_omega)
+    new_clutch, proportion = car.powertrain.gearbox.match_rpms(rpm, new_rpm)
+
+    if new_clutch != clutch
+      flag = true
+      puts format("Clutch: [%s] %d RPM is %.1f%% from %d RPM",
+                  new_clutch, new_rpm, proportion * 100, rpm)
+      clutch = new_clutch
+      CLI.pause
+    end
+
+    case new_clutch
+    when :ok
+      rpm = new_rpm
+    when :mismatch
+      flag = true
+      puts "LURCH!"
+      puts
+      rpm = new_rpm
+    end
+    next_gear = car.powertrain.gearbox.next_gear(rpm)
+    if next_gear != gearbox.gear
+      flag = true
+      puts "Gear Change: #{next_gear}"
+      car.powertrain.select_gear(next_gear)
+      CLI.pause
+    end
+  end
+}
+
+elapsed = Time.now - t
+puts format("%.2f s (%d ticks / s)", elapsed, num_ticks / elapsed)

data/demo/disk.rb

@@ -0,0 +1,76 @@
+require 'driving_physics/disk'
+require 'driving_physics/cli'
+
+include DrivingPhysics
+
+env = Environment.new
+disk = Disk.new(env)
+
+puts env
+puts disk
+puts
+
+axle_torque = 50
+alpha = disk.alpha(axle_torque)
+drive_force = disk.force(axle_torque)
+
+puts [format("Axle torque: %.1f Nm", axle_torque),
+      format("      Alpha: %.1f rad/s/s", alpha),
+      format("Drive force: %.1f N", drive_force),
+     ].join("\n")
+puts
+CLI.pause
+
+duration = 750 # sec
+
+dist = 0.0  # meters
+speed = 0.0 # meters/s
+
+theta = 0.0 # radians
+omega = 0.0 # radians/s
+
+t = Time.now
+elapsed = 0.0
+num_ticks = duration * env.hz
+
+num_ticks.times { |i|
+  # shut off the powah!
+  if i == 19_000
+    puts
+    puts "     ### CUT POWER ###"
+    puts
+    axle_torque = 0
+    elapsed += Time.now - t
+    CLI.pause
+    t = Time.now
+  end
+
+  rotating_friction = disk.rotating_friction(omega)
+  net_torque = axle_torque + rotating_friction
+  net_force = disk.force(net_torque)
+
+  # rotational kinematics
+  alpha = disk.alpha(net_torque)
+  omega += alpha * env.tick
+  omega = 0.0 if omega.abs < 0.0001
+  theta += omega * env.tick
+
+  if i < 10 or
+    (i < 20_000 and i%1000 == 0) or
+    (i % 10_000 == 0) or
+    i == duration * env.hz - 1
+
+    puts DrivingPhysics.elapsed_display(i)
+    puts format(" Torque: %.1f Nm (%d Nm)  Friction: %.1f Nm",
+                net_torque, axle_torque, rotating_friction)
+    puts format("Radians: %.1f r  %.2f r/s  %.3f r/s^2", theta, omega, alpha)
+    puts format("   Revs: %d revs  %d revs/s  %d rpm",
+                DrivingPhysics.revs(theta),
+                DrivingPhysics.revs(omega),
+                DrivingPhysics.rpm(omega))
+    puts
+  end
+}
+
+elapsed += Time.now - t
+puts format("%.2f s (%d ticks / s)", elapsed, num_ticks / elapsed)

data/demo/gearbox.rb

@@ -0,0 +1,47 @@
+require 'driving_physics/gearbox'
+require 'driving_physics/cli'
+
+include DrivingPhysics
+
+env = Environment.new
+gearbox = Gearbox.new(env)
+
+torque = 30
+duration = 30
+
+puts env
+puts gearbox
+puts
+puts "Spin up the gearbox with #{torque} Nm of input torque"
+puts "How fast will it go in #{duration} seconds?"
+CLI.pause
+
+# rotational kinematics
+alpha = 0.0
+omega = 0.0
+theta = 0.0
+
+(duration * env.hz + 1).times { |i|
+  # just for info, not used in the simulation
+  friction = gearbox.spinner.rotating_friction(omega)
+
+  # update rotational kinematics
+  # gearbox.alpha incorporates friction and inertia
+  alpha = gearbox.alpha(torque, omega: omega)
+  omega += alpha * env.tick
+  theta += omega * env.tick
+
+  net_torque = gearbox.implied_torque(alpha)
+
+  # periodic output
+  if i < 10 or
+    (i < 100 and i % 10 == 0) or
+    (i < 1000 and i % 100 == 0) or
+    i % 1000 == 0
+    puts DrivingPhysics.elapsed_display(i)
+    puts format("RPM %d  Torque: %.3f Nm (%d Nm) Friction: %.3f Nm",
+                DrivingPhysics.rpm(omega), net_torque, torque, friction)
+    puts format("%.1f rad  %.1f rad/s  %.1f rad/s/s", theta, omega, alpha)
+    puts
+  end
+}

data/demo/motor.rb

@@ -0,0 +1,89 @@
+require 'driving_physics/motor'
+require 'driving_physics/cli'
+
+# fun idea for a different demo: keep increasing torque until idle is
+# maintained
+
+include DrivingPhysics
+
+env = Environment.new
+motor = Motor.new(env)
+puts env
+puts motor
+
+puts "Rev it up!"
+800.upto(7000) { |rpm|
+  next unless rpm % 200 == 0
+  tq = motor.torque(rpm).to_f
+  puts format("%s RPM: %s Nm\t%s",
+              rpm.to_s.rjust(4, ' '),
+              tq.round(1).to_s.rjust(5, ' '),
+              '#' * (tq.to_f / 10).round)
+}
+
+puts
+puts "* Spin the motor up to #{motor.idle_rpm} RPM with the starter motor."
+puts "* Rev it up with the throttle."
+puts "* Let it die."
+CLI.pause
+
+alpha = 0.0
+omega = 0.0
+theta = 0.0
+
+duration = 60
+
+status = :ignition
+rpm = 0
+
+(duration * env.hz + 1).times { |i|
+  # this is an input torque; alpha is determined after inertia and friction
+  torque = case status
+           when :ignition
+             motor.starter_torque
+           when :running
+             motor.torque(rpm)
+           else
+             0
+           end
+
+  # Motor#alpha incorporates inertia and friction
+  alpha = motor.alpha(torque, omega: omega)
+  omega += alpha * env.tick
+  theta += omega * env.tick
+
+  net_torque = motor.implied_torque(alpha)
+
+  # prevent silly oscillations due to tiny floating point errors
+  omega = 0 if omega < 0.00001
+  rpm = DrivingPhysics.rpm(omega)
+
+  if rpm > motor.idle_rpm and status == :ignition
+    status = :running
+    flag = true
+  end
+
+  if rpm > 7000 and status == :running
+    status = :off
+    flag = true
+  end
+
+  if flag or
+    (i < 10) or
+    (i < 100 and i % 10 == 0) or
+    (i < 1000 and i % 100 == 0) or
+    (i < 10_000 and i % 500 == 0) or
+    i % 5000 == 0
+    puts DrivingPhysics.elapsed_display(i)
+    puts format("%d RPM  %.1f Nm (%d Nm)  Friction: %.1f Nm",
+                DrivingPhysics.rpm(omega),
+                net_torque,
+                torque,
+                motor.spinner.rotating_friction(omega))
+    puts format("%d rad  %.1f rad/s  %.1f rad/s/s", theta, omega, alpha)
+    puts
+
+    CLI.pause if flag
+    flag = false
+  end
+}

data/demo/powertrain.rb

@@ -0,0 +1,40 @@
+require 'driving_physics/powertrain'
+require 'driving_physics/imperial'
+require 'driving_physics/cli'
+
+include DrivingPhysics
+
+env = Environment.new
+motor = Motor.new(env)
+gearbox = Gearbox.new(env)
+powertrain = Powertrain.new(motor, gearbox)
+puts env
+puts powertrain
+CLI.pause
+
+crank_alpha = 0.0
+crank_omega = 0.0
+
+axle_alpha = 0.0
+axle_omega = 0.0
+
+
+# Run through the gears
+
+1.upto(6) { |gear|
+  powertrain.select_gear(gear)
+
+  puts <<EOF
+
+# GEAR #{gear} (#{powertrain.gearbox.ratio})
+#
+EOF
+
+  800.upto(7000) { |rpm|
+    next unless rpm % 500 == 0
+
+    axle_torque = powertrain.axle_torque(rpm)
+    mph = Imperial.mph(Disk.tangential(powertrain.axle_omega(rpm), 0.32))
+    puts format("%d RPM:  %.1f Nm  %d mph", rpm, axle_torque, mph)
+  }
+}

data/demo/scalar_force.rb

@@ -13,9 +13,9 @@ tick = 1.0 / DP::HZ
 (duration * DP::HZ).times { |i|
   nf = drive_force - DP::ScalarForce.all_resistance(spd, nf_mag: weight)
 
-  a = DP.a(nf, mass)
-  spd = DP.v(a, spd, dt: tick)
-  pos = DP.p(spd, pos, dt: tick)
+  a = DP.acc(nf, mass)
+  spd = DP.vel(spd, a, dt: tick)
+  pos = DP.pos(pos, spd, dt: tick)
 
   if i % DP::HZ == 0
     puts [i / DP::HZ,

data/demo/tire.rb

@@ -0,0 +1,88 @@
+require 'driving_physics/tire'
+
+include DrivingPhysics
+
+env = Environment.new
+tire = Tire.new(env)
+
+puts env
+puts tire
+
+# 1000 kg car
+# 4 tires
+# 250 kg per tire plus tire mass
+
+supported_mass = 1000 # kg
+total_mass = supported_mass + 4 * tire.mass
+corner_mass = Rational(total_mass) / 4
+normal_force = corner_mass * env.g
+axle_torque = 1000 # N*m
+
+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 = tire.traction(normal_force)
+drive_force = tire.force(axle_torque)
+inertial_loss = tire.inertial_loss(axle_torque, driven_mass: supported_mass)
+net_axle_torque = axle_torque - inertial_loss
+net_drive_force = tire.force(net_axle_torque)
+acc = DrivingPhysics.acc(net_drive_force, supported_mass) # translational
+alpha = acc / tire.radius
+
+puts [format("Traction: %.1f N", traction),
+      format("Drive force: %.1f N", drive_force),
+      format("Inertial loss: %.1f Nm", inertial_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", alpha),
+     ].join("\n")
+puts
+
+duration = 100 # sec
+
+dist = 0.0  # meters
+speed = 0.0 # meters/s
+
+theta = 0.0 # radians
+omega = 0.0 # radians/s
+
+t = Time.now
+num_ticks = duration * env.hz
+
+num_ticks.times { |i|
+  torque = tire.net_tractable_torque(axle_torque,
+                                      mass: total_mass,
+                                      omega: omega,
+                                      normal_force: normal_force)
+  force = tire.force(torque)
+
+  # translational kinematics
+  acc = DrivingPhysics.acc(force, supported_mass)
+  speed += acc * env.tick
+  dist += speed * env.tick
+
+  # rotational kinematics
+  alpha = acc / tire.radius
+  omega += alpha * env.tick
+  theta += omega * env.tick
+
+  if i < 10 or
+    (i < 20_000 and i%1000 == 0) or
+    (i % 10_000 == 0) or
+    i == duration * env.hz - 1
+
+    puts DrivingPhysics.elapsed_display(i)
+    puts format("  Tire: %.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, acc)
+    puts format("Torque: %.1f Nm (%d N)  Loss: %.1f%%",
+                torque, force, (1.0 - torque / axle_torque) * 100)
+    puts
+  end
+}
+
+elapsed = Time.now - t
+puts format("%.2f s (%d ticks / s)", elapsed, num_ticks / elapsed)

data/demo/vector_force.rb

@@ -13,9 +13,9 @@ tick = 1.0 / DP::HZ
 (duration * DP::HZ).times { |i|
   nf = drive_force + DP::VectorForce.all_resistance(v, dir: v, nf_mag: weight)
 
-  a = DP.a(nf, mass)
-  v = DP.v(a, v, dt: tick)
-  p = DP.p(v, p, dt: tick)
+  a = DP.acc(nf, mass)
+  v = DP.vel(v, a, dt: tick)
+  p = DP.pos(p, v, dt: tick)
 
   if i % DP::HZ == 0
     puts [i / DP::HZ,

data/lib/driving_physics/car.rb

@@ -0,0 +1,103 @@
+require 'driving_physics/tire'
+require 'driving_physics/powertrain'
+
+module DrivingPhysics
+  class Car
+    attr_reader :tire, :powertrain, :env
+    attr_accessor :num_tires, :mass, :frontal_area, :cd
+
+    def initialize(tire:, powertrain:)
+      @num_tires = 4
+      @tire = tire
+      @env = @tire.env
+      @powertrain = powertrain
+      @mass = Rational(1000)
+      @frontal_area = DrivingPhysics::FRONTAL_AREA
+      @cd = DrivingPhysics::DRAG_COF
+
+      yield self if block_given?
+    end
+
+    # force opposing speed
+    def air_force(speed)
+      -0.5 * @frontal_area * @cd * @env.air_density * speed ** 2
+    end
+
+    # force of opposite sign to omega
+    def tire_rolling_force(omega)
+      @num_tires *
+        @tire.rolling_friction(omega, normal_force: self.normal_force) /
+        @tire.radius
+    end
+
+    # force of opposite sign to omega
+    def tire_rotational_force(omega)
+      @num_tires *
+        @tire.rotating_friction(omega, normal_force: self.normal_force) /
+        @tire.radius
+    end
+
+    # force of opposite sign to force
+    def tire_inertial_force(force)
+      mag = force.abs
+      sign = force / mag
+      force_loss = 0
+      5.times {
+        # use magnitude, so we are subtracting only positive numbers
+        acc = DrivingPhysics.acc(mag - force_loss, self.total_mass)
+        alpha = acc / @tire.radius
+        # this will be a positive number
+        force_loss = @num_tires * @tire.implied_torque(alpha) /
+                     @tire.radius
+      }
+      # oppose initial force
+      -1 * sign * force_loss
+    end
+
+    def to_s
+      [[format("Mass: %.1f kg", self.total_mass),
+        format("Fr.A: %.2f m^2", @frontal_area),
+        format("cD: %.2f", @cd),
+       ].join(' | '),
+       format("Powertrain: %s", @powertrain),
+       format("Tires: %s", @tire),
+       format("Corner mass: %.1f kg | Normal force: %.1f N",
+              self.corner_mass, self.normal_force),
+      ].join("\n")
+    end
+
+    def drive_force(rpm)
+      @tire.force(@powertrain.axle_torque(rpm))
+    end
+
+    def tire_speed(rpm)
+      @tire.tangential(@powertrain.axle_omega(rpm))
+    end
+
+    def motor_rpm(tire_speed)
+      @powertrain.gearbox.crank_rpm(tire_speed / @tire_radius)
+    end
+
+    def total_mass
+      @mass + @tire.mass * @num_tires
+    end
+
+    def corner_mass
+      Rational(self.total_mass) / @num_tires
+    end
+
+    # per tire
+    def normal_force
+      self.corner_mass * @env.g
+    end
+
+    # per tire
+    def tire_traction
+      @tire.traction(self.normal_force)
+    end
+
+    def total_normal_force
+      self.total_mass * env.g
+    end
+  end
+end

data/lib/driving_physics/cli.rb

@@ -0,0 +1,17 @@
+module DrivingPhysics
+  module CLI
+    # returns user input as a string
+    def self.prompt(msg = '')
+      print msg + ' ' unless msg.empty?
+      print '> '
+      $stdin.gets.chomp
+    end
+
+    # press Enter to continue
+    def self.pause(msg = '')
+      puts msg unless msg.empty?
+      puts '     [ Press Enter ]'
+      $stdin.gets
+    end
+  end
+end