driving_physics 0.0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4b32478386d13b88eb67f9d2bb826c23dd06dd5100d807aa918cea6af962c6e3
+  data.tar.gz: 3ebcad787d058dac2d36718d46e5cf400dcc968f06427d2f65af4d1682f99166
+SHA512:
+  metadata.gz: 4ce4c55bbb0e9e5f12146856c45df05860443b18d7fd54c173e8b3026e55e1c8ccdfa3e9d48a6974af5f28c79e6df04b487c9728d5a831ec88d657a7ce997db1
+  data.tar.gz: 28ea2e0361cc180a5a405ed66caffcced3d1669ec18b87ce14f3ab0d77d130de9bd92864a2b78bddbcee236fff7bd982d66272456c4ba81eec43b863691e044d

data/README.md

@@ -0,0 +1,83 @@
+[![CI Status](https://github.com/rickhull/driving_physics/actions/workflows/ci.yaml/badge.svg)](https://github.com/rickhull/driving_physics/actions/workflows/ci.yaml)
+
+# Driving Simulation
+
+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**.
+
+## Rationale
+
+This is a toy project intended to scratch a personal itch: I want to create
+an environment to play with performance objectives under reasonable real-world
+constraints:
+
+Primarily, one must slow down in order to navigate a curve
+quickly.
+
+All of this is done with an eye towards handing the controls over to an AI,
+likely a neural net, so that it can learn (and possibly teach) techniques
+that increase performance via decreasing lap times.
+
+## Rough Notes, Thoughts, and Objectives
+
+### Constraints:
+
+1. cars must slow down to make tighter turns
+2. cars must manage grip levels
+3. equations to describe available grip
+4. grip depends on tires and road surface (coefficient of grip)
+5. grip "releases", whereby car controls lose effectiveness (sliding)
+6. higher speed means higher turning radius
+7. more mass (weight) means more grip, but also more force opposing that grip
+8. one clear downside of more mass is increased tire wear and tire heat
+9. tires get more grip with more heat up to a critical temp and then grip
+   falls off dramatically
+10. heat cycles (overheat and then cool down) reduce grip capacity over time
+11. sliding dramatically increases tire wear and decreases grip
+12. tire wear minimally affects grip (outside of heat cycling), up until tire
+    is completely worn
+13. sliding implies a gentle reduction of velocity over time, all things equal
+14. wheelspin may occur on driven wheels (different from brake- or
+    turn-induced sliding)
+15. wheelspin incurs similar wear and heat penalties to sliding (relative
+    velocity between tire and surface)
+
+### Given These Constraints:
+
+1. Car has enough power to create wheelspin (force applied to driven wheels
+   exceeds grip-reactive force)
+2. Car can achieve velocity that requires braking to successfully achieve a
+   given turn radius
+3. Grip level can be modeled as the ability to sustain acceleration around 1G
+4. Consider slip angles and modulated sliding (e.g. threshold braking, mild
+   wheelspin, limit-of-grip controlled slides)
+5. Fuel consumption reduces mass over time
+6. Driving outputs: gas pedal position (0-100), brake pedal position (0-100),
+   steering wheel position (-100 - +100)
+7. Car slows gently with 0 gas pedal
+8. Car consumes fuel gently with 0 gas pedal (idle)
+9. Car consumes fuel linearly with gas pedal position
+10. Brakes wear with brake usage (linear plus heat factor)
+11. Brakes can overheat
+12. Hot brakes wear faster
+13. Driving inputs: visual track position, fuel gauge, tire temp, brake temp
+
+### Examples
+
+Given:
+* 1.0 g lateral acceleration
+* 100 ft radius turn
+
+How fast can the car go around the turn?
+
+```
+Vmax = sqrt(r) * sqrt(a) = sqrt(r*a)
+Vmax = sqrt(100 ft * 32.2 ft / sec^2)
+Vmax = sqrt(3220) ft/sec = 56.75 ft/sec
+
+56.75 ft/sec * 3600 sec/hr / 5280 ft/mile
+56.75 ft/sec * 3600/5280 = 38.7 mph
+```

data/Rakefile

@@ -0,0 +1,62 @@
+require 'rake/testtask'
+
+Rake::TestTask.new :test do |t|
+  t.pattern = "test/*.rb"
+  t.warning = true
+end
+
+desc "Run demo scripts"
+task demo: [:test] do
+  Dir['demo/*.rb'].each { |filepath|
+    puts
+    sh "ruby -w -Ilib #{filepath}"
+    puts
+  }
+end
+
+task default: :test
+
+#
+# METRICS
+#
+
+begin
+  require 'flog_task'
+  FlogTask.new do |t|
+    t.threshold = 9000
+    t.dirs = ['lib']
+    t.verbose = true
+  end
+rescue LoadError
+  warn 'flog_task unavailable'
+end
+
+begin
+  require 'flay_task'
+  FlayTask.new do |t|
+    t.dirs = ['lib']
+    t.verbose = true
+  end
+rescue LoadError
+  warn 'flay_task unavailable'
+end
+
+begin
+  require 'roodi_task'
+  # RoodiTask.new config: '.roodi.yml', patterns: ['lib/**/*.rb']
+  RoodiTask.new patterns: ['lib/**/*.rb']
+rescue LoadError
+  warn "roodi_task unavailable"
+end
+
+begin
+  require 'buildar'
+
+  Buildar.new do |b|
+    b.gemspec_file = 'driving_physics.gemspec'
+    b.version_file = 'VERSION'
+    b.use_git = true
+  end
+rescue LoadError
+  warn "buildar tasks unavailable"
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.0.2

data/demo/car.rb

@@ -0,0 +1,28 @@
+require 'driving_physics/car'
+
+DP = DrivingPhysics
+
+env = DP::Environment.new
+car = DP::Car.new(env)
+car.add_fuel 10
+duration = 120 # seconds
+
+puts env
+puts
+puts car
+
+car.controls.drive_pedal = 1.0
+
+(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
+    end
+    puts
+    puts "[t = #{i / env.hz}]"
+    puts car
+    gets if i % (env.hz * 10) == 0
+  end
+}

data/demo/scalar_force.rb

@@ -0,0 +1,26 @@
+require 'driving_physics/scalar_force'
+
+DP = DrivingPhysics
+
+pos = 0               # m
+spd = 0               # m/s
+mass = 1000           # kg
+weight = mass * DP::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)
+
+  a = DP.a(nf, mass)
+  spd = DP.v(a, spd, dt: tick)
+  pos = DP.p(spd, pos, dt: tick)
+
+  if i % DP::HZ == 0
+    puts [i / DP::HZ,
+          format("%.2f m/s", spd),
+          format("%.2f m", pos),
+         ].join("\t")
+  end
+}

data/demo/tire.rb

@@ -0,0 +1,169 @@
+require 'driving_physics/tire'
+
+include DrivingPhysics
+
+t = Tire.new
+t.condition.debug_temp = false
+
+# drive time
+mins = 45
+
+drive_map = {
+  acc: {
+    label: "ACCELERATING",
+    g: 0.5,
+    fuel: 0.0002, # kg consumed / tick
+    small_slide: 1, # m/s of wheelspin
+    big_slide: 10,
+    seconds: 1,
+    next_sector: :brake,
+  },
+  brake: {
+    label: "BRAKING",
+    g: 1.0,
+    fuel: 0.00001,
+    small_slide: 0.5,
+    big_slide: 2,
+    seconds: 1,
+    next_sector: :corner,
+  },
+  corner: {
+    label: "CORNERING",
+    g: 0.8,
+    fuel: 0.0001,
+    small_slide: 0.5,
+    big_slide: 5,
+    seconds: 2,
+    next_sector: :acc,
+  },
+}
+
+slide_speed = 0
+sliding = false
+mass = 900.0
+ambient_temp = 25
+critical_temp = 100
+
+drive_time = 0   # how many ticks elapsed in the current sector
+sector_map = drive_map[:acc]
+puts "ACCELERATING"
+puts "---"
+
+cooldown = false
+pushing = false
+
+# 100 ticks / sec
+(mins * 60 * 100).times { |i|
+  drive_time += 1
+
+  dynamic_g = sector_map[:g]
+
+  if t.condition.temp_c <= 80 and cooldown
+    puts "ENDING COOLDOWN"
+    cooldown = false
+  elsif t.condition.temp_c >= 110 and Random.rand(100) >= 90
+    puts "COOLING DOWN"
+    cooldown = true
+  end
+  dynamic_g -= 0.2 if cooldown
+
+  if pushing
+    # stop pushing at very high temp
+    # 1/1000 chance to stop pushing
+    if cooldown
+      puts "ENDING PUSH BECAUSE COOLDOWN"
+      pushing = false
+    else
+      if t.condition.temp_c >= critical_temp and Random.rand(1000) >= 999
+        puts "ENDING PUSH"
+        pushing = false
+      else
+        dynamic_g += 0.2
+      end
+    end
+  else
+    if !cooldown and
+      t.condition.temp_c <= critical_temp and
+      Random.rand(1000) >= 999
+
+      puts "PUSHING!"
+      pushing = true
+      dynamic_g += 0.2
+    end
+  end
+
+  if sliding
+    # 5% chance to end the slide
+    if Random.rand(100) >= 95
+      puts "   -= CAUGHT THE SLIDE! =-"
+      sliding = false
+      slide_speed = 0
+    end
+  else
+    # 1% chance to start a small slide
+    # 0.1% chance to start a big slide
+    if Random.rand(100) >= 99
+      puts "   -= SMALL SLIDE! =-"
+      sliding = true
+      slide_speed = sector_map[:small_slide]
+    elsif Random.rand(1000) >= 999
+      puts "   -= BIG SLIDE! =-"
+      sliding = true
+      slide_speed = sector_map[:big_slide]
+    end
+  end
+
+  # fuel consumption
+  # 5L of fuel should last 5 minutes
+  # ~3.5 kg of fuel consumption
+  # 1.2e-4 kg / tick
+  mass -= sector_map[:fuel]
+
+  begin
+    t.condition.tick!(ambient_temp: ambient_temp, g: dynamic_g,
+                      slide_speed: slide_speed,
+                      mass: mass, tire_mass: 12, critical_temp: critical_temp)
+
+    if i % 10 == 0
+      condition = if pushing
+                    "Pushing"
+                  elsif cooldown
+                    "Cooldown"
+                  else
+                    "Normal"
+                  end
+
+      puts [sector_map[:label].ljust(12, ' '),
+            '%.2f' % dynamic_g,
+            '%.1f' % slide_speed,
+            '%.3f' % t.condition.temp_c,
+           ].join('  ')
+    end
+    if i % 600 == 0
+      puts
+      puts "Condition: #{condition}"
+      puts "Mass: #{'%.2f' % mass} kg"
+      if t.condition.tread_mm > 0
+        puts "Tread remaining: #{'%.3f' % t.condition.tread_mm}"
+      else
+        puts "Cords remaining: #{'%.3f' % t.condition.cords_mm}"
+      end
+      puts "Heat cycles: #{t.condition.heat_cycles}"
+      puts DrivingPhysics.elapsed_display(i * 10)
+      puts "[Enter] to continue"
+      gets
+    end
+  rescue Tire::Condition::Error => e
+    puts "FATAL:"
+    puts [e.class, e.message].join(': ')
+    break
+  end
+
+  if drive_time > sector_map[:seconds] * 100
+    sector_map = drive_map[sector_map[:next_sector]]
+    drive_time = 0
+    puts
+    puts sector_map[:label]
+    puts '---'
+  end
+}

data/demo/vector_force.rb

@@ -0,0 +1,26 @@
+require 'driving_physics/vector_force'
+
+DP = DrivingPhysics
+
+p = Vector[0, 0]      # m
+v = Vector[0, 0]      # m/s
+mass = 1000           # kg
+weight = mass * DP::G # 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)
+
+  a = DP.a(nf, mass)
+  v = DP.v(a, v, dt: tick)
+  p = DP.p(v, p, dt: tick)
+
+  if i % DP::HZ == 0
+    puts [i / DP::HZ,
+          format("%.2f m/s", v.magnitude),
+          format("%.2f m", p.magnitude),
+         ].join("\t")
+  end
+}

data/demo/wheel.rb

@@ -0,0 +1,84 @@
+require 'driving_physics/wheel'
+
+include DrivingPhysics
+
+env = Environment.new
+wheel = Wheel.new(env, mass: 25.0)
+
+puts env
+puts wheel
+
+# 1000 kg car
+# 4 tires
+# 250 kg per tire plus tire mass
+
+supported_mass = 1000 # kg
+total_mass = supported_mass + 4 * wheel.mass
+corner_mass = Rational(total_mass) / 4
+normal_force = corner_mass * env.g
+axle_torque = 1000 # N*m
+friction_loss = 0.05 # 5% friction / hysteresis loss
+
+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 = wheel.traction(normal_force)
+drive_force = wheel.force(axle_torque)
+inertial_loss = wheel.inertial_loss(axle_torque, supported_mass)
+friction_loss *= axle_torque # 5% of the axle torque
+
+# drive force = (axle torque - inertia - friction) limited by traction
+
+net_axle_torque = axle_torque - inertial_loss - friction_loss
+net_drive_force = wheel.force(net_axle_torque)
+net_drive_force = traction if net_drive_force > traction  # traction limited
+
+acc = DrivingPhysics.acc(net_drive_force, supported_mass) # translational
+
+puts [format("Traction: %.1f N", traction),
+      format("Drive force: %.1f N", drive_force),
+      format("Inertial loss: %.1f Nm", inertial_loss),
+      format("Friction loss: %.1f Nm", friction_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", acc / wheel.radius_m),
+     ].join("\n")
+puts
+
+duration = 100 # sec
+
+dist = 0.0  # meters
+speed = 0.0 # meters/s
+
+theta = 0.0 # radians
+omega = 0.0 # radians/s
+
+(duration * env.hz).times { |i|
+  # accumulate frictional losses with speed (omega)
+  omega_loss_cof = [wheel.omega_friction * omega, 1.0].min
+  slowed_acc = acc - acc * omega_loss_cof
+
+  # translational kinematics
+  speed += slowed_acc * env.tick
+  dist += speed * env.tick
+
+  # rotational kinematics
+  alpha = slowed_acc / wheel.radius_m
+  omega += alpha * env.tick
+  theta += omega * env.tick
+
+  if i < 10 or
+    (i < 10_000 and i%1000 == 0) or
+    (i % 10_000 == 0)
+    puts DrivingPhysics.elapsed_display(i)
+    puts format("Wheel: %.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, slowed_acc)
+    puts format("Omega Frictional Loss: %.1f%%", omega_loss_cof * 100)
+    puts "Press [enter]"
+    gets
+  end
+}

data/driving_physics.gemspec

@@ -0,0 +1,17 @@
+Gem::Specification.new do |s|
+  s.name = 'driving_physics'
+  s.summary = "WIP"
+  s.description = "WIP"
+  s.authors = ["Rick Hull"]
+  s.homepage = "https://github.com/rickhull/driving_physics"
+  s.license = "LGPL-3.0"
+
+  s.required_ruby_version = "> 2"
+
+  s.version = File.read(File.join(__dir__, 'VERSION')).chomp
+
+  s.files = %w[driving_physics.gemspec VERSION README.md Rakefile]
+  s.files += Dir['lib/**/*.rb']
+  s.files += Dir['test/**/*.rb']
+  s.files += Dir['demo/**/*.rb']
+end