driving_physics 0.0.0.3 → 0.0.1.1

data/lib/driving_physics/disk.rb

@@ -0,0 +1,184 @@
+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  = 350/1000r # m
+      @width   = 200/1000r # m
+      @density = DENSITY
+      @base_friction  = 5/100_000r  # constant resistance to rotation
+      @omega_friction = 5/100_000r  # 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)
+      torque / 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?
+      mag = omega.abs
+      sign = omega / mag
+      -1 * sign * (normal_force || self.normal_force) *
+       (@base_friction + @omega_friction * mag)
+    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/1000r
+        m.omega_friction = 15/100_000r
+        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/motor.rb

@@ -0,0 +1,99 @@
+require 'driving_physics/disk'
+
+module DrivingPhysics
+  class Motor
+    class Stall < RuntimeError; end
+    class OverRev < RuntimeError; end
+    class SanityCheck < RuntimeError; end
+
+    TORQUES = [  0,   50,  130,  200,  250,  320,  330,  320,  260,    0]
+    RPMS    = [500, 1000, 1500, 2000, 2500, 3500, 5000, 6000, 7000, 7100]
+
+    attr_reader :env
+    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/1000r
+        fly.omega_friction = 2/10_000r
+      }
+      @starter_torque = 500  # Nm
+      @idle_rpm       = 1000 # RPM
+    end
+
+    def to_s
+      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
+
+    # 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
+
+    # How much torque is required to accelerate spinner up to alpha,
+    # overcoming both inertia and friction
+    # Presumably we have more input torque available, but this will be
+    # used to do more work than just spinning up the motor
+    #
+    #def resistance_torque(alpha, omega)
+    #  # reverse sign on inertial_torque as it is not modeled as a resistance
+    #  -1 * @spinner.inertial_torque(alpha) +
+    #    @spinner.rotating_friction(omega)
+    #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 = 99999
+      last_tq = -1
+
+      # ew; there must be a better way
+      @rpms.each_with_index { |r, i|
+        tq = @torques[i]
+        if last_rpm <= rpm and rpm <= r
+          proportion = Rational(rpm - last_rpm) / (r - last_rpm)
+          return last_tq + (tq - last_tq) * proportion
+        end
+        last_rpm = r
+        last_tq = tq
+      }
+      raise(SanityCheck, "RPM #{rpm}")
+    end
+
+    def net_torque(rpm, alpha: 0)
+      torque(rpm) + resistance_torque(alpha, DrivingPhysics.omega(rpm))
+    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,39 @@
+require 'driving_physics/motor'
+require 'driving_physics/gearbox'
+
+module DrivingPhysics
+  class Powertrain
+    attr_reader :motor, :gearbox
+
+    def initialize(motor, gearbox)
+      @motor = motor
+      @gearbox = gearbox
+    end
+
+    def to_s
+      ["\t[MOTOR]", @motor, "\t[GEARBOX]", @gearbox].join("\n")
+    end
+
+    def select_gear(gear)
+      @gearbox.gear = gear
+    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/tire.rb

@@ -0,0 +1,120 @@
+require 'driving_physics/disk'
+
+module DrivingPhysics
+
+  # a Tire is a Disk with lighter density and meaningful surface friction
+
+  class Tire < Disk
+    # Note, this is not the density of solid rubber.  This density
+    # yields a sensible mass for a wheel / tire combo at common radius
+    # and width, assuming a uniform density
+    # e.g. 25kg at 350mm R x 200mm W
+    #
+    DENSITY = 0.325  # kg / L
+
+    # * the traction force opposes the axle torque / drive force
+    #   thus, driving the car forward
+    # * if the drive force exceeds the traction force, slippage occurs
+    # * slippage reduces the available traction force further
+    # * if the drive force is not reduced, the slippage increases
+    #   until resistance forces equal the drive force
+    def self.traction(normal_force, cof)
+      normal_force * cof
+    end
+
+    attr_accessor :mu_s, :mu_k, :omega_friction, :base_friction, :roll_cof
+
+    def initialize(env)
+      @env = env
+      @radius = 350/1000r # m
+      @width  = 200/1000r # m
+      @density = DENSITY
+      @temp = @env.air_temp
+      @mu_s = 11/10r # static friction
+      @mu_k =  7/10r # kinetic friction
+      @base_friction = 5/10_000r
+      @omega_friction = 5/100_000r # scales with speed
+      @roll_cof = DrivingPhysics::ROLL_COF
+
+      yield self if block_given?
+    end
+
+    def to_s
+      [[format("%d mm x %d mm (RxW)", @radius * 1000, @width * 1000),
+        format("%.1f kg  %.1f C", self.mass, @temp),
+        format("cF: %.1f / %.1f", @mu_s, @mu_k),
+       ].join(" | "),
+      ].join("\n")
+    end
+
+    def wear!(amount)
+      @radius -= amount
+    end
+
+    def heat!(amount_deg_c)
+      @temp += amount_deg_c
+    end
+
+    def traction(nf, static: true)
+      self.class.traction(nf, static ? @mu_s : @mu_k)
+    end
+
+    # require a normal_force to be be passed in
+    def rotating_friction(omega, normal_force:)
+      super(omega, normal_force: normal_force)
+    end
+
+    # rolling loss in terms of axle torque
+    def rolling_friction(omega, normal_force:)
+      return omega if omega.zero?
+      mag = omega.abs
+      sign = omega / mag
+      -1 * sign * (normal_force * @roll_cof) * @radius
+    end
+
+    # inertial loss in terms of axle torque when used as a drive wheel
+    def inertial_loss(axle_torque, driven_mass:)
+      drive_force = self.force(axle_torque)
+      force_loss = 0
+      # The force loss depends on the acceleration, but the acceleration
+      # depends on the force loss.  Converge the value via 5 round trips.
+      # This is a rough way to compute an integral and should be accurate
+      # to 8+ digits.
+      5.times {
+        acc = DrivingPhysics.acc(drive_force - force_loss, driven_mass)
+        alpha = acc / @radius
+        force_loss = self.inertial_torque(alpha) / @radius
+      }
+      force_loss * @radius
+    end
+
+    def net_torque(axle_torque, mass:, omega:, normal_force:)
+      # friction forces oppose omega
+      net = axle_torque +
+            self.rolling_friction(omega, normal_force: normal_force) +
+            self.rotating_friction(omega, normal_force: normal_force)
+
+      # inertial loss has interdependencies; calculate last
+      # it opposes net torque, not omega
+      sign = net / net.abs
+      net - sign * self.inertial_loss(net, driven_mass: mass)
+    end
+
+    def net_tractable_torque(axle_torque,
+                             mass:, omega:, normal_force:, static: true)
+      net = self.net_torque(axle_torque,
+                            mass: mass,
+                            omega: omega,
+                            normal_force: normal_force)
+      tt = self.tractable_torque(normal_force, static: static)
+      net > tt ? tt : net
+    end
+
+    # this doesn't take inertial losses or internal frictional losses
+    # into account.  input torque required to saturate traction will be
+    # higher than what this method returns
+    def tractable_torque(nf, static: true)
+      traction(nf, static: static) * @radius
+    end
+  end
+end

data/lib/driving_physics/vector_force.rb

@@ -84,12 +84,25 @@ module DrivingPhysics
                             frontal_area: FRONTAL_AREA,
                             drag_cof: DRAG_COF,
                             air_density: AIR_DENSITY)
+      return velocity if velocity.zero?
       -1 * 0.5 * frontal_area * drag_cof * air_density *
        velocity * velocity.magnitude
     end
 
-    def self.rotational_resistance(velocity, rot_cof: ROT_COF)
-      -1 * velocity * rot_cof
+    # return a force opposing velocity, representing friction / hysteresis
+    def self.rotational_resistance(velocity,
+                                   rot_const: ROT_CONST,
+                                   rot_cof: ROT_COF)
+      return velocity if velocity.zero?
+      -1 * velocity * rot_cof + -1 * velocity.normalize * rot_const
+    end
+
+    # return a torque opposing omega, representing friction / hysteresis
+    def self.omega_resistance(omega,
+                              rot_const: ROT_TQ_CONST,
+                              rot_cof: ROT_TQ_COF)
+      return 0 if omega == 0.0
+      omega * ROT_TQ_COF + ROT_TQ_CONST
     end
 
     # dir is drive_force vector or velocity vector; will be normalized

data/lib/driving_physics.rb

@@ -26,6 +26,7 @@ module DrivingPhysics
   DRAG_COF = 0.3      # based roughly on 2000s-era Chevrolet Corvette
   DRAG = 0.4257       # air_resistance at 1 m/s given above numbers
   ROT_COF = 12.771    # if rotating resistance matches air resistance at 30 m/s
+  ROT_CONST = 0.05    # N opposing drive force / torque
   ROLL_COF = 0.01     # roughly: street tires on concrete
 
   #