driving_physics 0.0.0.3 → 0.0.1.1

data/test/disk.rb

@@ -0,0 +1,129 @@
+require 'minitest/autorun'
+require 'driving_physics/disk'
+
+D = DrivingPhysics::Disk
+
+describe D do
+  describe "Disk.volume" do
+    it "calculates the volume (m^3) of disk given radius and width" do
+      cubic_m = D.volume(1.0, 1.0)
+      expect(cubic_m).must_equal Math::PI
+
+      cubic_m = D.volume(0.35, 0.2)
+      expect(cubic_m).must_be_within_epsilon 0.076969
+    end
+  end
+
+  describe "Disk.volume_l" do
+    it "calculates the volume (L) of a disk given radius and width" do
+      liters = D.volume_l(1.0, 1.0)
+      expect(liters).must_equal Math::PI * 1000
+
+      liters = D.volume_l(0.35, 0.2)
+      expect(liters).must_be_within_epsilon 76.96902
+    end
+  end
+
+  describe "Disk.density" do
+    it "calculates the density (kg/L) given mass and volume" do
+      expect(D.density(25.0, 25.0)).must_equal 1.0
+      expect(D.density(50.0, 25.0)).must_equal 2.0
+    end
+  end
+
+  describe "Disk.mass" do
+    it "calculates the mass (kg) of a disk given radius, width, and density" do
+      skip
+      expect(D.mass(0.35, 0.2, D::DENSITY)).must_be_within_epsilon 25.015
+    end
+  end
+
+  describe "Disk.rotational_inertia" do
+    it "calculates rotational inertia for a disk given radius and mass" do
+      expect(D.rotational_inertia(0.35, 25.0)).must_be_within_epsilon 1.53125
+    end
+  end
+
+  describe "Disk.alpha" do
+    it "calculates angular acceleration from torque and inertia" do
+      scalar_torque = 1000
+      inertia = D.rotational_inertia(0.35, 25.0)
+      expect(D.alpha scalar_torque, inertia).must_be_within_epsilon 653.061
+
+      vector_torque = Vector[0, 0, 1000]
+      vector_alpha = D.alpha vector_torque, inertia
+      expect(vector_alpha).must_be_instance_of Vector
+      expect(vector_alpha.size).must_equal 3
+      expect(vector_alpha[2]).must_be_within_epsilon 653.06
+    end
+  end
+
+  describe "Disk.torque_vector" do
+    it "calculates a torque in the 3rd dimension given 2D force and radius" do
+      force = Vector[1000, 0]
+      radius = Vector[0, 5]
+      torque = D.torque_vector(force, radius)
+      expect(torque).must_be_instance_of Vector
+      expect(torque.size).must_equal 3
+      expect(torque[2]).must_be_within_epsilon 5000.0
+    end
+  end
+
+  describe "Disk.force_vector" do
+    it "calculates a (3D) force given 3D torque and 2D radius" do
+      # let's invert the Disk.torque_vector case from above:
+      torque = Vector[0, 0, 5000]
+      radius = Vector[0, 5]
+      force = D.force_vector(torque, radius)
+      expect(force).must_be_instance_of Vector
+      expect(force.size).must_equal 3
+      expect(force[0]).must_be_within_epsilon 1000.0
+
+      # now let's rotate the radius into the x-dimension
+      # right hand rule, positive torque means thumb into screen, clockwise
+      # negative-x radius means positive-y force
+      torque = Vector[0, 0, 500]
+      radius = Vector[-5, 0]
+      force = D.force_vector(torque, radius)
+      expect(force).must_be_instance_of Vector
+      expect(force.size).must_equal 3
+      expect(force[1]).must_be_within_epsilon 100.0
+    end
+  end
+
+  describe "instance methods" do
+    before do
+      @env = DrivingPhysics::Environment.new
+      @disk = D.new(@env)
+    end
+
+    it "initializes" do
+      skip
+      expect(@disk).must_be_instance_of D
+      expect(@disk.density).must_equal D::DENSITY # sanity check
+      expect(@disk.mass).must_be_within_epsilon 25.01
+
+      with_mass = D.new(@env) { |w|
+        w.mass = 99.01
+      }
+      expect(with_mass.mass).must_equal 99.01
+      expect(with_mass.density).wont_equal D::DENSITY
+    end
+
+    it "has a string representation" do
+      str = @disk.to_s
+      expect(str).must_be_instance_of String
+      expect(str.length).must_be(:>, 5)
+    end
+
+    it "has volume" do
+      expect(@disk.volume).must_be_within_epsilon 0.07697
+      expect(@disk.volume_l).must_be_within_epsilon 76.96902
+    end
+
+    it "has inertia" do
+      skip
+      expect(@disk.rotational_inertia).must_be_within_epsilon 1.5321
+    end
+  end
+end

data/test/{wheel.rb → tire.rb}

@@ -1,92 +1,92 @@
 require 'minitest/autorun'
-require 'driving_physics/wheel'
+require 'driving_physics/tire'
 
-W = DrivingPhysics::Wheel
+T = DrivingPhysics::Tire
 
-describe W do
-  describe "Wheel.traction" do
+describe T do
+  describe "Tire.traction" do
     it "calculates traction force from normal force and coeff of friction" do
       scalar_nf = 9800 # N
       cof = 1.1
-      scalar_t = W.traction(scalar_nf, cof)
+      scalar_t = T.traction(scalar_nf, cof)
       expect(scalar_t).must_equal 10780.0
 
       vector_nf = Vector[9800, 0]
-      vector_t = W.traction(vector_nf, cof)
+      vector_t = T.traction(vector_nf, cof)
       expect(vector_t).must_equal Vector[10780.0, 0.0]
     end
   end
 
-  describe "Wheel.volume" do
+  describe "Tire.volume" do
     it "calculates the volume (m^3) of disk given radius and width" do
-      cubic_m = W.volume(1.0, 1.0)
+      cubic_m = T.volume(1.0, 1.0)
       expect(cubic_m).must_equal Math::PI
 
-      cubic_m = W.volume(0.35, 0.2)
+      cubic_m = T.volume(0.35, 0.2)
       expect(cubic_m).must_be_within_epsilon 0.076969
     end
   end
 
-  describe "Wheel.volume_l" do
+  describe "Tire.volume_l" do
     it "calculates the volume (L) of a disk given radius and width" do
-      liters = W.volume_l(1.0, 1.0)
+      liters = T.volume_l(1.0, 1.0)
       expect(liters).must_equal Math::PI * 1000
 
-      liters = W.volume_l(0.35, 0.2)
+      liters = T.volume_l(0.35, 0.2)
       expect(liters).must_be_within_epsilon 76.96902
     end
   end
 
-  describe "Wheel.density" do
+  describe "Tire.density" do
     it "calculates the density (kg/L) given mass and volume" do
-      expect(W.density(25.0, 25.0)).must_equal 1.0
-      expect(W.density(50.0, 25.0)).must_equal 2.0
+      expect(T.density(25.0, 25.0)).must_equal 1.0
+      expect(T.density(50.0, 25.0)).must_equal 2.0
     end
   end
 
-  describe "Wheel.mass" do
+  describe "Tire.mass" do
     it "calculates the mass (kg) of a disk given radius, width, and density" do
-      expect(W.mass(0.35, 0.2, W::DENSITY)).must_be_within_epsilon 25.015
+      expect(T.mass(0.35, 0.2, T::DENSITY)).must_be_within_epsilon 25.015
     end
   end
 
-  describe "Wheel.rotational_inertia" do
+  describe "Tire.rotational_inertia" do
     it "calculates rotational inertia for a disk given radius and mass" do
-      expect(W.rotational_inertia(0.35, 25.0)).must_be_within_epsilon 1.53125
+      expect(T.rotational_inertia(0.35, 25.0)).must_be_within_epsilon 1.53125
     end
   end
 
-  describe "Wheel.alpha" do
+  describe "Tire.alpha" do
     it "calculates angular acceleration from torque and inertia" do
       scalar_torque = 1000
-      inertia = W.rotational_inertia(0.35, 25.0)
-      expect(W.alpha scalar_torque, inertia).must_be_within_epsilon 653.061
+      inertia = T.rotational_inertia(0.35, 25.0)
+      expect(T.alpha scalar_torque, inertia).must_be_within_epsilon 653.061
 
       vector_torque = Vector[0, 0, 1000]
-      vector_alpha = W.alpha vector_torque, inertia
+      vector_alpha = T.alpha vector_torque, inertia
       expect(vector_alpha).must_be_instance_of Vector
       expect(vector_alpha.size).must_equal 3
       expect(vector_alpha[2]).must_be_within_epsilon 653.06
     end
   end
 
-  describe "Wheel.torque_vector" do
+  describe "Tire.torque_vector" do
     it "calculates a torque in the 3rd dimension given 2D force and radius" do
       force = Vector[1000, 0]
       radius = Vector[0, 5]
-      torque = W.torque_vector(force, radius)
+      torque = T.torque_vector(force, radius)
       expect(torque).must_be_instance_of Vector
       expect(torque.size).must_equal 3
       expect(torque[2]).must_be_within_epsilon 5000.0
     end
   end
 
-  describe "Wheel.force_vector" do
+  describe "Tire.force_vector" do
     it "calculates a (3D) force given 3D torque and 2D radius" do
-      # let's invert the Wheel.torque_vector case from above:
+      # let's invert the Tire.torque_vector case from above:
       torque = Vector[0, 0, 5000]
       radius = Vector[0, 5]
-      force = W.force_vector(torque, radius)
+      force = T.force_vector(torque, radius)
       expect(force).must_be_instance_of Vector
       expect(force.size).must_equal 3
       expect(force[0]).must_be_within_epsilon 1000.0
@@ -96,7 +96,7 @@ describe W do
       # negative-x radius means positive-y force
       torque = Vector[0, 0, 500]
       radius = Vector[-5, 0]
-      force = W.force_vector(torque, radius)
+      force = T.force_vector(torque, radius)
       expect(force).must_be_instance_of Vector
       expect(force.size).must_equal 3
       expect(force[1]).must_be_within_epsilon 100.0
@@ -106,72 +106,76 @@ describe W do
   describe "instance methods" do
     before do
       @env = DrivingPhysics::Environment.new
-      @w = W.new(@env)
+      @tire = T.new(@env)
     end
 
     it "initializes" do
-      expect(@w).must_be_instance_of W
-      expect(@w.density).must_equal W::DENSITY # sanity check
-      expect(@w.mass).must_be_within_epsilon 25.01
+      expect(@tire).must_be_instance_of T
+      expect(@tire.density).must_equal T::DENSITY # sanity check
+      expect(@tire.mass).must_be_within_epsilon 25.01
 
-      with_mass = W.new(@env, mass: 99.01)
+      with_mass = T.new(@env) { |w|
+        w.mass = 99.01
+      }
       expect(with_mass.mass).must_equal 99.01
-      expect(with_mass.density).wont_equal W::DENSITY
+      expect(with_mass.density).wont_equal T::DENSITY
     end
 
     it "has a string representation" do
-      str = @w.to_s
+      str = @tire.to_s
       expect(str).must_be_instance_of String
       expect(str.length).must_be(:>, 5)
     end
 
     it "loses radius as it wears" do
-      expect(@w.radius).must_equal 350.0
-      @w.wear!(50)
-      expect(@w.radius).must_equal 300.0
+      old_r = @tire.radius
+      wear_amt = 50/1000r
+      @tire.wear! wear_amt
+      expect(@tire.radius).must_equal old_r - wear_amt
     end
 
     it "calculates mass from current radius" do
-      expect(@w.mass).must_be_within_epsilon 25.01
-      @w.wear!(50)
-      expect(@w.mass).must_be_within_epsilon 18.378
+      expect(@tire.mass).must_be_within_epsilon 25.01
+      @tire.wear!(50/1000r)
+      expect(@tire.mass).must_be_within_epsilon 18.378
     end
 
     it "has volume" do
-      expect(@w.volume).must_be_within_epsilon 0.07697
-      expect(@w.volume_l).must_be_within_epsilon 76.96902
+      expect(@tire.volume).must_be_within_epsilon 0.07697
+      expect(@tire.volume_l).must_be_within_epsilon 76.96902
     end
 
     it "has inertia" do
-      expect(@w.rotational_inertia).must_be_within_epsilon 1.5321
+      expect(@tire.rotational_inertia).must_be_within_epsilon 1.5321
     end
 
     it "has traction force based on normal force" do
       scalar_nf = 9800
-      expect(@w.traction scalar_nf).must_equal 10780.0
-      expect(@w.traction scalar_nf, static: false).must_equal 6860.0
+      expect(@tire.traction scalar_nf).must_equal 10780.0
+      expect(@tire.traction scalar_nf, static: false).must_equal 6860.0
 
       vector_nf = Vector[9800, 0]
-      expect(@w.traction vector_nf).must_equal Vector[10780.0, 0.0]
-      expect(@w.traction vector_nf, static: false).
+      expect(@tire.traction vector_nf).must_equal Vector[10780.0, 0.0]
+      expect(@tire.traction vector_nf, static: false).
         must_equal Vector[6860.0, 0.0]
     end
 
     it "determines (e.g. thrust) force based on axle torque" do
-      expect(@w.force 1000).must_be_within_epsilon 2857.143
-      @w.wear! 50
-      expect(@w.force 1000).must_be_within_epsilon 3333.333
+      expect(@tire.force 1000).must_be_within_epsilon 2857.143
+      @tire.wear! 50/1000r
+      expect(@tire.force 1000).must_be_within_epsilon 3333.333
     end
 
     it "determines tractable torque" do
       scalar_nf = 9800
-      expect(@w.tractable_torque scalar_nf).must_be_within_epsilon 3773.0
-      kin_tq = @w.tractable_torque scalar_nf, static: false
+      expect(@tire.tractable_torque scalar_nf).must_be_within_epsilon 3773.0
+      kin_tq = @tire.tractable_torque scalar_nf, static: false
       expect(kin_tq).must_be_within_epsilon 2401.0
 
       # not sure about how torque vectors work, but the "math" "works":
       vector_nf = Vector[9800, 0]
-      expect(@w.tractable_torque(vector_nf)[0]).must_be_within_epsilon 3773.0
+      expect(@tire.tractable_torque(vector_nf)[0]).
+        must_be_within_epsilon 3773.0
     end
   end
 end

data/test/vector_force.rb

@@ -74,9 +74,15 @@ describe VectorForce do
   end
 
   it "calculates the rotational resistance as a function of velocity" do
+    rr = VectorForce.rotational_resistance(@v, rot_const: 0)
+    rr2 = VectorForce.rotational_resistance(@v * 2, rot_const: 0)
+    expect(rr2).must_equal rr * 2
+
+    # now with rot_const != 0, the relationship is skewed
     rr = VectorForce.rotational_resistance(@v)
     rr2 = VectorForce.rotational_resistance(@v * 2)
-    expect(rr2).must_equal rr * 2
+    expect(rr2).wont_equal rr * 2   # because of rot_const
+    expect(rr2.magnitude).must_be(:<, (rr * 2).magnitude)
   end
 
   it "sums resistance forces" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: driving_physics
 version: !ruby/object:Gem::Version
-  version: 0.0.0.3
+  version: 0.0.1.1
 platform: ruby
 authors:
 - Rick Hull
@@ -19,20 +19,33 @@ files:
 - README.md
 - Rakefile
 - VERSION
+- demo/car.rb
+- demo/disk.rb
+- demo/gearbox.rb
+- demo/motor.rb
+- demo/powertrain.rb
 - demo/scalar_force.rb
+- demo/tire.rb
 - demo/vector_force.rb
-- demo/wheel.rb
 - driving_physics.gemspec
 - lib/driving_physics.rb
+- lib/driving_physics/car.rb
+- lib/driving_physics/cli.rb
+- lib/driving_physics/disk.rb
 - lib/driving_physics/environment.rb
+- lib/driving_physics/gearbox.rb
 - lib/driving_physics/imperial.rb
+- lib/driving_physics/motor.rb
+- lib/driving_physics/power.rb
+- lib/driving_physics/powertrain.rb
 - lib/driving_physics/scalar_force.rb
+- lib/driving_physics/tire.rb
 - lib/driving_physics/vector_force.rb
-- lib/driving_physics/wheel.rb
+- test/disk.rb
 - test/driving_physics.rb
 - test/scalar_force.rb
+- test/tire.rb
 - test/vector_force.rb
-- test/wheel.rb
 homepage: https://github.com/rickhull/driving_physics
 licenses:
 - LGPL-3.0

data/demo/wheel.rb

@@ -1,84 +0,0 @@
-require 'driving_physics/wheel'
-
-include DrivingPhysics
-
-env = Environment.new
-wheel = Wheel.new(env, mass: 25.0)
-
-puts env
-puts wheel
-
-# 1000 kg car
-# 4 tires
-# 250 kg per tire plus tire mass
-
-supported_mass = 1000 # kg
-total_mass = supported_mass + 4 * wheel.mass
-corner_mass = Rational(total_mass) / 4
-normal_force = corner_mass * env.g
-axle_torque = 1000 # N*m
-friction_loss = 0.05 # 5% friction / hysteresis loss
-
-puts [format("Corner mass: %d kg", corner_mass),
-      format("Normal force: %.1f N", normal_force),
-      format("Axle torque: %d Nm", axle_torque),
-     ].join("\n")
-puts
-
-traction = wheel.traction(normal_force)
-drive_force = wheel.force(axle_torque)
-inertial_loss = wheel.inertial_loss(axle_torque, supported_mass)
-friction_loss *= axle_torque # 5% of the axle torque
-
-# drive force = (axle torque - inertia - friction) limited by traction
-
-net_axle_torque = axle_torque - inertial_loss - friction_loss
-net_drive_force = wheel.force(net_axle_torque)
-net_drive_force = traction if net_drive_force > traction  # traction limited
-
-acc = DrivingPhysics.acc(net_drive_force, supported_mass) # translational
-
-puts [format("Traction: %.1f N", traction),
-      format("Drive force: %.1f N", drive_force),
-      format("Inertial loss: %.1f Nm", inertial_loss),
-      format("Friction loss: %.1f Nm", friction_loss),
-      format("Net Axle Torque: %.1f Nm", net_axle_torque),
-      format("Net Drive Force: %.1f N", net_drive_force),
-      format("Acceleration: %.1f m/s/s", acc),
-      format("Alpha: %.2f r/s/s", acc / wheel.radius_m),
-     ].join("\n")
-puts
-
-duration = 100 # sec
-
-dist = 0.0  # meters
-speed = 0.0 # meters/s
-
-theta = 0.0 # radians
-omega = 0.0 # radians/s
-
-(duration * env.hz).times { |i|
-  # accumulate frictional losses with speed (omega)
-  omega_loss_cof = [wheel.omega_friction * omega, 1.0].min
-  slowed_acc = acc - acc * omega_loss_cof
-
-  # translational kinematics
-  speed += slowed_acc * env.tick
-  dist += speed * env.tick
-
-  # rotational kinematics
-  alpha = slowed_acc / wheel.radius_m
-  omega += alpha * env.tick
-  theta += omega * env.tick
-
-  if i < 10 or
-    (i < 10_000 and i%1000 == 0) or
-    (i % 10_000 == 0)
-    puts DrivingPhysics.elapsed_display(i)
-    puts format("Wheel: %.1f r  %.2f r/s  %.3f r/s^2", theta, omega, alpha)
-    puts format("  Car: %.1f m  %.2f m/s  %.3f m/s^2", dist, speed, slowed_acc)
-    puts format("Omega Frictional Loss: %.1f%%", omega_loss_cof * 100)
-    puts "Press [enter]"
-    gets
-  end
-}