driving_physics 0.0.0.2 → 0.0.1.2

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/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,103 @@
+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/1000r
+        fly.omega_friction = 2/10_000r
+      }
+      @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 = 99999
+      last_tq = -1
+      torque = nil
+
+      # 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)
+          torque = last_tq + (tq - last_tq) * proportion
+          break
+        end
+        last_rpm = r
+        last_tq = 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

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
 
     #