earth-ruby19 0.2.3

data/Gemfile

@@ -0,0 +1,5 @@
+gem 'data_miner', :path => ENV['LOCAL_DATA_MINER'] if ENV['LOCAL_DATA_MINER']
+
+source :rubygems
+
+gemspec :path => '.'

data/Gemfile.lock

@@ -0,0 +1,138 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    GData (0.0.4)
+      builder (>= 2.1.2)
+      hoe (>= 1.2.1)
+    activemodel (3.0.0)
+      activesupport (= 3.0.0)
+      builder (~> 2.1.2)
+      i18n (~> 0.4.1)
+    activerecord (3.0.0)
+      activemodel (= 3.0.0)
+      activesupport (= 3.0.0)
+      arel (~> 1.0.0)
+      tzinfo (~> 0.3.23)
+    activesupport (3.0.0)
+    amatch (0.2.5)
+    andand (1.3.1)
+    arel (1.0.1)
+      activesupport (~> 3.0.0)
+    blockenspiel (0.3.2)
+    builder (2.1.2)
+    cohort_scope (0.0.7)
+      activerecord (>= 3.0.0.beta4)
+      activesupport (>= 3.0.0.beta4)
+    conversions (1.4.5)
+      activesupport (>= 2.3.4)
+    data_miner (0.5.4)
+      activerecord (>= 2.3.4)
+      activesupport (>= 2.3.4)
+      andand (>= 1.3.1)
+      blockenspiel (= 0.3.2)
+      conversions (>= 1.4.4)
+      errata (>= 0.2.1)
+      escape (>= 0.0.4)
+      log4r (>= 1.1.7)
+      remote_table (>= 0.2.30)
+      taps (>= 0.3.11)
+    diff-lcs (1.1.2)
+    errata (0.2.3)
+      activesupport (>= 2.3.4)
+      remote_table (>= 0.2.20)
+    escape (0.0.4)
+    falls_back_on (0.0.3)
+      activerecord
+    fastercsv (1.5.3)
+    gemcutter (0.6.1)
+    geokit (1.5.0)
+    git (1.2.5)
+    hoe (2.6.2)
+      rake (>= 0.8.7)
+      rubyforge (>= 2.0.4)
+    hpricot (0.8.2)
+    i18n (0.4.1)
+    jeweler (1.4.0)
+      gemcutter (>= 0.1.0)
+      git (>= 1.2.5)
+      rubyforge (>= 2.0.0)
+    json_pure (1.4.6)
+    libxml-ruby (1.1.4)
+    log4r (1.1.8)
+    loose_tight_dictionary (0.0.8)
+      activesupport (>= 2.3.4)
+      amatch (>= 0.2.5)
+      andand (>= 1.3.1)
+      fastercsv (>= 1.5.3)
+    mime-types (1.16)
+    nokogiri (1.4.3.1)
+    rack (1.2.1)
+    rake (0.8.7)
+    rcov (0.9.9)
+    rdoc (2.5.11)
+    remote_table (0.2.30)
+      activesupport (>= 2.3.4)
+      escape (>= 0.0.4)
+      fastercsv (>= 1.5.0)
+      nokogiri (>= 1.4.1)
+      roo (= 1.3.11)
+      slither (>= 0.99.3)
+    rest-client (1.4.2)
+      mime-types (>= 1.16)
+    roo (1.3.11)
+      GData (>= 0.0.4)
+      hpricot (>= 0.6)
+      libxml-ruby (>= 1.1.3)
+      rubyzip (>= 0.9.1)
+      spreadsheet (>= 0.6.4)
+    rspec (2.0.0.beta.22)
+      rspec-core (= 2.0.0.beta.22)
+      rspec-expectations (= 2.0.0.beta.22)
+      rspec-mocks (= 2.0.0.beta.22)
+    rspec-core (2.0.0.beta.22)
+    rspec-expectations (2.0.0.beta.22)
+      diff-lcs (>= 1.1.2)
+    rspec-mocks (2.0.0.beta.22)
+      rspec-core (= 2.0.0.beta.22)
+      rspec-expectations (= 2.0.0.beta.22)
+    ruby-ole (1.2.10.1)
+    rubyforge (2.0.4)
+      json_pure (>= 1.1.7)
+    rubyzip (0.9.4)
+    sequel (3.15.0)
+    sinatra (1.0)
+      rack (>= 1.0)
+    slither (0.99.3)
+    spreadsheet (0.6.4.1)
+      ruby-ole
+    sqlite3-ruby (1.3.1)
+    taps (0.3.12)
+      json_pure (>= 1.2.0, < 1.5.0)
+      rack (>= 1.0.1)
+      rest-client (~> 1.4.0)
+      sequel (~> 3.15.0)
+      sinatra (~> 1.0.0)
+      sqlite3-ruby (~> 1.2)
+    tzinfo (0.3.23)
+    weighted_average (0.0.5)
+      activerecord (>= 3.0.0.beta2)
+      arel (>= 0.3.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (>= 3.0.0.beta4)
+  cohort_scope (>= 0.0.7)
+  conversions (>= 1.4.5)
+  data_miner (>= 0.5.3)
+  falls_back_on (>= 0.0.3)
+  geokit (>= 1.5.0)
+  jeweler
+  loose_tight_dictionary (>= 0.0.8)
+  rake
+  rcov
+  rdoc
+  rspec (>= 2.0.0.beta.17)
+  sqlite3-ruby (>= 1.3.0)
+  weighted_average (>= 0.0.4)

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Andy Rossmeissl
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,38 @@
+# earth
+
+Earth is a collection of data models that represent various things found here on Earth, such as pet breeds, kinds of rail travel, zip codes, and Petroleum Administration for Defense Districts.
+
+The data that these models represent can be pulled from http://data.brighterplanet.com
+
+## Usage
+
+    require 'earth'
+    Earth.init :automobile, :locality
+    ft = AutomobileFuelType.first
+    ...
+
+You can also run data imports via the data_miner gem.
+
+    require 'earth'
+    Earth.init :fuel
+    Earth.taps_server # 'http://user:pass@data.brighterplanet.com'
+
+    DataMiner.run :resource_names #> [FuelPrice]</tt>
+
+## Collaboration cycle 
+Brighter Planet vigorously encourages collaborative improvement of its emitter libraries. Collaboration requires a (free) GitHub account.
+
+### You
+1.  Fork the earth repository on GitHub.
+1.  Write a test proving the existing implementation's inadequacy. Ensure that the test fails. Commit the test.
+1.  Improve the code until your new test passes and commit your changes.
+1.  Push your changes to your GitHub fork.
+1.  Submit a pull request to brighterplanet.
+
+### Brighter Planet
+1.  Receive a pull request.
+1.  Pull changes from forked repository.
+1.  Ensure tests pass.
+1.  Review changes for scientific accuracy.
+1.  Merge changes to master repository and publish.
+1.  Direct production environment to use new emitter version.

data/lib/earth.rb

@@ -0,0 +1,146 @@
+require 'active_record'
+require 'cohort_scope'
+require 'earth/base'
+require 'earth/conversions_ext'
+require 'earth/inflectors'
+require 'data_miner'
+require 'falls_back_on'
+require 'falls_back_on/active_record_ext'
+require 'weighted_average'
+require 'loose_tight_dictionary'
+
+# The earth module is an interface for establishing a taps server (used to fetch 
+# data) and for loading data models from various domains.
+module Earth
+  extend self
+
+  def taps_server
+    if defined?(@taps_server)
+      @taps_server
+    else
+      @taps_server = nil
+    end
+  end
+
+  # taps_server is a URL. See the data_miner gem docs
+  def taps_server=(val)
+    @taps_server = val
+  end
+  
+  # Takes argument like Earth.resource_names(['air'])
+  # Default is search all domains
+  # For example, <tt>[ 'Aircraft', 'Airline' ]</tt>
+  def resource_names(search_domains = nil)
+    (search_domains || domains).map do |domain|
+      Dir[File.join(Earth.gem_root, 'lib', 'earth', domain, '*.rb')]
+    end.flatten.uniq.map { |p| File.basename(p, '.rb').camelcase } - %w{ DataMiner }
+  end
+
+  def gem_root 
+    File.expand_path File.join(File.dirname(__FILE__), '..')
+  end
+
+  def domains
+    %w{air automobile bus diet fuel locality pet rail residence}
+  end
+
+  # Earth.init will load any specified domains, any needed ActiveRecord plugins, 
+  # and will apply each domain model's schema to the database if the 
+  # :apply_schemas option is given. See Earth.domains for the list of allowable 
+  # domains.
+  #
+  # Earth.init should be performed after a connection is made to the database and 
+  # before any domain models are referenced.
+  def init(*args)
+    load_plugins
+
+    domains = []
+    options = {}
+    args.each do |arg|
+      if arg.is_a?(Hash)
+        options = arg
+      else
+        domains << arg
+      end
+    end
+
+    load_domains(domains, options)
+    load_schemas if options[:apply_schemas]
+  end
+
+  def database_options
+    if ActiveRecord::Base.connection.adapter_name.downcase == 'sqlite'
+      {}
+    else
+      { :options => 'ENGINE=InnoDB default charset=utf8' }
+    end
+  end
+
+private
+  def load_domains(domains, options)
+    if domains.empty? or domains.include?(:all)
+      # sabshere 9/16/10 why maintain this separately?
+      require 'earth/all'
+      require 'earth/data_miner' if options[:apply_schemas] or options[:load_data_miner]
+    elsif !domains.include?(:none)
+      domains.each do |domain| 
+        require "earth/#{domain}"
+        if options[:apply_schemas] or options[:load_data_miner]
+          begin
+            require "earth/#{domain}/data_miner"
+          rescue LoadError
+          end
+        end
+      end
+    end
+  end
+
+  def load_plugins
+    require 'earth/active_record_ext'
+    Dir[File.join(Earth.gem_root, 'vendor', '**', 'init.rb')].each do |pluginit|
+      $:.unshift File.join(File.dirname(pluginit), 'lib')
+      load pluginit
+    end
+  end
+
+  def load_schemas
+    force_fallback_table
+    load_data_miner_schemas
+  end
+  
+  # sabshere 9/17/10 this sucks. the falls_back_on gem sucks.
+  def force_fallback_table
+    c = ActiveRecord::Base.connection
+    if c.table_exists? 'fallbacks'
+      raise "The earth gem expects a different schema for the fallbacks table." unless  c.column_exists?('fallbacks', 'name') and
+                                                                                        c.column_exists?('fallbacks', 'values') and
+                                                                                        c.column_exists?('fallbacks', 'created_at') and
+                                                                                        c.column_exists?('fallbacks', 'updated_at')
+    else
+      c.create_table 'fallbacks' do |t|
+        t.string   'name'
+        t.text     'values'
+        t.datetime 'created_at'
+        t.datetime 'updated_at'
+      end
+    end
+  end
+
+  def load_data_miner_schemas
+    models = Module.constants.select do |k|
+      const = Object.const_get(k) if Object.const_defined?(k)
+      if const.instance_of?(Class)
+        const.superclass == ActiveRecord::Base || 
+          const.superclass == Earth::Base
+      else
+        false
+      end
+    end
+    models.sort.each do |model|
+      klass = Object.const_get(model)
+      if klass.respond_to?(:execute_schema) and !klass.table_exists?
+        klass.execute_schema 
+      end
+    end
+  end
+end

data/lib/earth/active_record_ext.rb

@@ -0,0 +1,9 @@
+require 'active_record'
+::ActiveRecord::Base.class_eval do
+  def self.run_data_miner_on_belongs_to_associations
+    reflect_on_all_associations(:belongs_to).each do |a|
+      next if a.options[:polymorphic]
+      a.klass.run_data_miner!
+    end
+  end
+end

data/lib/earth/air.rb

@@ -0,0 +1,13 @@
+require 'earth/air/aircraft'
+require 'earth/air/aircraft_class'
+require 'earth/air/aircraft_manufacturer'
+require 'earth/air/airline'
+require 'earth/air/airport'
+require 'earth/air/flight_configuration'
+require 'earth/air/flight_distance_class'
+require 'earth/air/flight_domesticity'
+require 'earth/air/flight_fuel_type'
+require 'earth/air/flight_propulsion'
+require 'earth/air/flight_seat_class'
+require 'earth/air/flight_segment'
+require 'earth/air/flight_service'

data/lib/earth/air/aircraft.rb

@@ -0,0 +1,21 @@
+class Aircraft < ActiveRecord::Base
+  set_primary_key :icao_code
+  
+  belongs_to :aircraft_class, :foreign_key => 'brighter_planet_aircraft_class_code'
+  belongs_to :manufacturer,   :foreign_key => 'manufacturer_name',                  :class_name => 'AircraftManufacturer'
+  has_many   :segments,       :foreign_key => 'bts_aircraft_type_code',             :class_name => "FlightSegment", :primary_key => 'bts_aircraft_type_code'
+
+  falls_back_on :m3 =>                      lambda { weighted_average(:m3,             :weighted_by => [:segments, :passengers]) }, # 9.73423082858437e-08   r7110: 8.6540464368905e-8      r6972: 8.37e-8
+                :m2 =>                      lambda { weighted_average(:m2,             :weighted_by => [:segments, :passengers]) }, # -0.000134350543484608  r7110: -0.00015337661447817    r6972: -4.09e-5
+                :m1 =>                      lambda { weighted_average(:m1,             :weighted_by => [:segments, :passengers]) }, # 6.7728101555467        r7110: 4.7781966869412         r6972: 7.85
+                :endpoint_fuel =>           lambda { weighted_average(:endpoint_fuel,  :weighted_by => [:segments, :passengers]) }, # 1527.81790006167       r7110: 1065.3476555284         r6972: 1.72e3
+                :seats =>                   lambda { weighted_average(:seats,          :weighted_by => [:segments, :passengers]) } # 62.1741
+
+  data_miner do
+    tap "Brighter Planet's sanitized aircraft data", Earth.taps_server
+    
+    process "pull dependencies" do
+      run_data_miner_on_belongs_to_associations
+    end
+  end
+end

data/lib/earth/air/aircraft/data_miner.rb

@@ -0,0 +1,184 @@
+Aircraft.class_eval do
+  
+  # TODO use http://www.transtats.bts.gov/Download_Lookup.asp?Lookup=L_AIRCRAFT_TYPE
+  def self.bts_name_dictionary
+    @_bts_dictionary ||= LooseTightDictionary.new RemoteTable.new(:url => 'http://www.transtats.bts.gov/Download_Lookup.asp?Lookup=L_AIRCRAFT_TYPE', :select => lambda { |record| record['Code'].to_i.between?(1, 998) }),
+                                                  :tightenings  => RemoteTable.new(:url => 'http://spreadsheets.google.com/pub?key=tiS_6CCDDM_drNphpYwE_iw&single=true&gid=0&output=csv', :headers => false),
+                                                  :identities   => RemoteTable.new(:url => 'http://spreadsheets.google.com/pub?key=tiS_6CCDDM_drNphpYwE_iw&single=true&gid=3&output=csv', :headers => false),
+                                                  :blockings    => RemoteTable.new(:url => 'http://spreadsheets.google.com/pub?key=tiS_6CCDDM_drNphpYwE_iw&single=true&gid=4&output=csv', :headers => false),
+                                                  :blocking_only => true,
+                                                  :right_reader => lambda { |record| record['Description'] }
+  end
+  
+  # warning: self-referential, assumes it will be used once first import step is done
+  def self.icao_name_dictionary
+    @_icao_dictionary ||= LooseTightDictionary.new Aircraft.all,
+                                                   :tightenings  => RemoteTable.new(:url => 'http://spreadsheets.google.com/pub?key=tiS_6CCDDM_drNphpYwE_iw&single=true&gid=0&output=csv', :headers => false),
+                                                   :identities   => RemoteTable.new(:url => 'http://spreadsheets.google.com/pub?key=tiS_6CCDDM_drNphpYwE_iw&single=true&gid=3&output=csv', :headers => false),
+                                                   :blockings    => RemoteTable.new(:url => 'http://spreadsheets.google.com/pub?key=tiS_6CCDDM_drNphpYwE_iw&single=true&gid=4&output=csv', :headers => false),
+                                                   :right_reader => lambda { |record| record.manufacturer_name.to_s + ' ' + record.name.to_s }
+  end
+
+  class Aircraft::BtsMatcher
+    attr_reader :wants
+    def initialize(wants)
+      @wants = wants
+    end
+    def match(raw_faa_icao_record)
+      @_match ||= Hash.new
+      return @_match[raw_faa_icao_record] if @_match.has_key?(raw_faa_icao_record)
+      faa_icao_record = [ raw_faa_icao_record['Manufacturer'] + ' ' + raw_faa_icao_record['Model'] ]
+      bts_record = Aircraft.bts_name_dictionary.left_to_right faa_icao_record
+      retval = case wants
+      when :bts_aircraft_type_code
+        bts_record['Code']
+      when :bts_name
+        bts_record['Description']
+      end if bts_record
+      @_match[raw_faa_icao_record] = retval
+    end
+  end
+
+  class Aircraft::FuelUseMatcher
+    def match(raw_fuel_use_record)
+      @_match ||= Hash.new
+      return @_match[raw_fuel_use_record] if @_match.has_key?(raw_fuel_use_record)
+
+      aircraft_record = if raw_fuel_use_record['ICAO'] =~ /\A[0-9A-Z]+\z/
+        Aircraft.find_by_icao_code raw_fuel_use_record['ICAO']
+      end
+      
+      aircraft_record ||= if raw_fuel_use_record['Aircraft Name'].present?
+        Aircraft.icao_name_dictionary.left_to_right [ raw_fuel_use_record['Aircraft Name'] ]
+      end
+      
+      if aircraft_record
+        @_match[raw_fuel_use_record] = aircraft_record.icao_code
+      else
+        raise "Didn't find a match for #{raw_fuel_use_record['Aircraft Name']} (#{raw_fuel_use_record['ICAO']}), which we found in the fuel use spreadsheet"
+      end
+    end
+  end
+
+  class Aircraft::Guru
+    # for errata
+    def is_a_dc_plane?(row)
+      row['Designator'] =~ /^DC\d/i
+    end
+    
+    # def is_a_crj_900?(row)
+    #   row['Designator'].downcase == 'crj9'
+    # end
+    
+    def is_a_g159?(row)
+      row['Designator'] =~ /^G159$/
+    end
+
+    def is_a_galx?(row)
+      row['Designator'] =~ /^GALX$/
+    end
+    
+    def method_missing(method_id, *args, &block)
+      if method_id.to_s =~ /\Ais_n?o?t?_?attributed_to_([^\?]+)/
+        manufacturer_name = $1
+        manufacturer_regexp = Regexp.new(manufacturer_name.gsub('_', ' ?'), Regexp::IGNORECASE)
+        matches = manufacturer_regexp.match(args.first['Manufacturer']) # row['Manufacturer'] =~ /mcdonnell douglas/i
+        method_id.to_s.include?('not_attributed') ? matches.nil? : !matches.nil?
+      else
+        super
+      end
+    end
+  end
+
+  data_miner do
+    schema Earth.database_options do
+      string   'icao_code'
+      string   'manufacturer_name'
+      string   'name'
+      string   'bts_name'
+      string   'bts_aircraft_type_code'
+      string   'brighter_planet_aircraft_class_code'
+      string   'fuel_use_aircraft_name'
+      float    'm3'
+      string   'm3_units'
+      float    'm2'
+      string   'm2_units'
+      float    'm1'
+      string   'm1_units'
+      float    'endpoint_fuel'
+      string   'endpoint_fuel_units'
+      float    'seats'
+      float    'distance'
+      string   'distance_units'
+      float    'load_factor'
+      float    'freight_share'
+      float    'payload'
+      float    'weighting'
+      index    'bts_aircraft_type_code'
+    end
+    
+    ('A'..'Z').each do |letter|
+    # ('Z'..'Z').each do |letter|
+      import( "ICAO aircraft codes starting with the letter #{letter} used by the FAA",
+              :url => "http://www.faa.gov/air_traffic/publications/atpubs/CNT/5-2-#{letter}.htm",
+              :errata => Errata.new(:url => 'http://spreadsheets.google.com/pub?key=tObVAGyqOkCBtGid0tJUZrw',
+                                    :responder => Aircraft::Guru.new),
+              :encoding => 'windows-1252',
+              :row_xpath => '//table/tr[2]/td/table/tr',
+              :column_xpath => 'td' ) do
+        key 'icao_code', :field_name => 'Designator'
+        store 'bts_aircraft_type_code', :matcher => Aircraft::BtsMatcher.new(:bts_aircraft_type_code)
+        store 'bts_name', :matcher => Aircraft::BtsMatcher.new(:bts_name)
+        store 'manufacturer_name', :field_name => 'Manufacturer'
+        store 'name', :field_name => 'Model'
+      end
+    end
+    
+    # TODO fixme need to remake aircraft classes dictionary based on ICAO codes
+    # sabshere 5/17/10 or maybe we can replace this with typ/weight class from FAA (?)
+    import "Brighter Planet's aircraft class codes",
+           :url => 'http://static.brighterplanet.com/science/data/transport/air/bts_aircraft_type/bts_aircraft_types-brighter_planet_aircraft_classes.csv' do
+      key   'bts_aircraft_type_code', :field_name => 'bts_aircraft_type'
+      store 'brighter_planet_aircraft_class_code'
+    end
+
+    # EEA
+    import "pre-calculated fuel use equation coefficients",
+           :url => 'http://static.brighterplanet.com/science/data/transport/air/fuel_use/aircraft_fuel_use_formulae.ods',
+           :select => lambda { |row| row['ICAO'].present? or row['Aircraft Name'].present? } do
+      key   'icao_code', :matcher => Aircraft::FuelUseMatcher.new
+      store 'fuel_use_aircraft_name', :field_name => 'Aircraft Name'
+      store 'm3'
+      store 'm2'
+      store 'm1'
+      store 'endpoint_fuel', :field_name => 'b'
+    end
+    
+    process "Derive some average flight characteristics from flight segments" do
+      FlightSegment.run_data_miner!
+      aircraft = Aircraft.arel_table
+      segments = FlightSegment.arel_table
+
+      # non-working joins method
+      # update_all "aircraft.distance_1            = (SELECT * FROM (#{FlightSegment.joins(:aircraft).weighted_average_relation(:distance,            :weighted_by => :passengers                                           ).to_sql}) AS anonymous_1)"
+      # update_all "aircraft.load_factor_1         = (SELECT * FROM (#{FlightSegment.joins(:aircraft).weighted_average_relation(:load_factor,         :weighted_by => :passengers                                           ).to_sql}) AS anonymous_1)"
+      # execute %{
+      #   update aircraft as t1
+      #   set t1.distance_1 = (SELECT * FROM (#{FlightSegment.joins(:aircraft).weighted_average_relation(:distance,            :weighted_by => :passengers                                           ).where('t1.bts_aircraft_type_code = flight_segments.bts_aircraft_type_code').to_sql}) AS anonymous_1)
+      # }
+
+      conditional_relation = aircraft[:bts_aircraft_type_code].eq(segments[:bts_aircraft_type_code])
+      update_all "seats         = (#{FlightSegment.weighted_average_relation(:seats,         :weighted_by => :passengers                                           ).where(conditional_relation).to_sql})"
+      update_all "distance      = (#{FlightSegment.weighted_average_relation(:distance,      :weighted_by => :passengers                                           ).where(conditional_relation).to_sql})"
+      update_all "load_factor   = (#{FlightSegment.weighted_average_relation(:load_factor,   :weighted_by => :passengers                                           ).where(conditional_relation).to_sql})"
+      update_all "freight_share = (#{FlightSegment.weighted_average_relation(:freight_share, :weighted_by => :passengers                                           ).where(conditional_relation).to_sql})"
+      update_all "payload       = (#{FlightSegment.weighted_average_relation(:payload,       :weighted_by => :passengers, :disaggregate_by => :departures_performed).where(conditional_relation).to_sql})"
+      
+      update_all "weighting = (#{segments.project(segments[:passengers].sum).where(aircraft[:bts_aircraft_type_code].eq(segments[:bts_aircraft_type_code])).to_sql})"
+    end
+    
+    process "Synthesize AircraftManufacturer" do
+      AircraftManufacturer.run_data_miner!
+    end
+  end
+end