earth 0.7.0 → 0.11.0

data/lib/earth/automobile.rb

@@ -1,17 +1,18 @@
 require 'earth/automobile/automobile_fuel'
 require 'earth/automobile/automobile_make'
-require 'earth/automobile/automobile_make_fleet_year'
 require 'earth/automobile/automobile_make_year'
+require 'earth/automobile/automobile_make_year_fleet'
 require 'earth/automobile/automobile_make_model'
 require 'earth/automobile/automobile_make_model_year'
+require 'earth/automobile/automobile_make_model_year_variant'
+require 'earth/automobile/automobile_model'
 require 'earth/automobile/automobile_size_class'
 require 'earth/automobile/automobile_size_class_year'
-require 'earth/automobile/automobile_make_model_year_variant'
 require 'earth/automobile/automobile_type_year'
-require 'earth/automobile/automobile_type_fuel_age'
 require 'earth/automobile/automobile_type_fuel_control'
 require 'earth/automobile/automobile_type_fuel_year'
 require 'earth/automobile/automobile_type_fuel_year_age'
 require 'earth/automobile/automobile_type_fuel_year_control'
+require 'earth/automobile/automobile_year'
 
 require 'earth/fuel'

data/lib/earth/automobile/automobile_fuel.rb

@@ -33,150 +33,87 @@ class AutomobileFuel < ActiveRecord::Base
     end
   end
   
-  # FIXME TODO verify that base_fuel_name and blend_fuel_name are found in Fuel if present
-  # FIXME TODO verify that distance_key is found in AutomobileTypeFuelYearAge
-  # FIXME TODO verify that ef_key is found in AutomobileTypeFuelYear
-  
-  # TODO convert these to warn blocks  
-  # ["ch4_emission_factor", "n2o_emission_factor", "hfc_emission_factor"].each do |attribute|
-  #   verify "#{attribute.humanize} should be > 0" do
-  #     find_each do |fuel|
-  #       value = fuel.send(attribute)
-  #       unless value > 0
-  #         raise "Invalid #{attribute.humanize.downcase} for AutomobileFuel #{fuel.name}: #{value} (should be > 0)"
-  #       end
-  #     end
-  #   end
-  # end
-  # 
-  # [["co2_emission_factor_units", "kilograms_per_litre"],
-  #  ["co2_biogenic_emission_factor_units", "kilograms_per_litre"],
-  #  ["ch4_emission_factor_units", "kilograms_co2e_per_litre"],
-  #  ["n2o_emission_factor_units", "kilograms_co2e_per_litre"],
-  #  ["hfc_emission_factor_units", "kilograms_co2e_per_litre"]].each do |pair|
-  #   attribute = pair[0]
-  #   proper_units = pair[1]
-  #   verify "#{attribute.humanize} should be #{proper_units.humanize.downcase}" do
-  #     find_each do |fuel|
-  #       units = fuel.send(attribute)
-  #       unless units == proper_units
-  #         raise "Invalid #{attribute.humanize.downcase} for AutomobileFuel #{fuel.name}: #{units} (should be #{proper_units})"
-  #       end
-  #     end
-  #   end
-  # end
-  
   class << self
-    def fallback_latest_type_fuel_year_ages
+    def fallback_type_fuel_year_ages
       AutomobileTypeFuelYearAge.where(:year => AutomobileTypeFuelYearAge.maximum('year'))
     end
     
-    def fallback_annual_distance
-      fallback_latest_type_fuel_year_ages.weighted_average(:annual_distance, :weighted_by => :vehicles)
-    end
-    
-    def fallback_annual_distance_units
-      fallback_latest_type_fuel_year_ages.first.annual_distance_units
-    end
-    
-    def fallback_blend_portion
-      latest_year = AutomobileTypeFuelYear.maximum('year')
-      gas_use = AutomobileTypeFuelYear.where(:year => latest_year, :fuel_common_name => 'gasoline').sum('fuel_consumption')
-      diesel_use = AutomobileTypeFuelYear.where(:year => latest_year, :fuel_common_name => 'diesel').sum('fuel_consumption')
-      diesel_use.to_f / (gas_use + diesel_use)
-    end
-    
-    def fallback_co2_emission_factor
-      (Fuel.find_by_name("Motor Gasoline").co2_emission_factor.to_f * (1 - AutomobileFuel.fallback_blend_portion)) +
-      (Fuel.find_by_name("Distillate Fuel Oil No. 2").co2_emission_factor.to_f * AutomobileFuel.fallback_blend_portion)
-    end
-    
-    def fallback_co2_emission_factor_units
-      Fuel.find_by_name("Motor Gasoline").co2_emission_factor_units
-    end
-    
-    def fallback_co2_biogenic_emission_factor
-      (Fuel.find_by_name("Motor Gasoline").co2_biogenic_emission_factor * (1 - AutomobileFuel.fallback_blend_portion)) +
-      (Fuel.find_by_name("Distillate Fuel Oil No. 2").co2_biogenic_emission_factor * AutomobileFuel.fallback_blend_portion)
-    end
-    
-    def fallback_co2_biogenic_emission_factor_units
-      Fuel.find_by_name("Motor Gasoline").co2_biogenic_emission_factor_units
-    end
-    
-    def fallback_latest_type_fuel_years
+    def fallback_type_fuel_years
       AutomobileTypeFuelYear.where(:year => AutomobileTypeFuelYear.maximum('year'))
     end
     
-    def fallback_ch4_emission_factor
-      fallback_latest_type_fuel_years.weighted_average(:ch4_emission_factor, :weighted_by => :total_travel).to_f * GreenhouseGas[:ch4].global_warming_potential
-    end
-    
-    def fallback_ch4_emission_factor_units
-      prefix = fallback_latest_type_fuel_years.first.ch4_emission_factor_units.split("_per_")[0]
-      suffix = fallback_latest_type_fuel_years.first.ch4_emission_factor_units.split("_per_")[1]
-      prefix + "_co2e_per_" + suffix
-    end
-    
-    def fallback_n2o_emission_factor
-      fallback_latest_type_fuel_years.weighted_average(:n2o_emission_factor, :weighted_by => :total_travel).to_f * GreenhouseGas[:n2o].global_warming_potential
-    end
-    
-    def fallback_n2o_emission_factor_units
-      prefix = fallback_latest_type_fuel_years.first.n2o_emission_factor_units.split("_per_")[0]
-      suffix = fallback_latest_type_fuel_years.first.n2o_emission_factor_units.split("_per_")[1]
-      prefix + "_co2e_per_" + suffix
+    def fallback_type_years
+      AutomobileTypeYear.where(:year => AutomobileTypeYear.maximum('year'))
     end
     
-    def fallback_hfc_emission_factor
-      fallback_latest_type_fuel_years.map do |tfy|
-        tfy.total_travel.to_f * tfy.type_year.hfc_emission_factor
-      end.sum / fallback_latest_type_fuel_years.sum('total_travel')
-    end
-    
-    def fallback_hfc_emission_factor_units
-      fallback_latest_type_fuel_years.first.type_year.hfc_emission_factor_units
+    # FIXME TODO for some reason this causes the fallbacks calculation to hang (infinite loop?) if it's defined as a fallback
+    def fallback_blend_portion
+      gas_use = fallback_type_fuel_years.where(:fuel_common_name => 'gasoline').sum('fuel_consumption').to_f
+      diesel_use = fallback_type_fuel_years.where(:fuel_common_name => 'diesel').sum('fuel_consumption').to_f
+      diesel_use / (gas_use + diesel_use)
     end
   end
   
   falls_back_on :name => 'fallback',
-                :annual_distance => lambda { AutomobileFuel.fallback_annual_distance },
-                :annual_distance_units => lambda { AutomobileFuel.fallback_annual_distance_units },
-                :co2_emission_factor => lambda { AutomobileFuel.fallback_co2_emission_factor },
-                :co2_emission_factor_units => lambda { AutomobileFuel.fallback_co2_emission_factor_units },
-                :co2_biogenic_emission_factor => lambda { AutomobileFuel.fallback_co2_biogenic_emission_factor },
-                :co2_biogenic_emission_factor_units => lambda { AutomobileFuel.fallback_co2_biogenic_emission_factor_units },
-                :ch4_emission_factor => lambda { AutomobileFuel.fallback_ch4_emission_factor },
-                :ch4_emission_factor_units => lambda { AutomobileFuel.fallback_ch4_emission_factor_units },
-                :n2o_emission_factor => lambda { AutomobileFuel.fallback_n2o_emission_factor },
-                :n2o_emission_factor_units => lambda { AutomobileFuel.fallback_n2o_emission_factor_units },
-                :hfc_emission_factor => lambda { AutomobileFuel.fallback_hfc_emission_factor },
-                :hfc_emission_factor_units => lambda { AutomobileFuel.fallback_hfc_emission_factor_units }
-
+                :annual_distance => lambda { fallback_type_fuel_year_ages.weighted_average(:annual_distance, :weighted_by => :vehicles) },
+                :annual_distance_units => lambda { fallback_type_fuel_year_ages.first.annual_distance_units },
+                :energy_content => lambda {
+                  (Fuel.find_by_name('Motor Gasoline').energy_content * (1 - fallback_blend_portion)) +
+                  (Fuel.find_by_name('Distillate Fuel Oil No. 2').energy_content * fallback_blend_portion)
+                },
+                :co2_emission_factor => lambda {
+                  (Fuel.find_by_name("Motor Gasoline").co2_emission_factor * (1 - fallback_blend_portion)) +
+                  (Fuel.find_by_name("Distillate Fuel Oil No. 2").co2_emission_factor * fallback_blend_portion)
+                },
+                :co2_emission_factor_units => lambda { Fuel.find_by_name("Motor Gasoline").co2_emission_factor_units },
+                :co2_biogenic_emission_factor => lambda {
+                  (Fuel.find_by_name("Motor Gasoline").co2_biogenic_emission_factor * (1 - AutomobileFuel.fallback_blend_portion)) +
+                  (Fuel.find_by_name("Distillate Fuel Oil No. 2").co2_biogenic_emission_factor * AutomobileFuel.fallback_blend_portion)
+                },
+                :co2_biogenic_emission_factor_units => lambda { Fuel.find_by_name("Motor Gasoline").co2_biogenic_emission_factor_units },
+                :ch4_emission_factor => lambda { fallback_type_fuel_years.weighted_average(:ch4_emission_factor, :weighted_by => :total_travel) * GreenhouseGas[:ch4].global_warming_potential },
+                :ch4_emission_factor_units => lambda {
+                  prefix = fallback_type_fuel_years.first.ch4_emission_factor_units.split("_per_")[0]
+                  suffix = fallback_type_fuel_years.first.ch4_emission_factor_units.split("_per_")[1]
+                  prefix + "_co2e_per_" + suffix
+                },
+                :n2o_emission_factor => lambda {
+                  fallback_type_fuel_years.weighted_average(:n2o_emission_factor, :weighted_by => :total_travel) * GreenhouseGas[:n2o].global_warming_potential
+                },
+                :n2o_emission_factor_units => lambda {
+                  prefix = fallback_type_fuel_years.first.n2o_emission_factor_units.split("_per_")[0]
+                  suffix = fallback_type_fuel_years.first.n2o_emission_factor_units.split("_per_")[1]
+                  prefix + "_co2e_per_" + suffix
+                },
+                :hfc_emission_factor => lambda { fallback_type_years.weighted_average(:hfc_emission_factor, :weighted_by => [:type_fuel_years, :total_travel]) },
+                :hfc_emission_factor_units => lambda { fallback_type_years.first.hfc_emission_factor_units }
+  
   col :name
   col :code
   col :base_fuel_name
   col :blend_fuel_name
-  col :blend_portion, :type => :float # the portion of the blend that is the blend fuel
-  col :distance_key # used to look up annual distance from AutomobileTypeFuelYear
-  col :ef_key # used to look up ch4 n2o and hfc emission factors from AutomobileTypeFuelYear
-  col :annual_distance, :type => :float
+  col :blend_portion,                :type => :float # the portion of the blend that is the blend fuel
+  col :distance_key                                  # used to look up annual distance from AutomobileTypeFuelYear
+  col :ef_key                                        # used to look up ch4 n2o and hfc emission factors from AutomobileTypeFuelYear
+  col :annual_distance,              :type => :float
   col :annual_distance_units
-  col :co2_emission_factor, :type => :float
+  col :energy_content,               :type => :float
+  col :energy_content_units
+  col :co2_emission_factor,          :type => :float
   col :co2_emission_factor_units
   col :co2_biogenic_emission_factor, :type => :float
   col :co2_biogenic_emission_factor_units
-  col :ch4_emission_factor, :type => :float
+  col :ch4_emission_factor,          :type => :float
   col :ch4_emission_factor_units
-  col :n2o_emission_factor, :type => :float
+  col :n2o_emission_factor,          :type => :float
   col :n2o_emission_factor_units
-  col :hfc_emission_factor, :type => :float
+  col :hfc_emission_factor,          :type => :float
   col :hfc_emission_factor_units
-  col :emission_factor, :type => :float # DEPRECATED but motorcycle needs this
-  col :emission_factor_units # DEPRECATED but motorcycle needs this
-
+  col :emission_factor,              :type => :float # DEPRECATED but motorcycle needs this
+  col :emission_factor_units # FIXME TODO DEPRECATED but motorcycle needs this
+  
   CODES = {
     :electricity => 'El',
     :diesel => 'D'
   }
-end
+end

data/lib/earth/automobile/automobile_fuel/data_miner.rb

@@ -36,6 +36,18 @@ AutomobileFuel.class_eval do
       end
     end
     
+    process "Derive energy content" do
+      find_each do |record|
+        if record.blend_fuel.present?
+          record.energy_content = (record.base_fuel.energy_content * (1 - record.blend_portion)) + (record.blend_fuel.energy_content * record.blend_portion)
+        else
+          record.energy_content = record.base_fuel.energy_content
+        end
+        record.energy_content_units = record.base_fuel.energy_content_units
+        record.save!
+      end
+    end
+    
     process "Derive co2 emission factor and co2 biogenic emission factors" do
       find_each do |record|
         if record.blend_fuel.present?
@@ -74,13 +86,14 @@ AutomobileFuel.class_eval do
       end
     end
     
+    # FIXME TODO DEPRECATED motorcycle needs this
     process "Derive emission factor" do
-      update_all "emission_factor = co2_emission_factor + ch4_emission_factor + n2o_emission_factor + hfc_emission_factor,
-                  emission_factor_units = 'kilograms_co2e_per_litre'"
+      update_all(%{
+        emission_factor = 1.0 * co2_emission_factor + ch4_emission_factor + n2o_emission_factor + hfc_emission_factor,
+        emission_factor_units = 'kilograms_co2e_per_litre'
+      })
     end
     
     # FIXME TODO verify code somehow
-    
-
   end
 end

data/lib/earth/automobile/automobile_make.rb

@@ -1,22 +1,7 @@
 class AutomobileMake < ActiveRecord::Base
   set_primary_key :name
   
-  has_many :make_years,               :class_name => 'AutomobileMakeYear',             :foreign_key => 'make_name'
-  has_many :models,                   :class_name => 'AutomobileMakeModel',            :foreign_key => 'make_name'
-  has_many :fleet_years,              :class_name => 'AutomobileMakeFleetYear',        :foreign_key => 'make_name'
-  has_many :make_model_year_variants, :class_name => 'AutomobileMakeModelYearVariant', :foreign_key => 'make_name'
-
   col :name
   col :fuel_efficiency, :type => :float
   col :fuel_efficiency_units
-
-  # TODO convert to table_warnings
-  # verify "Fuel efficiency should be greater than zero" do
-  #   AutomobileMake.all.each do |make|
-  #     unless make.fuel_efficiency > 0
-  #       raise "Invalid fuel efficiency for AutomobileMake #{make.name}: #{make.fuel_efficiency} (should be > 0)"
-  #     end
-  #   end
-  # end
-  
-end
+end

data/lib/earth/automobile/automobile_make/data_miner.rb

@@ -4,50 +4,50 @@ AutomobileMake.class_eval do
       delete_all
     end
     
-    process "Ensure AutomobileMakeModelYearVariant and AutomobileMakeFleetYear are populated" do
+    process "Ensure AutomobileMakeModelYearVariant and AutomobileMakeYearFleet are populated" do
       AutomobileMakeModelYearVariant.run_data_miner!
-      AutomobileMakeFleetYear.run_data_miner!
+      AutomobileMakeYearFleet.run_data_miner!
     end
     
     process "Derive manufacturer names from automobile make model year variants" do
       ::Earth::Utils.insert_ignore(
         :src => AutomobileMakeModelYearVariant,
         :dest => AutomobileMake,
-        :cols => {
-          :make_name => :name,
-        }
+        :cols => { :make_name => :name }
       )
     end
     
     # sabshere 1/31/11 add Avanti, DaimlerChrysler, IHC, Tesla, etc.
     process "Derive extra manufacturer names from CAFE data" do
       ::Earth::Utils.insert_ignore(
-        :src => AutomobileMakeFleetYear,
+        :src => AutomobileMakeYearFleet,
         :dest => AutomobileMake,
-        :cols => {
-          :make_name => :name,
-        }
+        :cols => { :make_name => :name }
       )
     end
     
-    # FIXME TODO make this a method on AutomobileMake?
-    process "Calculate fuel efficiency from automobile make fleet years for makes with CAFE data" do
-      make_fleet_years = AutomobileMakeFleetYear.arel_table
-      makes = AutomobileMake.arel_table
-      conditional_relation = makes[:name].eq(make_fleet_years[:make_name])
-      relation = AutomobileMakeFleetYear.weighted_average_relation(:fuel_efficiency, :weighted_by => :volume).where(conditional_relation)
-      update_all "fuel_efficiency = (#{relation.to_sql})"
+    # FIXME TODO derive units here
+    process "Calculate fuel efficiency from CAFE data" do
+      makes = arel_table
+      year_fleets = AutomobileMakeYearFleet.arel_table
+      conditional_relation = makes[:name].eq(year_fleets[:make_name])
+      relation = AutomobileMakeYearFleet.weighted_average_relation(:fuel_efficiency, :weighted_by => :volume).where(conditional_relation)
+      update_all(%{
+        fuel_efficiency = (#{relation.to_sql}),
+        fuel_efficiency_units = 'kilometres_per_litre'
+      })
     end
     
-    process "Calculate fuel effeciency from automobile make model year variants for makes without CAFE data" do
-      update_all(
-        %{fuel_efficiency = (SELECT AVG(automobile_make_model_year_variants.fuel_efficiency) FROM automobile_make_model_year_variants WHERE automobile_makes.name = automobile_make_model_year_variants.make_name)},
-        'fuel_efficiency IS NULL'
-      )
-    end
-    
-    process "Set units" do
-      update_all :fuel_efficiency_units => 'kilometres_per_litre'
+    # FIXME TODO derive units here
+    process "Calculate any missing fuel effeciencies from automobile make model year variants" do
+      makes = arel_table
+      variants = AutomobileMakeModelYearVariant.arel_table
+      conditional_relation = variants[:make_name].eq(makes[:name])
+      relation = variants.project(variants[:fuel_efficiency].average).where(conditional_relation)
+      where(:fuel_efficiency => nil).update_all(%{
+        fuel_efficiency = (#{relation.to_sql}),
+        fuel_efficiency_units = 'kilometres_per_litre'
+      })
     end
   end
 end

data/lib/earth/automobile/automobile_make_model.rb

@@ -1,9 +1,6 @@
 class AutomobileMakeModel < ActiveRecord::Base
   set_primary_key :name
   
-  belongs_to :make,                   :class_name => 'AutomobileMake',                 :foreign_key => 'make_name'
-  has_many :make_model_year_variants, :class_name => 'AutomobileMakeModelYearVariant', :foreign_key => 'make_model_name'
-
   col :name # make + model
   col :make_name
   col :model_name # model only
@@ -11,27 +8,4 @@ class AutomobileMakeModel < ActiveRecord::Base
   col :fuel_efficiency_city_units
   col :fuel_efficiency_highway, :type => :float
   col :fuel_efficiency_highway_units
-
-  # TODO convert to table_warnings
-  # verify "Fuel efficiencies should be greater than zero" do
-  #   AutomobileMakeModel.all.each do |model|
-  #     %w{ city highway }.each do |type|
-  #       fuel_efficiency = model.send(:"fuel_efficiency_#{type}")
-  #       unless fuel_efficiency > 0
-  #         raise "Invalid fuel efficiency #{type} for AutomobileMakeModel #{model.name}: #{fuel_efficiency} (should be > 0)"
-  #       end
-  #     end
-  #   end
-  # end
-  # 
-  # verify "Fuel efficiency units should be kilometres per litre" do
-  #   AutomobileMakeModel.all.each do |model|
-  #     %w{ city highway }.each do |type|
-  #       units = model.send(:"fuel_efficiency_#{type}_units")
-  #       unless units == "kilometres_per_litre"
-  #         raise "Invalid fuel efficiency #{type} units for AutomobileMakeModel #{model.name}: #{units} (should be kilometres_per_litre)"
-  #       end
-  #     end
-  #   end
-  # end
 end

data/lib/earth/automobile/automobile_make_model/data_miner.rb

@@ -13,26 +13,25 @@ AutomobileMakeModel.class_eval do
         :src => AutomobileMakeModelYearVariant,
         :dest => AutomobileMakeModel,
         :cols => {
-          :make_model_name => :name,
+          [:make_name, :model_name] => :name,
           :make_name => :make_name,
-          :name => :model_name
+          :model_name => :model_name
         }
-        # :where => 'LENGTH(src.make_name) > 0 AND LENGTH(src.make_model_name) > 0'
       )
     end
     
-    # FIXME TODO make this a method on AutomobileMakeModel?
-    # TODO not weighted until we get weightings on auto variants
+    # FIXME TODO not weighted until we get weightings on auto variants
     process "Derive average fuel economy from automobile make model year variants" do
-      models = AutomobileMakeModel.arel_table
+      models = arel_table
       variants = AutomobileMakeModelYearVariant.arel_table
-      conditional_relation = models[:name].eq(variants[:make_model_name])
-      %w{ city highway }.each do |i|
-        null_check = variants[:"fuel_efficiency_#{i}"].not_eq(nil)
-        # sabshere 12/6/10 careful, don't use AutomobileMakeModelYearVariant.where here or you will be forced into projecting *
-        relation = variants.project(variants[:"fuel_efficiency_#{i}"].average).where(conditional_relation).where(null_check)
-        update_all "fuel_efficiency_#{i} = (#{relation.to_sql})"
-        update_all "fuel_efficiency_#{i}_units" => 'kilometres_per_litre'
+      conditional_relation = models[:make_name].eq(variants[:make_name]).and(models[:model_name].eq(variants[:model_name]))
+      %w{ city highway }.each do |type|
+        null_check = variants[:"fuel_efficiency_#{type}"].not_eq(nil)
+        relation = variants.project(variants[:"fuel_efficiency_#{type}"].average).where(conditional_relation).where(null_check)
+        update_all(%{
+          fuel_efficiency_#{type} = (#{relation.to_sql}),
+          fuel_efficiency_#{type}_units = 'kilometres_per_litre'
+        })
       end
     end
   end

data/lib/earth/automobile/automobile_make_model_year.rb

@@ -1,48 +1,17 @@
 class AutomobileMakeModelYear < ActiveRecord::Base
   set_primary_key :name
   
-  belongs_to :make_year,              :class_name => 'AutomobileMakeYear',             :foreign_key => 'make_year_name'
-  has_many :make_model_year_variants, :class_name => 'AutomobileMakeModelYearVariant', :foreign_key => 'make_model_year_name'
+  # Need this so Automobile and AutomobileTrip can do characteristics[:make_model_year].automobile_fuel
+  belongs_to :automobile_fuel, :foreign_key => 'fuel_code', :primary_key => 'code'
   
   col :name # make + model + year
   col :make_name
   col :model_name
-  col :make_model_name
-  col :year, :type => :integer
-  col :make_year_name
-  col :fuel_efficiency_city, :type => :float
+  col :year,                    :type => :integer
+  col :fuel_code
+  col :hybridity,               :type => :boolean
+  col :fuel_efficiency_city,    :type => :float
   col :fuel_efficiency_city_units
   col :fuel_efficiency_highway, :type => :float
   col :fuel_efficiency_highway_units
-
-  # TODO convert to table_warnings
-  # verify "Year should be from 1985 to 2011" do
-  #   AutomobileMakeModelYear.all.each do |model_year|
-  #     unless model_year.year.to_i > 1984 and model_year.year.to_i < 2012
-  #       raise "Invalid year for AutomobileMakeModelYear #{model_year.name}: #{model_year.year} (should be from 1985 to 2011)"
-  #     end
-  #   end
-  # end
-  # 
-  # verify "Fuel efficiencies should be greater than zero" do
-  #   AutomobileMakeModelYear.all.each do |model_year|
-  #     %w{ city highway }.each do |type|
-  #       fuel_efficiency = model_year.send(:"fuel_efficiency_#{type}")
-  #       unless fuel_efficiency.to_f > 0
-  #         raise "Invalid fuel efficiency #{type} for AutomobileMakeModelYear #{model_year.name}: #{fuel_efficiency} (should be > 0)"
-  #       end
-  #     end
-  #   end
-  # end
-  # 
-  # verify "Fuel efficiency units should be kilometres per litre" do
-  #   AutomobileMakeModelYear.all.each do |model_year|
-  #     %w{ city highway }.each do |type|
-  #       units = model_year.send(:"fuel_efficiency_#{type}_units")
-  #       unless units == "kilometres_per_litre"
-  #         raise "Invalid fuel efficiency #{type} units for AutomobileMakeModelYear #{model_year.name}: #{units} (should be kilometres_per_litre)"
-  #       end
-  #     end
-  #   end
-  # end
 end