driving_physics 0.0.0.2 → 0.0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b32478386d13b88eb67f9d2bb826c23dd06dd5100d807aa918cea6af962c6e3
-  data.tar.gz: 3ebcad787d058dac2d36718d46e5cf400dcc968f06427d2f65af4d1682f99166
+  metadata.gz: ef486c39982798a7331f49f601e648d520a65977161180631cc4c5d3340a9011
+  data.tar.gz: 9e30b74ae34cb77a711d5d9631983b0c070872900123a1dde2d3dd03bdab854b
 SHA512:
-  metadata.gz: 4ce4c55bbb0e9e5f12146856c45df05860443b18d7fd54c173e8b3026e55e1c8ccdfa3e9d48a6974af5f28c79e6df04b487c9728d5a831ec88d657a7ce997db1
-  data.tar.gz: 28ea2e0361cc180a5a405ed66caffcced3d1669ec18b87ce14f3ab0d77d130de9bd92864a2b78bddbcee236fff7bd982d66272456c4ba81eec43b863691e044d
+  metadata.gz: 46eaf512dad64ca39ec20451d7acce1b1819ecd64125ee858f92c26e5edd7b0ec0e7ef01af8f73daa0d37868e0ffd76bd3b29478093219cd906d8d9e38026bcd
+  data.tar.gz: ae2e01ae8e7986c9d2e659ff5a0934ed5359e20cf2757d7724118bb59e0fb0199180249815f2f28f55f48a2336511a0b43f0d6fab042ed5d20a5ab6a897baef1

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/Rakefile

@@ -32,10 +32,13 @@ rescue LoadError
 end
 
 begin
-  require 'flay_task'
-  FlayTask.new do |t|
-    t.dirs = ['lib']
-    t.verbose = true
+  # need to stop looking in old/ and also the scoring seems wack
+  if false
+    require 'flay_task'
+    FlayTask.new do |t|
+      t.dirs = ['lib']
+      t.verbose = true
+    end
   end
 rescue LoadError
   warn 'flay_task unavailable'
@@ -49,6 +52,10 @@ rescue LoadError
   warn "roodi_task unavailable"
 end
 
+#
+# GEM BUILD / PUBLISH
+#
+
 begin
   require 'buildar'
 

data/VERSION

@@ -1 +1 @@
-0.0.0.2
+0.0.1.2

data/demo/car.rb

@@ -1,28 +1,175 @@
 require 'driving_physics/car'
+require 'driving_physics/imperial'
+require 'driving_physics/cli'
 
-DP = DrivingPhysics
-
-env = DP::Environment.new
-car = DP::Car.new(env)
-car.add_fuel 10
-duration = 120 # seconds
+include DrivingPhysics
 
+env = Environment.new
 puts env
-puts
+
+tire = Tire.new(env)
+motor = Motor.new(env)
+gearbox = Gearbox.new(env)
+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
+}
 puts car
+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
+
+start = Timer.now
+paused = 0.0
+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 Timer.display(i)
+      puts format("%d rad  %d rad/s  %d rad/s/s",
+                  crank_theta, crank_omega, crank_alpha)
+      puts format("%d RPM  %d Nm starter torque", rpm, motor.starter_torque)
+      puts
+    end
+
+    if rpm > motor.idle_rpm
+      car.gear = 1
+      car.throttle = 1.0
+      phase = :running
+
+      puts <<EOF
+
+#
+# RUNNING
+#
+
+EOF
+    end
+  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
 
-car.controls.drive_pedal = 1.0
+    acc = DrivingPhysics.acc(force, car.total_mass)
+    speed += acc * env.tick
+    dist += speed * env.tick
 
-(duration * env.hz).times { |i|
-  car.tick!
-  if i % env.hz == 0
-    if car.sum_forces.magnitude < 1
-      car.controls.drive_pedal = 0.0
-      car.controls.brake_pedal = 1.0
+    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 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)
+      puts        "Resist: " + format(%w[Air Roll Spin Inertial].map { |s|
+                                        "#{s}: %.1f N"
+                                      }.join('  '), ar, rr, rf, ir)
+      puts
+      flag = false
     end
-    puts
-    puts "[t = #{i / env.hz}]"
-    puts car
-    gets if i % (env.hz * 10) == 0
+
+    # 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
+      paused += CLI.pause
+    end
+
+    case new_clutch
+    when :ok
+      rpm = new_rpm
+    when :mismatch
+      flag = true
+      puts '#'
+      puts '# LURCH!'
+      puts '#'
+      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.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
 }
+
+puts Timer.summary(start, num_ticks, paused)

data/demo/disk.rb

@@ -0,0 +1,83 @@
+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
+
+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
+
+dist = 0.0  # meters
+speed = 0.0 # meters/s
+
+theta = 0.0 # radians
+omega = 0.0 # radians/s
+
+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 == 18_950
+    flag = true
+    puts '#'
+    puts '# CUT POWER'
+    puts '#'
+    puts
+    axle_torque = 0
+  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 flag or i < 10 or
+    (i < 20_000 and i%1000 == 0) or
+    (i % 10_000 == 0) or
+    i == duration * env.hz - 1
+
+    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)
+    puts format("   Revs: %d revs  %d revs/s  %d rpm",
+                DrivingPhysics.revs(theta),
+                DrivingPhysics.revs(omega),
+                DrivingPhysics.rpm(omega))
+    puts
+    if flag
+      paused += CLI.pause
+      flag = false
+    end
+  end
+}
+
+puts Timer.summary(start, num_ticks, paused)

data/demo/gearbox.rb

@@ -0,0 +1,52 @@
+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
+
+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)
+
+  # 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 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

@@ -0,0 +1,141 @@
+require 'driving_physics/motor'
+require 'driving_physics/cli'
+require 'driving_physics/power'
+
+# next fun idea: PID controller
+
+include DrivingPhysics
+
+env = Environment.new
+motor = Motor.new(env)
+puts env
+puts motor
+puts
+
+puts "Rev it up!"
+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."
+CLI.pause
+
+alpha = 0.0
+omega = 0.0
+theta = 0.0
+
+duration = 60
+
+status = :ignition
+rpm = 0
+
+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, :off_throttle, :idling
+             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)
+
+  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_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) 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
+
+    paused += CLI.pause if flag
+    flag = false
+  end
+}
+
+puts Timer.summary(start, num_ticks, paused)

data/demo/powertrain.rb

@@ -0,0 +1,47 @@
+require 'driving_physics/powertrain'
+require 'driving_physics/imperial'
+require 'driving_physics/cli'
+require 'driving_physics/power'
+
+include DrivingPhysics
+
+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
+
+crank_alpha = 0.0
+crank_omega = 0.0
+
+axle_alpha = 0.0
+axle_omega = 0.0
+
+# Run through the gears
+1.upto(6) { |gear|
+  gearbox.gear = gear
+
+  puts <<EOF
+
+# GEAR #{gear} (#{gearbox.ratio})
+#
+EOF
+
+  800.upto(7000) { |rpm|
+    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.a(nf, mass)
-  spd = DP.v(a, spd, dt: tick)
-  pos = DP.p(spd, pos, 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)