driving_physics 0.0.0.3 → 0.0.2.1

data/lib/driving_physics/disk.rb

@@ -0,0 +1,185 @@
+require 'driving_physics/environment'
+#require 'driving_physics/vector_force'
+
+module DrivingPhysics
+  # radius is always in meters
+  # force in N
+  # torque in Nm
+
+  # Rotational complements to acc/vel/pos
+  # alpha - angular acceleration (radians / s / s)
+  # omega - angular velocity (radians / s)
+  # theta - radians
+
+  # convert radians to revolutions; works for alpha/omega/theta
+  def self.revs(rads)
+    rads / (2 * Math::PI)
+  end
+
+  # convert revs to rads; works for alpha/omega/theta
+  def self.rads(revs)
+    revs * 2 * Math::PI
+  end
+
+  # convert rpm to omega (rads / s)
+  def self.omega(rpm)
+    self.rads(rpm / 60.0)
+  end
+
+  # convert omega to RPM (revs per minute)
+  def self.rpm(omega)
+    self.revs(omega) * 60
+  end
+
+  class Disk
+    DENSITY = 1.0 # kg / L
+
+    # torque = force * distance
+    def self.force(axle_torque, radius)
+      axle_torque / radius.to_f
+    end
+
+    # in m^3
+    def self.volume(radius, width)
+      Math::PI * radius ** 2 * width
+    end
+
+    # in L
+    def self.volume_l(radius, width)
+      volume(radius, width) * 1000
+    end
+
+    def self.density(mass, volume_l)
+      mass.to_f / volume_l
+    end
+
+    def self.mass(radius, width, density)
+      volume_l(radius, width) * density
+    end
+
+    # I = 1/2 (m)(r^2) for a disk
+    def self.rotational_inertia(radius, mass)
+      mass * radius**2 / 2.0
+    end
+    class << self
+      alias_method(:moment_of_inertia, :rotational_inertia)
+    end
+
+    # angular acceleration
+    def self.alpha(torque, inertia)
+      torque / inertia
+    end
+
+    # convert alpha/omega/theta to acc/vel/pos
+    def self.tangential(rotational, radius)
+      rotational * radius
+    end
+
+    # convert acc/vel/pos to alpha/omega/theta
+    def self.rotational(tangential, radius)
+      tangential.to_f / radius
+    end
+
+    # vectors only
+    def self.torque_vector(force, radius)
+      if !force.is_a?(Vector) or force.size != 2
+        raise(ArgumentError, "force must be a 2D vector")
+      end
+      if !radius.is_a?(Vector) or radius.size != 2
+        raise(ArgumentError, "radius must be a 2D vector")
+      end
+      force = Vector[force[0], force[1], 0]
+      radius = Vector[radius[0], radius[1], 0]
+      force.cross(radius)
+    end
+
+    # vectors only
+    def self.force_vector(torque, radius)
+      if !torque.is_a?(Vector) or torque.size != 3
+        raise(ArgumentError, "torque must be a 3D vector")
+      end
+      if !radius.is_a?(Vector) or radius.size != 2
+        raise(ArgumentError, "radius must be a 2D vector")
+      end
+      radius = Vector[radius[0], radius[1], 0]
+      radius.cross(torque) / radius.dot(radius)
+    end
+
+    attr_reader :env
+    attr_accessor :radius, :width, :density, :base_friction, :omega_friction
+
+    def initialize(env)
+      @env = env
+      @radius  = 0.35
+      @width   = 0.2
+      @density = DENSITY
+      @base_friction  = 5.0/100_000  # constant resistance to rotation
+      @omega_friction = 5.0/100_000  # scales with omega
+      yield self if block_given?
+    end
+
+    def to_s
+      [[format("%d mm x %d mm (RxW)", @radius * 1000, @width * 1000),
+        format("%.1f kg  %.2f kg/L", self.mass, @density),
+       ].join(" | "),
+      ].join("\n")
+    end
+
+    def normal_force
+      @normal_force ||= self.mass * @env.g
+      @normal_force
+    end
+
+    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)
+      alpha * self.rotational_inertia
+    end
+
+    def mass
+      self.class.mass(@radius, @width, @density)
+    end
+
+    def mass=(val)
+      @density = self.class.density(val, self.volume_l)
+      @normal_force = nil # force update
+    end
+
+    # in m^3
+    def volume
+      self.class.volume(@radius, @width)
+    end
+
+    # in L
+    def volume_l
+      self.class.volume_l(@radius, @width)
+    end
+
+    def rotational_inertia
+      self.class.rotational_inertia(@radius, self.mass)
+    end
+    alias_method(:moment_of_inertia, :rotational_inertia)
+
+    def force(axle_torque)
+      self.class.force(axle_torque, @radius)
+    end
+
+    def tangential(rotational)
+      self.class.tangential(rotational, @radius)
+    end
+
+    # modeled as a tiny but increasing torque opposing omega
+    # also scales with normal force
+    # 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 * (@base_friction + mag * @omega_friction)
+    end
+  end
+end

data/lib/driving_physics/gearbox.rb

@@ -0,0 +1,109 @@
+require 'driving_physics/disk'
+
+module DrivingPhysics
+  # Technically speaking, the gear ratio goes up with speed and down with
+  # torque.  But in the automotive world, it's customary to invert the
+  # relationship, where a bigger number means more torque and less speed.
+  # We'll store the truth, where the default final drive would be
+  # conventionally known as 3.73, but 1/3.73 will be stored.
+
+  # The gear ratio (above 1) multiplies speed and divides torque
+  # 5000 RPM is around 375 MPH with a standard wheel/tire
+  # 3.73 final drive reduces that to around 100 mph in e.g. 5th gear (1.0)
+  # Likewise, 1st gear is a _smaller_ gear ratio than 3rd
+  class Gearbox
+    class Disengaged < RuntimeError; end
+
+    RATIOS = [1/5r, 2/5r, 5/9r, 5/7r, 1r, 5/4r]
+    FINAL_DRIVE = 11/41r # 1/3.73
+
+    attr_accessor :gear, :ratios, :final_drive, :spinner, :fixed_mass
+
+    def initialize(env)
+      @ratios = RATIOS
+      @final_drive = FINAL_DRIVE
+      @gear = 0 # neutral
+
+      # represent all rotating mass
+      @spinner = Disk.new(env) { |m|
+        m.radius = 0.15
+        m.base_friction = 5.0/1000
+        m.omega_friction = 15.0/100_000
+        m.mass = 15
+      }
+      @fixed_mass = 30 # kg
+
+      yield self if block_given?
+    end
+
+    # given torque, apply friction, determine alpha
+    def alpha(torque, omega: 0)
+      @spinner.alpha(torque + @spinner.rotating_friction(omega))
+    end
+
+    def rotating_friction(omega)
+      @spinner.rotating_friction(omega)
+    end
+
+    def implied_torque(alpha)
+      @spinner.implied_torque(alpha)
+    end
+
+    def mass
+      @fixed_mass + @spinner.mass
+    end
+
+    def top_gear
+      @ratios.length
+    end
+
+    def to_s
+      [format("Ratios: %s", @ratios.inspect),
+       format(" Final: %s  Mass: %.1f kg  Rotating: %.1f kg",
+              @final_drive.inspect, self.mass, @spinner.mass),
+      ].join("\n")
+    end
+
+    def ratio(gear = nil)
+      gear ||= @gear
+      raise(Disengaged, "Cannot determine gear ratio") if @gear == 0
+      @ratios.fetch(gear - 1) * @final_drive
+    end
+
+    def axle_torque(crank_torque)
+      crank_torque / self.ratio
+    end
+
+    def axle_omega(crank_rpm)
+      DrivingPhysics.omega(crank_rpm) * self.ratio
+    end
+
+    def crank_rpm(axle_omega)
+      DrivingPhysics.rpm(axle_omega) / self.ratio
+    end
+
+    def match_rpms(old_rpm, new_rpm)
+      diff = new_rpm - old_rpm
+      proportion = diff.to_f / old_rpm
+      if proportion.abs < 0.01
+        [:ok, proportion]
+      elsif proportion.abs < 0.1
+        [:slip, proportion]
+      elsif @gear == 1 and new_rpm < old_rpm and old_rpm <= 1500
+        [:get_rolling, proportion]
+      else
+        [:mismatch, proportion]
+      end
+    end
+
+    def next_gear(rpm, floor: 2500, ceiling: 6400)
+      if rpm < floor and @gear > 1
+        @gear - 1
+      elsif rpm > ceiling and @gear < self.top_gear
+        @gear + 1
+      else
+        @gear
+      end
+    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

@@ -0,0 +1,150 @@
+require 'driving_physics/disk'
+
+module DrivingPhysics
+  class Motor
+    class Stall < RuntimeError; end
+    class OverRev < RuntimeError; end
+    class SanityCheck < RuntimeError; end
+
+    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, :throttle
+    attr_accessor :torques, :rpms, :fixed_mass,
+                  :spinner, :starter_torque, :idle_rpm
+
+    def initialize(env)
+      @env = env
+
+      @torques = TORQUES
+      @rpms = RPMS
+      @fixed_mass = 125
+
+      # represent all rotating mass as one big flywheel
+      @spinner = Disk.new(@env) { |fly|
+        fly.radius =  0.25 # m
+        fly.mass   = 75    # kg
+        fly.base_friction  = 5.0/1000
+        fly.omega_friction = 2.0/10_000
+      }
+      @starter_torque = 500  # Nm
+      @idle_rpm       = 1000 # RPM
+      @throttle       = 0.0  # 0.0 - 1.0 (0% - 100%)
+    end
+
+    def to_s
+      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, ' '),
+                      r.to_s.rjust(5, ' '))
+      }
+      ary << format("Mass: %.1f kg  Fixed: %d kg", self.mass, @fixed_mass)
+      ary << format("Rotating: %s", @spinner)
+      ary.join("\n")
+    end
+
+    def rotational_inertia
+      @spinner.rotational_inertia
+    end
+
+    def mass
+      @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))
+    end
+
+    def implied_torque(alpha)
+      @spinner.implied_torque(alpha)
+    end
+
+    # interpolate based on torque curve points
+    def torque(rpm)
+      raise(Stall, "RPM #{rpm}") if rpm < @rpms.first
+      raise(OverRev, "RPM #{rpm}") if rpm > @rpms.last
+
+      last_rpm, last_tq, torque = 99999, -1, nil
+
+      @rpms.each_with_index { |r, i|
+        tq = @torques[i]
+        if last_rpm <= rpm and rpm <= r
+          proportion = Rational(rpm - last_rpm) / (r - last_rpm)
+          torque = last_tq + (tq - last_tq) * proportion
+          break
+        end
+        last_rpm, last_tq = r, tq
+      }
+      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
+
+
+# TODO: starter motor
+# Starter motor is power limited, not torque limited
+# Consider:
+# * 2.2 kW (3.75:1 gear reduction)
+# * 1.8 kW  (4.4:1 gear reduction)
+# On a workbench, a starter will draw 80 to 90 amps. However, during actual
+# start-up of an engine, a starter will draw 250 to 350 amps.
+# from https://www.motortrend.com/how-to/because-theres-more-to-a-starter-than-you-realize/
+
+# V - Potential, voltage
+# I - Current, amperage
+# R - Resistance, ohms
+# P - Power, wattage
+
+# Ohm's law: I = V / R (where R is held constant)
+# P = I * V
+# For resistors (where R is helod constant)
+#   = I^2 * R
+#   = V^2 / R
+
+
+# torque proportional to A
+# speed proportional to V
+
+
+# batteries are rated in terms of CCA - cold cranking amps
+
+# P = I * V
+# V = 12 (up to 14ish)
+# I = 300
+# P = 3600 or 3.6 kW
+
+
+# A starter rated at e.g. 2.2 kW will use more power on initial cranking
+# Sometimes up to 500 amperes are required, and some batteries will provide
+# over 600 cold cranking amps
+
+
+# Consider:
+
+# V = 12
+# R = resistance of battery, wiring, starter motor
+# L = inductance (approx 0)
+# I = current through motor
+# Vc = proportional to omega
+
+# rated power - Vc * I
+# input power - V * I
+# input power that is unable to be converted to output power is wasted as heat

data/lib/driving_physics/mruby.rb

@@ -0,0 +1,45 @@
+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
+    def self.now
+      Time.now
+    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/power.rb

@@ -0,0 +1,20 @@
+require 'driving_physics'
+
+# Work is Force * Distance   (Torque * Theta)
+# W = F * s  (W = T * Th)
+# W = T * Theta
+
+# Power is Work / time
+# P = W / dt
+# P = T * Th / dt
+# P = T * Omega
+
+module DrivingPhysics
+  def self.work(force, displacement)
+    force * displacement
+  end
+
+  def self.power(force, speed)
+    force * speed
+  end
+end

data/lib/driving_physics/powertrain.rb

@@ -0,0 +1,50 @@
+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
+
+    def initialize(motor, gearbox)
+      @motor = motor
+      @gearbox = gearbox
+    end
+
+    def mass
+      @motor.mass + @gearbox.mass
+    end
+
+    def to_s
+      ["\t[MOTOR]", @motor, "\t[GEARBOX]", @gearbox].join("\n")
+    end
+
+    # 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)
+      crank_alpha = @motor.alpha(@motor.torque(rpm),
+                                 omega: DrivingPhysics.omega(rpm))
+      crank_torque = @motor.implied_torque(crank_alpha)
+
+      axle_alpha = @gearbox.alpha(@gearbox.axle_torque(crank_torque),
+                                  omega: @gearbox.axle_omega(rpm))
+      @gearbox.implied_torque(axle_alpha)
+    end
+
+    def axle_omega(rpm)
+      @gearbox.axle_omega(rpm)
+    end
+
+    def crank_rpm(axle_omega)
+      @gearbox.crank_rpm(axle_omega)
+    end
+  end
+end

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
 
     #