driving_physics 0.0.0.3 → 0.0.2.1

data/demo/mruby/motor.rb

@@ -0,0 +1,137 @@
+
+# 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
+
+  # prevent silly oscillations due to ticks or tiny floating point errors
+  omega = 0 if omega < 0.0001
+
+  net_torque = motor.implied_torque(alpha)
+  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(ms: 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("%.3f rad/s/s  %.2f rad/s  %.1f rad", alpha, omega, theta)
+    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)

data/demo/tire.rb

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

data/lib/driving_physics/car.rb

@@ -0,0 +1,123 @@
+require 'driving_physics/tire'
+require 'driving_physics/powertrain'
+
+module DrivingPhysics
+  class Car
+    attr_reader :tire, :powertrain, :env
+    attr_accessor :num_tires, :body_mass, :frontal_area, :cd
+
+    def initialize(tire:, powertrain:)
+      @num_tires = 4
+      @tire = tire
+      @env = @tire.env
+      @powertrain = powertrain
+      @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
+    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:\n%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
+      @body_mass + @powertrain.mass + @tire.mass * @num_tires
+    end
+
+    def corner_mass
+      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,51 @@
+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, 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