driving_physics 0.0.1.1 → 0.0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 102b8d70a0aa540ee6e56ca24987497c0f272473790180a9f8691418fd1557f6
-  data.tar.gz: d82c3924641569610a538804e9b7cd9df040f8487ff50158e0b227cbf529f3dc
+  metadata.gz: ef486c39982798a7331f49f601e648d520a65977161180631cc4c5d3340a9011
+  data.tar.gz: 9e30b74ae34cb77a711d5d9631983b0c070872900123a1dde2d3dd03bdab854b
 SHA512:
-  metadata.gz: '08e0488d1a152f1ca7c432fa60c3bbb06f63ef5674c12ec898de7505e8c054a0eac75280b0b2c78985b1cacf6f7fd2925130a0c48b0564c15cbaca5036e68e30'
-  data.tar.gz: 1df9c64a0d59f48a4d9a13062166516456d685e18cf9f7bc684c0853bd9f71587460d98f14f4fc9c1f0e3a571ee325e09fe9538ab249ca4403071280b8a0eddb
+  metadata.gz: 46eaf512dad64ca39ec20451d7acce1b1819ecd64125ee858f92c26e5edd7b0ec0e7ef01af8f73daa0d37868e0ffd76bd3b29478093219cd906d8d9e38026bcd
+  data.tar.gz: ae2e01ae8e7986c9d2e659ff5a0934ed5359e20cf2757d7724118bb59e0fb0199180249815f2f28f55f48a2336511a0b43f0d6fab042ed5d20a5ab6a897baef1

data/VERSION

@@ -1 +1 @@
-0.0.1.1
+0.0.1.2

data/demo/car.rb

@@ -10,9 +10,9 @@ 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
+powertrain = Powertrain.new(motor, gearbox)
+car = Car.new(tire: tire, powertrain: powertrain) { |c|
+  c.body_mass = 850.0
   c.frontal_area = 2.5
   c.cd = 0.5
 }
@@ -21,16 +21,20 @@ CLI.pause
 
 duration = 120
 
+acc = 0.0
 speed = 0.0
 dist = 0.0
 
+tire_alpha = 0.0
 tire_omega = 0.0
 tire_theta = 0.0
 
+crank_alpha = 0.0
 crank_omega = 0.0
 crank_theta = 0.0
 
-t = Time.now
+start = Timer.now
+paused = 0.0
 num_ticks = duration * env.hz + 1
 
 clutch = :ok
@@ -55,15 +59,16 @@ num_ticks.times { |i|
     rpm = DrivingPhysics.rpm(crank_omega)
 
     if i % 100 == 0 or rpm > motor.idle_rpm
-      puts DrivingPhysics.elapsed_display(i)
+      puts Timer.display(i)
       puts format("%d rad  %d rad/s  %d rad/s/s",
                   crank_theta, crank_omega, crank_alpha)
-      puts "RPM: #{rpm.round}"
+      puts format("%d RPM  %d Nm starter torque", rpm, motor.starter_torque)
       puts
     end
 
     if rpm > motor.idle_rpm
-      pt.select_gear(1)
+      car.gear = 1
+      car.throttle = 1.0
       phase = :running
 
       puts <<EOF
@@ -77,13 +82,16 @@ EOF
   elsif phase == :running
     # track crank_alpha/omega/theta
 
+    # cut throttle after 60 s
+    car.throttle = 0 if i > 60 * env.hz and car.throttle == 1.0
+
     ar = car.air_force(speed)
     rr = car.tire_rolling_force(tire_omega)
     rf = car.tire_rotational_force(tire_omega)
 
+    # note, this fails if we're in neutral
     force = car.drive_force(rpm) + ar + rr + rf
 
-
     ir = car.tire_inertial_force(force)
     force += ir
 
@@ -103,11 +111,11 @@ EOF
     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 Timer.display(i)
+      puts format("  Tire: %.1f r/s/s  %.2f r/s  %.3f r",
+                  tire_alpha, tire_omega, tire_theta)
+      puts format("   Car: %.1f m/s/s  %.2f m/s  %.3f m  (%.1f MPH)",
+                  acc, speed, dist, 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)
@@ -127,7 +135,7 @@ EOF
       puts format("Clutch: [%s] %d RPM is %.1f%% from %d RPM",
                   new_clutch, new_rpm, proportion * 100, rpm)
       clutch = new_clutch
-      CLI.pause
+      paused += CLI.pause
     end
 
     case new_clutch
@@ -135,7 +143,9 @@ EOF
       rpm = new_rpm
     when :mismatch
       flag = true
-      puts "LURCH!"
+      puts '#'
+      puts '# LURCH!'
+      puts '#'
       puts
       rpm = new_rpm
     end
@@ -143,11 +153,23 @@ EOF
     if next_gear != gearbox.gear
       flag = true
       puts "Gear Change: #{next_gear}"
-      car.powertrain.select_gear(next_gear)
-      CLI.pause
+      car.gear = next_gear
+      paused += CLI.pause
+    end
+
+    # maintain idle when revs drop
+    if car.throttle == 0 and rpm < motor.idle_rpm
+      phase = :idling
+      car.gear = 0
+      paused += CLI.pause
     end
+
+
+  elsif phase == :idling
+    # fake
+    rpm = motor.idle_rpm
+    break
   end
 }
 
-elapsed = Time.now - t
-puts format("%.2f s (%d ticks / s)", elapsed, num_ticks / elapsed)
+puts Timer.summary(start, num_ticks, paused)

data/demo/disk.rb

@@ -19,6 +19,10 @@ puts [format("Axle torque: %.1f Nm", axle_torque),
       format("Drive force: %.1f N", drive_force),
      ].join("\n")
 puts
+
+puts "* Spin up the disk with #{axle_torque} Nm of torque"
+puts "* Cut the power at some point"
+puts "* Observe"
 CLI.pause
 
 duration = 750 # sec
@@ -29,20 +33,20 @@ 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
+paused = 0.0 # seconds
+num_ticks = duration * env.hz + 1
+flag = false # to display current stats
+start = Timer.now
 
 num_ticks.times { |i|
   # shut off the powah!
-  if i == 19_000
-    puts
-    puts "     ### CUT POWER ###"
+  if i == 18_950
+    flag = true
+    puts '#'
+    puts '# CUT POWER'
+    puts '#'
     puts
     axle_torque = 0
-    elapsed += Time.now - t
-    CLI.pause
-    t = Time.now
   end
 
   rotating_friction = disk.rotating_friction(omega)
@@ -55,12 +59,12 @@ num_ticks.times { |i|
   omega = 0.0 if omega.abs < 0.0001
   theta += omega * env.tick
 
-  if i < 10 or
+  if flag or 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 Timer.display(ms: 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)
@@ -69,8 +73,11 @@ num_ticks.times { |i|
                 DrivingPhysics.revs(omega),
                 DrivingPhysics.rpm(omega))
     puts
+    if flag
+      paused += CLI.pause
+      flag = false
+    end
   end
 }
 
-elapsed += Time.now - t
-puts format("%.2f s (%d ticks / s)", elapsed, num_ticks / elapsed)
+puts Timer.summary(start, num_ticks, paused)

data/demo/gearbox.rb

@@ -21,6 +21,9 @@ alpha = 0.0
 omega = 0.0
 theta = 0.0
 
+start = Timer.now
+paused = 0
+
 (duration * env.hz + 1).times { |i|
   # just for info, not used in the simulation
   friction = gearbox.spinner.rotating_friction(omega)
@@ -38,10 +41,12 @@ theta = 0.0
     (i < 100 and i % 10 == 0) or
     (i < 1000 and i % 100 == 0) or
     i % 1000 == 0
-    puts DrivingPhysics.elapsed_display(i)
+    puts Timer.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
 }
+
+puts Timer.summary(start, num_ticks, paused)

data/demo/motor.rb

@@ -1,8 +1,8 @@
 require 'driving_physics/motor'
 require 'driving_physics/cli'
+require 'driving_physics/power'
 
-# fun idea for a different demo: keep increasing torque until idle is
-# maintained
+# next fun idea: PID controller
 
 include DrivingPhysics
 
@@ -10,18 +10,44 @@ env = Environment.new
 motor = Motor.new(env)
 puts env
 puts motor
+puts
 
 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)
+motor.throttle = 1.0
+[:torque, :power].each { |run|
+  puts
+  puts run.to_s.upcase + ':'
+
+  800.upto(7000) { |rpm|
+    next unless rpm % 200 == 0
+    omega = DrivingPhysics.omega(rpm)
+    torque = motor.torque(rpm)
+    case run
+    when :torque
+      count = (torque.to_f / 10).round
+      char = 'T'
+      val = torque.round.to_s.rjust(5, ' ')
+      fmt = "%s Nm"
+    when :power
+      power = DrivingPhysics.power(torque, omega)
+      kw = power.to_f / 1000
+      count = (kw / 5).round
+      char = 'P'
+      val = kw.round(1).to_s.rjust(5, ' ')
+      fmt = "%s kW"
+    else
+      raise "unknown"
+    end
+    puts format("%s RPM: #{fmt}\t%s",
+                rpm.to_s.rjust(4, ' '),
+                val,
+                char * count)
+  }
 }
 
 puts
+puts "Now, the simulation begins..."
+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."
@@ -36,12 +62,16 @@ duration = 60
 status = :ignition
 rpm = 0
 
-(duration * env.hz + 1).times { |i|
+paused = 0.0
+num_ticks = duration * env.hz + 1
+start = Timer.now
+
+num_ticks.times { |i|
   # this is an input torque; alpha is determined after inertia and friction
   torque = case status
            when :ignition
              motor.starter_torque
-           when :running
+           when :running, :off_throttle, :idling
              motor.torque(rpm)
            else
              0
@@ -58,32 +88,54 @@ rpm = 0
   omega = 0 if omega < 0.00001
   rpm = DrivingPhysics.rpm(omega)
 
+  power = DrivingPhysics.power(net_torque, omega)
+
   if rpm > motor.idle_rpm and status == :ignition
     status = :running
     flag = true
   end
 
   if rpm > 7000 and status == :running
-    status = :off
+    status = :off_throttle
+    motor.throttle = 0.0
     flag = true
   end
 
+  if rpm < 1000 and status == :off_throttle
+    status = :idling
+    motor.throttle = 0.06
+    flag = true
+  end
+
+  if status == :idling
+    if rpm < 999
+      motor.throttle += (1.0 - motor.throttle) * 0.005
+    elsif rpm > 1001
+      motor.throttle -= motor.throttle * 0.005
+    end
+  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",
+    (i % 5000 == 0) or
+    (status == :idling and i % 100 == 0)
+    puts Timer.display(i)
+    puts format("Throttle: %.1f%%", motor.throttle * 100)
+    puts format("%d RPM  %.1f Nm (%d Nm)  %.1f kW   Friction: %.1f Nm",
                 DrivingPhysics.rpm(omega),
                 net_torque,
                 torque,
+                power / 1000,
                 motor.spinner.rotating_friction(omega))
     puts format("%d rad  %.1f rad/s  %.1f rad/s/s", theta, omega, alpha)
     puts
 
-    CLI.pause if flag
+    paused += CLI.pause if flag
     flag = false
   end
 }
+
+puts Timer.summary(start, num_ticks, paused)

data/demo/powertrain.rb

@@ -1,6 +1,7 @@
 require 'driving_physics/powertrain'
 require 'driving_physics/imperial'
 require 'driving_physics/cli'
+require 'driving_physics/power'
 
 include DrivingPhysics
 
@@ -8,6 +9,7 @@ env = Environment.new
 motor = Motor.new(env)
 gearbox = Gearbox.new(env)
 powertrain = Powertrain.new(motor, gearbox)
+motor.throttle = 1.0
 puts env
 puts powertrain
 CLI.pause
@@ -18,23 +20,28 @@ crank_omega = 0.0
 axle_alpha = 0.0
 axle_omega = 0.0
 
-
 # Run through the gears
-
 1.upto(6) { |gear|
-  powertrain.select_gear(gear)
+  gearbox.gear = gear
 
   puts <<EOF
 
-# GEAR #{gear} (#{powertrain.gearbox.ratio})
+# GEAR #{gear} (#{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)
+    next unless rpm % 200 == 0
+
+    power, axle_torque, axle_omega = powertrain.output(rpm)
+    kw = power / 1000.to_f
+    mph = Imperial.mph(Disk.tangential(axle_omega, 0.32))
+    ps = Imperial.ps(kw)
+    puts format("%s RPM: %s Nm  %s kW  %s PS\t%s mph",
+                rpm.round.to_s.rjust(4, ' '),
+                axle_torque.round(1).to_s.rjust(5, ' '),
+                kw.round(1).to_s.rjust(5, ' '),
+                ps.round.to_s.rjust(4, ' '),
+                mph.round.to_s.rjust(3, ' '))
   }
 }

data/demo/scalar_force.rb

@@ -1,26 +1,52 @@
 require 'driving_physics/scalar_force'
+require 'driving_physics/environment'
+require 'driving_physics/cli'
 
-DP = DrivingPhysics
+include DrivingPhysics
+
+env = Environment.new
+puts env
 
-pos = 0               # m
-spd = 0               # m/s
 mass = 1000           # kg
-weight = mass * DP::G # N
+weight = mass * env.g # N
 drive_force = 7000    # N
 duration = 100        # seconds
-tick = 1.0 / DP::HZ
 
-(duration * DP::HZ).times { |i|
-  nf = drive_force - DP::ScalarForce.all_resistance(spd, nf_mag: weight)
+puts format("Force: %d N  Mass: %d kg for %d seconds",
+            drive_force, mass, duration)
+CLI.pause
+
+spd = 0.0 # m/s
+pos = 0.0 # m
+num_ticks = duration * env.hz + 1
+
+flag = false
+phase = :accelerate
+paused = 0.0
+start = Timer.now
+
+num_ticks.times { |i|
+  # TODO: make the resistance force negative
+  net_force = drive_force + ScalarForce.all_resistance(spd, nf_mag: weight)
 
-  a = DP.acc(nf, mass)
-  spd = DP.vel(spd, a, dt: tick)
-  pos = DP.pos(pos, spd, dt: tick)
+  acc = DrivingPhysics.acc(net_force, mass)
+  spd += acc * env.tick
+  pos += spd * env.tick
 
-  if i % DP::HZ == 0
-    puts [i / DP::HZ,
-          format("%.2f m/s", spd),
-          format("%.2f m", pos),
-         ].join("\t")
+  if phase == :accelerate and spd.magnitude > 100
+    flag = true
+    phase = :coast
+    drive_force = 0
+  end
+
+  if flag or (i % 1000 == 0)
+    puts format("%d  %.3f m/s/s  %.2f m/s  %.1f m",
+                i.to_f / env.hz, acc, spd, pos)
+    if flag
+      paused += CLI.pause
+      flag = false
+    end
   end
 }
+
+puts Timer.summary(start, num_ticks, paused)

data/demo/tire.rb

@@ -1,69 +1,69 @@
 require 'driving_physics/tire'
+require 'driving_physics/imperial'
+require 'driving_physics/cli'
 
 include DrivingPhysics
 
 env = Environment.new
 tire = Tire.new(env)
-
 puts env
 puts tire
+puts
 
-# 1000 kg car
-# 4 tires
-# 250 kg per tire plus tire mass
+duration = 100 # sec
+axle_torque = 500 # N*m
+supported_mass = 1500 # kg
+
+puts "Given:"
+puts "* #{axle_torque} Nm axle torque"
+puts "* #{supported_mass} kg supported mass"
+puts "* 4 tires"
+puts "* #{duration} seconds"
+puts
 
-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 "Therefore:"
+puts format("* %.1f kg total mass",  total_mass)
+puts format("* %.1f kg per corner",  corner_mass)
+puts format("* %.1f N normal force", normal_force)
 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
+puts "Tires:"
+puts format("* %.1f N traction", traction)
+puts format("* %.1f N drive force", drive_force)
 
-dist = 0.0  # meters
+CLI.pause
+
+acc = 0.0   # meters/s/s
 speed = 0.0 # meters/s
+dist = 0.0  # meters
 
-theta = 0.0 # radians
+alpha = 0.0 # radians/s/s
 omega = 0.0 # radians/s
+theta = 0.0 # radians
 
-t = Time.now
-num_ticks = duration * env.hz
+start = Timer.now
+paused = 0.0
+num_ticks = duration * env.hz + 1
 
 num_ticks.times { |i|
   torque = tire.net_tractable_torque(axle_torque,
-                                      mass: total_mass,
-                                      omega: omega,
-                                      normal_force: normal_force)
+                                     mass: total_mass,
+                                     omega: omega,
+                                     normal_force: normal_force)
   force = tire.force(torque)
 
   # translational kinematics
-  acc = DrivingPhysics.acc(force, supported_mass)
+  acc = DrivingPhysics.acc(force, total_mass)
   speed += acc * env.tick
   dist += speed * env.tick
+  mph = Imperial.mph(speed)
 
   # rotational kinematics
   alpha = acc / tire.radius
@@ -72,17 +72,16 @@ num_ticks.times { |i|
 
   if i < 10 or
     (i < 20_000 and i%1000 == 0) or
-    (i % 10_000 == 0) or
-    i == duration * env.hz - 1
+    (i % 10_000 == 0)
 
     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("   Car: %.1f m  %.2f m/s  %.3f m/s^2  (%d mph)",
+                dist, speed, acc, mph)
     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)
+puts Timer.summary(start, num_ticks, paused)

data/demo/vector_force.rb

@@ -1,26 +1,56 @@
 require 'driving_physics/vector_force'
+require 'driving_physics/environment'
+require 'driving_physics/cli'
 
-DP = DrivingPhysics
+include DrivingPhysics
+
+env = Environment.new
+puts env
 
-p = Vector[0, 0]      # m
-v = Vector[0, 0]      # m/s
 mass = 1000           # kg
-weight = mass * DP::G # N
+weight = mass * env.g # N
+drive_force = DrivingPhysics.random_unit_vector * 7000 # N
 duration = 100        # seconds
-drive_force = DP.random_unit_vector * 7000 # N
-tick = 1.0 / DP::HZ
 
-(duration * DP::HZ).times { |i|
-  nf = drive_force + DP::VectorForce.all_resistance(v, dir: v, nf_mag: weight)
+puts format("Force: %d N  Dir: %s",
+            drive_force.magnitude,
+            DrivingPhysics.compass_dir(drive_force.normalize))
+puts format("Mass: %d kg for %d seconds", mass, duration)
+CLI.pause
+
+acc = Vector[0, 0] # m/s/s
+vel = Vector[0, 0] # m/s
+pos = Vector[0, 0] # m
+
+num_ticks = duration * env.hz + 1
+
+flag = false
+phase = :accelerate
+paused = 0.0
+start = Timer.now
 
-  a = DP.acc(nf, mass)
-  v = DP.vel(v, a, dt: tick)
-  p = DP.pos(p, v, dt: tick)
+num_ticks.times { |i|
+  net_force = drive_force +
+              VectorForce.all_resistance(vel, dir: vel, nf_mag: weight)
 
-  if i % DP::HZ == 0
-    puts [i / DP::HZ,
-          format("%.2f m/s", v.magnitude),
-          format("%.2f m", p.magnitude),
-         ].join("\t")
+  acc = DrivingPhysics.acc(net_force, mass)
+  vel += acc * env.tick
+  pos += vel * env.tick
+
+  if phase == :accelerate and vel.magnitude > 100
+    flag = true
+    phase = :coast
+    drive_force = Vector[0, 0]
+  end
+
+  if flag or (i % 1000 == 0)
+    puts format("%d  %.3f m/s/s  %.2f m/s  %.1f m",
+                i.to_f / env.hz, acc.magnitude, vel.magnitude, pos.magnitude)
+    if flag
+      paused = CLI.pause
+      flag = false
+    end
   end
 }
+
+puts Timer.summary(start, num_ticks, paused)

data/lib/driving_physics/car.rb

@@ -4,20 +4,40 @@ require 'driving_physics/powertrain'
 module DrivingPhysics
   class Car
     attr_reader :tire, :powertrain, :env
-    attr_accessor :num_tires, :mass, :frontal_area, :cd
+    attr_accessor :num_tires, :body_mass, :frontal_area, :cd
 
     def initialize(tire:, powertrain:)
       @num_tires = 4
       @tire = tire
       @env = @tire.env
       @powertrain = powertrain
-      @mass = Rational(1000)
+      @body_mass = 1000.0
       @frontal_area = DrivingPhysics::FRONTAL_AREA
       @cd = DrivingPhysics::DRAG_COF
 
       yield self if block_given?
     end
 
+    def throttle
+      @powertrain.motor.throttle
+    end
+
+    def throttle=(val)
+      @powertrain.motor.throttle = val
+    end
+
+    def gear
+      @powertrain.gearbox.gear
+    end
+
+    def gear=(val)
+      @powertrain.gearbox.gear = val
+    end
+
+    def top_gear
+      @powertrain.gearbox.top_gear
+    end
+
     # force opposing speed
     def air_force(speed)
       -0.5 * @frontal_area * @cd * @env.air_density * speed ** 2
@@ -59,7 +79,7 @@ module DrivingPhysics
         format("Fr.A: %.2f m^2", @frontal_area),
         format("cD: %.2f", @cd),
        ].join(' | '),
-       format("Powertrain: %s", @powertrain),
+       format("POWERTRAIN:\n%s", @powertrain),
        format("Tires: %s", @tire),
        format("Corner mass: %.1f kg | Normal force: %.1f N",
               self.corner_mass, self.normal_force),
@@ -79,7 +99,7 @@ module DrivingPhysics
     end
 
     def total_mass
-      @mass + @tire.mass * @num_tires
+      @body_mass + @powertrain.mass + @tire.mass * @num_tires
     end
 
     def corner_mass

data/lib/driving_physics/cli.rb

@@ -7,11 +7,45 @@ module DrivingPhysics
       $stdin.gets.chomp
     end
 
-    # press Enter to continue
+    # press Enter to continue, ignore input, return elapsed time
     def self.pause(msg = '')
+      t = Timer.now
       puts msg unless msg.empty?
       puts '     [ Press Enter ]'
       $stdin.gets
+      Timer.since(t)
+    end
+  end
+
+  module Timer
+    if defined? Process::CLOCK_MONOTONIC
+      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/disk.rb

@@ -130,8 +130,9 @@ module DrivingPhysics
       @normal_force
     end
 
-    def alpha(torque)
-      torque / self.rotational_inertia
+    def alpha(torque, omega: 0, normal_force: nil)
+      (torque - self.rotating_friction(omega, normal_force: normal_force)) /
+        self.rotational_inertia
     end
 
     def implied_torque(alpha)
@@ -175,10 +176,10 @@ module DrivingPhysics
     # maybe not physically faithful but close enough
     def rotating_friction(omega, normal_force: nil)
       return omega if omega.zero?
+      normal_force = self.normal_force if normal_force.nil?
       mag = omega.abs
       sign = omega / mag
-      -1 * sign * (normal_force || self.normal_force) *
-       (@base_friction + @omega_friction * mag)
+      -1 * sign * normal_force * (@base_friction + mag * @omega_friction)
     end
   end
 end

data/lib/driving_physics/imperial.rb

@@ -7,6 +7,7 @@ module DrivingPhysics
     MPH = (FEET_PER_METER / FEET_PER_MILE) * SECS_PER_HOUR
     CI_PER_LITER = 61.024
     GAL_PER_LITER = 0.264172
+    PS_PER_KW = 1.3596216173039
 
     def self.feet(meters)
       meters * FEET_PER_METER
@@ -36,6 +37,11 @@ module DrivingPhysics
       DP::kph(mps(mph))
     end
 
+    # convert kilowatts to horsepower
+    def self.ps(kw)
+      kw * PS_PER_KW
+    end
+
     def self.deg_c(deg_f)
       (deg_f - 32).to_f * 5 / 9
     end

data/lib/driving_physics/motor.rb

@@ -6,10 +6,11 @@ module DrivingPhysics
     class OverRev < RuntimeError; end
     class SanityCheck < RuntimeError; end
 
-    TORQUES = [  0,   50,  130,  200,  250,  320,  330,  320,  260,    0]
+    TORQUES = [  0,   70,  130,  200,  250,  320,  330,  320,  260,    0]
     RPMS    = [500, 1000, 1500, 2000, 2500, 3500, 5000, 6000, 7000, 7100]
+    ENGINE_BRAKING = 0.2 # 20% of the torque at a given RPM
 
-    attr_reader :env
+    attr_reader :env, :throttle
     attr_accessor :torques, :rpms, :fixed_mass,
                   :spinner, :starter_torque, :idle_rpm
 
@@ -29,10 +30,12 @@ module DrivingPhysics
       }
       @starter_torque = 500  # Nm
       @idle_rpm       = 1000 # RPM
+      @throttle       = 0.0  # 0.0 - 1.0 (0% - 100%)
     end
 
     def to_s
-      ary = ["Torque:"]
+      ary = [format("Throttle: %.1f%%", @throttle * 100)]
+      ary << "Torque:"
       @rpms.each_with_index { |r, i|
         ary << format("%s Nm %s RPM",
                       @torques[i].round(1).to_s.rjust(4, ' '),
@@ -51,6 +54,13 @@ module DrivingPhysics
       @spinner.mass + @fixed_mass
     end
 
+    def throttle=(val)
+      if val < 0.0 or val > 1.0
+        raise(ArgumentError, "val #{val.inspect} should be between 0 and 1")
+      end
+      @throttle = val
+    end
+
     # given torque, determine crank alpha after inertia and friction
     def alpha(torque, omega: 0)
       @spinner.alpha(torque + @spinner.rotating_friction(omega))
@@ -60,17 +70,6 @@ module DrivingPhysics
       @spinner.implied_torque(alpha)
     end
 
-    # How much torque is required to accelerate spinner up to alpha,
-    # overcoming both inertia and friction
-    # Presumably we have more input torque available, but this will be
-    # used to do more work than just spinning up the motor
-    #
-    #def resistance_torque(alpha, omega)
-    #  # reverse sign on inertial_torque as it is not modeled as a resistance
-    #  -1 * @spinner.inertial_torque(alpha) +
-    #    @spinner.rotating_friction(omega)
-    #end
-
     # interpolate based on torque curve points
     def torque(rpm)
       raise(Stall, "RPM #{rpm}") if rpm < @rpms.first
@@ -78,22 +77,27 @@ module DrivingPhysics
 
       last_rpm = 99999
       last_tq = -1
+      torque = nil
 
       # ew; there must be a better way
       @rpms.each_with_index { |r, i|
         tq = @torques[i]
         if last_rpm <= rpm and rpm <= r
           proportion = Rational(rpm - last_rpm) / (r - last_rpm)
-          return last_tq + (tq - last_tq) * proportion
+          torque = last_tq + (tq - last_tq) * proportion
+          break
         end
         last_rpm = r
         last_tq = tq
       }
-      raise(SanityCheck, "RPM #{rpm}")
-    end
-
-    def net_torque(rpm, alpha: 0)
-      torque(rpm) + resistance_torque(alpha, DrivingPhysics.omega(rpm))
+      raise(SanityCheck, "RPM #{rpm}") if torque.nil?
+
+      if (@throttle <= 0.05) and (rpm > @idle_rpm * 1.5)
+        # engine braking: 20% of torque
+        -1 * torque * ENGINE_BRAKING
+      else
+        torque * @throttle
+      end
     end
   end
 end

data/lib/driving_physics/powertrain.rb

@@ -2,6 +2,11 @@ require 'driving_physics/motor'
 require 'driving_physics/gearbox'
 
 module DrivingPhysics
+  # Powertrain right now is pretty simple.  It combines the motor with the
+  # gearbox.  It is focused on operations that require or involve both
+  # components. It does not pass through operations to the motor or gearbox.
+  # Instead, it provides direct access to each component.
+  #
   class Powertrain
     attr_reader :motor, :gearbox
 
@@ -10,12 +15,18 @@ module DrivingPhysics
       @gearbox = gearbox
     end
 
+    def mass
+      @motor.mass + @gearbox.mass
+    end
+
     def to_s
       ["\t[MOTOR]", @motor, "\t[GEARBOX]", @gearbox].join("\n")
     end
 
-    def select_gear(gear)
-      @gearbox.gear = gear
+    # returns [power, torque, omega]
+    def output(rpm)
+      t, o = self.axle_torque(rpm), self.axle_omega(rpm)
+      [t * o, t, o]
     end
 
     def axle_torque(rpm)

data/lib/driving_physics/scalar_force.rb

@@ -18,20 +18,23 @@ module DrivingPhysics
     # Note: here we only consider speed; we're in a 1D world for now
     #
 
+    # opposes the direction of speed
     def self.air_resistance(speed,
                             frontal_area: FRONTAL_AREA,
                             drag_cof: DRAG_COF,
                             air_density: AIR_DENSITY)
-      0.5 * frontal_area * drag_cof * air_density * speed ** 2
+      -1 * 0.5 * frontal_area * drag_cof * air_density * speed ** 2
     end
 
+    # opposes the direction of speed
     def self.rotational_resistance(speed, rot_cof: ROT_COF)
-      speed * rot_cof
+      -1 * speed * rot_cof
     end
 
+    # opposes the direction of speed
     # normal force is not always mass * G, e.g. aero downforce
     def self.rolling_resistance(normal_force, roll_cof: ROLL_COF)
-      normal_force * roll_cof
+      -1 * normal_force * roll_cof
     end
 
     #

data/lib/driving_physics/tire.rb

@@ -83,7 +83,7 @@ module DrivingPhysics
       5.times {
         acc = DrivingPhysics.acc(drive_force - force_loss, driven_mass)
         alpha = acc / @radius
-        force_loss = self.inertial_torque(alpha) / @radius
+        force_loss = self.implied_torque(alpha) / @radius
       }
       force_loss * @radius
     end

data/lib/driving_physics.rb

@@ -36,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/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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: driving_physics
 version: !ruby/object:Gem::Version
-  version: 0.0.1.1
+  version: 0.0.1.2
 platform: ruby
 authors:
 - Rick Hull