driving_physics 0.0.0.2 → 0.0.1.2

data/lib/driving_physics/car.rb

@@ -1,294 +1,123 @@
-require 'driving_physics/environment'
-require 'driving_physics/vector_force'
 require 'driving_physics/tire'
+require 'driving_physics/powertrain'
 
 module DrivingPhysics
-  # treat instances of this class as immutable
   class Car
-    attr_accessor :mass, :min_turn_radius,
-                  :max_drive_force, :max_brake_clamp, :max_brake_force,
-                  :fuel_capacity, :brake_pad_depth, :driver_mass,
-                  :frontal_area, :cd, :fuel_consumption,
-                  :tires, :controls, :condition
-
-    def initialize(environment)
-      @environment = environment
-      @mass             = 1000  # kg, without fuel or driver
-      @min_turn_radius = 10     # meters
-      @max_drive_force = 7000   # N - 1000kg car at 0.7g acceleration
-      @max_brake_clamp = 100    # N
-      @max_brake_force = 40_000 # N - 2000kg car at 2g braking
-      @fuel_capacity   = 40     # L
-      @brake_pad_depth = 10     # mm
-      @driver_mass     = 75     # kg
-      @fuel_consumption = 0.02  # L/s at full throttle
-
-      @frontal_area = DrivingPhysics::FRONTAL_AREA # m^2
+    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
 
-      @tires = Tire.new
-      @controls = Controls.new
-      @condition = Condition.new(brake_temp: @environment.air_temp,
-                                 brake_pad_depth: @brake_pad_depth)
-
-      # consider downforce
-      # probably area * angle
-      # goes up with square of velocity
-
       yield self if block_given?
     end
 
-    def to_s
-      [[format("Mass: %.1f kg", total_mass),
-        format("Power: %.1f kN", @max_drive_force.to_f / 1000),
-        format("Brakes: %.1f kN", @max_brake_force.to_f / 1000),
-        format("Fr.A: %.2f m^2", @frontal_area),
-        format("cD: %.2f", @cd),
-       ].join(' | '),
-       [format("Op: %d N", drive_force - brake_force),
-        format("Drive: %d N", drive_force),
-        format("Brake: %d N", brake_force),
-       ].join(' | '),
-       [format("Net: %.1f N", sum_forces.magnitude),
-        format("Air: %.1f N", air_resistance.magnitude),
-        format("Rot: %.1f N", rotational_resistance.magnitude),
-        format("Roll: %.1f N", rolling_resistance.magnitude),
-       ].join(' | '),
-        @controls, @condition, @tires,
-      ].join("\n")
+    def throttle
+      @powertrain.motor.throttle
     end
 
-    def tick!
-      @condition.tick!(force: sum_forces,
-                       mass: total_mass,
-                       tire: @tires,
-                       env: @environment)
-
-      @condition.consume_fuel(@fuel_consumption *
-                              @controls.drive_pedal *
-                              @environment.tick)
+    def throttle=(val)
+      @powertrain.motor.throttle = val
     end
 
-    def drive_force
-      @condition.fuel > 0.0 ? (@max_drive_force * @controls.drive_pedal) : 0.0
+    def gear
+      @powertrain.gearbox.gear
     end
 
-    def drive_force_vector
-      @condition.dir * drive_force
+    def gear=(val)
+      @powertrain.gearbox.gear = val
     end
 
-    def brake_force
-      @max_brake_force * @controls.brake_pedal
+    def top_gear
+      @powertrain.gearbox.top_gear
     end
 
-    def brake_force_vector
-      -1 * @condition.movement_dir * brake_force
+    # force opposing speed
+    def air_force(speed)
+      -0.5 * @frontal_area * @cd * @env.air_density * speed ** 2
     end
 
-    def fuel_mass
-      @condition.fuel * @environment.petrol_density
+    # 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
 
-    def total_mass
-      @mass + fuel_mass + @driver_mass
+    # 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
 
-    def weight
-      total_mass * @environment.g
+    # 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 add_fuel(liters)
-      sum = @condition.fuel + liters
-      overflow = sum > @fuel_capacity ? sum - @fuel_capacity : 0
-      @condition.add_fuel(liters - overflow)
-      overflow
+    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 air_resistance
-      # use default air density for now
-      VectorForce.air_resistance(@condition.vel,
-                                 frontal_area: @frontal_area,
-                                 drag_cof: @cd)
+    def drive_force(rpm)
+      @tire.force(@powertrain.axle_torque(rpm))
     end
 
-    def rotational_resistance
-      # uses default ROT_COF
-      VectorForce.rotational_resistance(@condition.vel)
+    def tire_speed(rpm)
+      @tire.tangential(@powertrain.axle_omega(rpm))
     end
 
-    def rolling_resistance
-      # TODO: downforce
-      VectorForce.rolling_resistance(weight,
-                                     dir: @condition.movement_dir,
-                                     roll_cof: @tires.roll_cof)
+    def motor_rpm(tire_speed)
+      @powertrain.gearbox.crank_rpm(tire_speed / @tire_radius)
     end
 
-    def applied_force
-      drive_force_vector + brake_force_vector
+    def total_mass
+      @body_mass + @powertrain.mass + @tire.mass * @num_tires
     end
 
-    def natural_force
-      air_resistance + rotational_resistance + rolling_resistance
+    def corner_mass
+      Rational(self.total_mass) / @num_tires
     end
 
-    def sum_forces
-      applied_force + natural_force
+    # per tire
+    def normal_force
+      self.corner_mass * @env.g
     end
 
-    class Controls
-      attr_reader :drive_pedal, :brake_pedal, :steering_wheel
-
-      def initialize
-        @drive_pedal = 0.0     # up to 1.0
-        @brake_pedal = 0.0     # up to 1.0
-        @steering_wheel = 0.0  # -1.0 to 1.0
-      end
-
-      def drive_pedal=(flt)
-        @drive_pedal = flt.clamp(0.0, 1.0)
-      end
-
-      def brake_pedal=(flt)
-        @brake_pedal = flt.clamp(0.0, 1.0)
-      end
-
-      def steering_wheel=(flt)
-        @steering_wheel = steering_wheel.clamp(-1.0, 1.0)
-      end
-
-      def to_s
-        [format("Throttle: %d%%", @drive_pedal * 100),
-         format("Brake: %d%%", @brake_pedal * 100),
-         format("Steering: %d%%", @steering_wheel * 100),
-        ].join(" | ")
-      end
+    # per tire
+    def tire_traction
+      @tire.traction(self.normal_force)
     end
 
-    class Condition
-      unless Vector.method_defined?(:zero?)
-        using VectorZeroBackport
-      end
-
-      attr_reader :dir, :pos, :vel, :acc, :fuel, :lat_g, :lon_g,
-                  :wheelspeed, :brake_temp, :brake_pad_depth
-
-      def initialize(dir: DrivingPhysics.random_unit_vector,
-                     brake_temp: AIR_TEMP,
-                     brake_pad_depth: )
-        @dir = dir  # maybe rename to @heading ?
-        @pos = Vector[0, 0]
-        @vel = Vector[0, 0]
-        @acc = Vector[0, 0]
-        @fuel = 0.0   # L
-        @lat_g = 0.0  # g
-        @lon_g = 0.0  # g
-        @wheelspeed = 0.0 # m/s (sliding when it differs from @speed)
-        @brake_temp = brake_temp
-        @brake_pad_depth = brake_pad_depth   # mm
-      end
-
-      def to_s
-        [[compass,
-          format('P(%d, %d)', @pos[0], @pos[1]),
-          format('V(%.1f, %.1f)', @vel[0], @vel[1]),
-          format('A(%.2f, %.2f)', @acc[0], @acc[1]),
-         ].join(' | '),
-         [format('%.1f m/s', speed),
-          format('LatG: %.2f', lat_g),
-          format('LonG: %.2f', lon_g),
-          format('Whl: %.1f m/s', @wheelspeed),
-          format('Slide: %.1f m/s', slide_speed),
-         ].join(' | '),
-         [format('Brakes: %.1f C %.1f mm', @brake_temp, @brake_pad_depth),
-          format('Fuel: %.2f L', @fuel),
-         ].join(' | ')
-        ].join("\n")
-      end
-
-      # left is negative, right is positive
-      def lat_dir
-        DrivingPhysics.rot_90(@dir, clockwise: true)
-      end
-
-      # note, we might be moving backwards, so not always @dir
-      # and we can't normalize a zero vector if we're not moving
-      def movement_dir
-        (speed == 0.0) ? @dir : @vel.normalize
-      end
-
-      def tick!(force:, mass:, tire:, env:)
-        # take the longitudinal component of the force, relative to vel dir
-        vel_dir = @vel.zero? ? @dir : @vel.normalize
-        lon_force = force.dot(vel_dir)
-        @wheelspeed = nil
-
-        if lon_force < 0.0
-          is_stopping = true
-          if @vel.zero?
-            @acc = Vector[0,0]
-            @wheelspeed = 0.0
-            @lon_g = 0.0
-
-            # TODO: update any other physical vars
-            return
-          end
-        else
-          is_stopping = false
-        end
-
-        # now detect sliding
-        nominal_acc = DrivingPhysics.acc(force, mass)
-        init_v = @vel
-
-        if nominal_acc.magnitude > tire.max_g * env.g
-          nominal_v = DrivingPhysics.vel(@vel, nominal_acc, dt: env.tick)
-
-          # check for reversal of velocity; could be wheelspin while
-          # moving backwards, so can't just look at is_stopping
-          if nominal_v.dot(@vel) < 0 and is_stopping
-            @wheelspeed = 0.0
-          else
-            @wheelspeed = nominal_v.magnitude
-          end
-          @acc = nominal_acc.normalize * tire.max_g * env.g
-        else
-          @acc = nominal_acc
-        end
-
-        @vel = DrivingPhysics.vel(@vel, @acc, dt: env.tick)
-        @wheelspeed ||= @vel.magnitude
-
-        # finally, detect velocity reversal when stopping
-        if is_stopping and @vel.dot(init_v) < 0
-          puts "crossed zero; stopping!"
-          @vel = Vector[0, 0]
-          @wheelspeed = 0.0
-          @lon_g = 0.0
-        end
-
-        @lon_g = @acc.dot(@dir) / env.g
-        @pos = DrivingPhysics.pos(@pos, @vel, dt: env.tick)
-      end
-
-      def add_fuel(liters)
-        @fuel += liters
-      end
-
-      def consume_fuel(liters)
-        @fuel -= liters
-      end
-
-      def speed
-        @vel.magnitude
-      end
-
-      def slide_speed
-        (speed - @wheelspeed).abs
-      end
-
-      def compass
-        DrivingPhysics.compass_dir(@dir)
-      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

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  = 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, 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