driving_physics 0.0.0.2 → 0.0.1.2

data/demo/tire.rb

@@ -1,169 +1,87 @@
 require 'driving_physics/tire'
+require 'driving_physics/imperial'
+require 'driving_physics/cli'
 
 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
+env = Environment.new
+tire = Tire.new(env)
+puts env
+puts tire
+puts
+
+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
+
+total_mass = supported_mass + 4 * tire.mass
+corner_mass = Rational(total_mass) / 4
+normal_force = corner_mass * env.g
+
+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)
+
+puts "Tires:"
+puts format("* %.1f N traction", traction)
+puts format("* %.1f N drive force", drive_force)
+
+CLI.pause
+
+acc = 0.0   # meters/s/s
+speed = 0.0 # meters/s
+dist = 0.0  # meters
+
+alpha = 0.0 # radians/s/s
+omega = 0.0 # radians/s
+theta = 0.0 # radians
+
+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)
+  force = tire.force(torque)
+
+  # translational kinematics
+  acc = DrivingPhysics.acc(force, total_mass)
+  speed += acc * env.tick
+  dist += speed * env.tick
+  mph = Imperial.mph(speed)
+
+  # 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)
+
+    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  (%d mph)",
+                dist, speed, acc, mph)
+    puts format("Torque: %.1f Nm (%d N)  Loss: %.1f%%",
+                torque, force, (1.0 - torque / axle_torque) * 100)
     puts
-    puts sector_map[:label]
-    puts '---'
   end
 }
+
+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.a(nf, mass)
-  v = DP.v(a, v, dt: tick)
-  p = DP.p(v, p, 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)