terrapop_models 0.1.0

data/app/models/nhgis/time_series_table_time_series_release.rb

@@ -0,0 +1,7 @@
+require 'nhgis_database'
+module Nhgis
+  class TimeSeriesTableTimeSeriesRelease < NhgisActiveRecord::Base
+    self.table_name = "time_series_tables_x_time_series_releases"
+
+  end
+end

data/app/models/nhgis/time_series_table_topic.rb

@@ -0,0 +1,9 @@
+require 'nhgis_database'
+module Nhgis
+  class TimeSeriesTableTopic < NhgisActiveRecord::Base
+    self.table_name = "topics_x_time_series_tables"
+
+    belongs_to :time_series_table
+    belongs_to :topic
+  end
+end

data/app/models/nhgis/time_series_table_x_time_series.rb

@@ -0,0 +1,9 @@
+require 'nhgis_database'
+module Nhgis
+  class TimeSeriesTableXTimeSeries < NhgisActiveRecord::Base
+    self.table_name = "time_series_tables_x_time_series"
+
+    belongs_to :time_series_table
+    belongs_to :time_series
+  end
+end

data/app/models/nhgis_metadata_store.rb

@@ -0,0 +1,2 @@
+class NhgisMetadataStore < ActiveRecord::Base
+end

data/app/models/raster.rb

@@ -0,0 +1,5 @@
+class Raster < ActiveRecord::Base
+
+  belongs_to :raster_variable
+
+end

data/app/models/raster_category.rb

@@ -0,0 +1,6 @@
+class RasterCategory < ActiveRecord::Base
+
+  belongs_to :raster_variable
+  has_many   :raster_category_statistics
+
+end

data/app/models/raster_category_statistic.rb

@@ -0,0 +1,7 @@
+class RasterCategoryStatistic < ActiveRecord::Base
+
+  belongs_to :geog_instance
+  belongs_to :raster_variable
+  belongs_to :raster_category
+
+end

data/app/models/raster_data_type.rb

@@ -0,0 +1,6 @@
+class RasterDataType < ActiveRecord::Base
+  has_many :raster_variables
+  has_many :raster_operations
+  has_many :raster_dataset_raster_data_types
+  has_many :raster_datasets, :through => :raster_dataset_raster_data_types
+end

data/app/models/raster_dataset.rb

@@ -0,0 +1,130 @@
+class RasterDataset < ActiveRecord::Base
+
+  has_many :raster_dataset_raster_variables
+  has_many :raster_variables, through: :raster_dataset_raster_variables
+  has_many :raster_dataset_raster_data_types
+  has_many :raster_dataset_raster_dataset_units
+  has_many :raster_data_types, through: :raster_dataset_raster_data_types
+  has_many :raster_dataset_units, through: :raster_dataset_raster_dataset_units
+  has_many :map_unit_raster_datasets
+  has_many :map_units, through: :map_unit_raster_datasets
+
+  belongs_to :raster_dataset_group
+  belongs_to :resolution
+
+
+  def api_attributes
+    "TODO"
+  end
+
+
+  def formatted_north_extent
+    north_extent.nil? ? 'N/A' : sprintf("%.2f", north_extent)
+  end
+
+
+  def formatted_south_extent
+    south_extent.nil? ? 'N/A' : sprintf("%.2f", south_extent)
+  end
+
+
+  def formatted_east_extent
+    east_extent.nil?  ? 'N/A' : sprintf("%.2f", east_extent)
+  end
+
+
+  def formatted_west_extent
+    west_extent.nil?  ? 'N/A' : sprintf("%.2f", west_extent)
+  end
+
+
+  def map_unit
+    map_units.first.nil? ? 'Unknown Units' : map_units.first.unit_long
+  end
+
+
+  def raster_variable_mnemonics
+    raster_variables.pluck(:mnemonic)
+  end
+
+
+  def self.long_description(raster_datasets)
+    if raster_datasets.count > 0
+      datasets = {}
+      str = []
+      raster_datasets.each do |rd|
+        ld = rd.long_description
+        datasets[ld[:label]] = [] unless datasets.has_key? ld[:label]
+        datasets[ld[:label]] << ld[:years]
+      end
+      datasets.each{ |label, years| str << label + "\t" + years.join(", ") }
+      str.join("\n")
+    else
+      "No Raster Datasets"
+    end
+  end
+
+
+  def long_description
+    years = if begin_year == end_year
+      begin_year.to_s
+    else
+      begin_year.to_s + "-" + end_year.to_s
+    end
+    
+    unless raster_dataset_group.nil?
+      {label: raster_dataset_group.label, years: years}
+    else
+      {label: "*** Dataset Group Unavailable ***", years: years}
+    end
+    
+  end
+
+  def self.long_citation(raster_datasets)
+    
+    if raster_datasets.count > 0
+      groups = {}
+      str = []
+      raster_datasets.each do |rd|
+        unless rd.raster_dataset_group.nil?
+          unless groups.has_key? rd.raster_dataset_group.label
+            groups[rd.raster_dataset_group.label] = {citation: "<citation for #{rd.raster_dataset_group.label}>. Source data downloaded from <URL> on <date>.", time_points: {}}
+          end
+          
+          years = if rd.begin_year == rd.end_year
+            rd.begin_year.to_s
+          else
+            rd.begin_year.to_s + "-" + rd.end_year.to_s
+          end
+          
+          years = years.to_s
+          
+          unless groups[rd.raster_dataset_group.label][:time_points].has_key? years
+            groups[rd.raster_dataset_group.label][:time_points][years] = rd.period
+          end
+          
+        end
+      end
+      
+      groups.each do |label,info|
+        str << label
+        str << info[:citation]
+        
+        if info[:time_points].count > 1
+          s = "Time points:"
+        else
+          s = "Time point:"
+        end
+        
+        str << s + " " + info[:time_points].keys.join(", ") + "; " + info[:time_points].values.first
+        
+      end
+      
+      str.join("\n")
+    else
+      ""
+    end
+
+  end
+
+end

data/app/models/raster_dataset_group.rb

@@ -0,0 +1,3 @@
+class RasterDatasetGroup < ActiveRecord::Base
+  has_many :raster_datasets
+end

data/app/models/raster_dataset_raster_data_type.rb

@@ -0,0 +1,4 @@
+class RasterDatasetRasterDataType < ActiveRecord::Base
+  belongs_to :raster_dataset
+  belongs_to :raster_data_type
+end

data/app/models/raster_dataset_raster_dataset_unit.rb

@@ -0,0 +1,4 @@
+class RasterDatasetRasterDatasetUnit < ActiveRecord::Base
+  belongs_to :raster_dataset
+  belongs_to :raster_dataset_unit
+end

data/app/models/raster_dataset_raster_variable.rb

@@ -0,0 +1,4 @@
+class RasterDatasetRasterVariable < ActiveRecord::Base
+  belongs_to :raster_dataset
+  belongs_to :raster_variable
+end

data/app/models/raster_dataset_unit.rb

@@ -0,0 +1,4 @@
+class RasterDatasetUnit < ActiveRecord::Base
+  has_many :raster_dataset_raster_dataset_units
+  has_many :raster_datasets, :through => :raster_dataset_raster_dataset_units
+end

data/app/models/raster_group.rb

@@ -0,0 +1,87 @@
+class RasterGroup < ActiveRecord::Base
+  include ApiUtility
+  belongs_to :parent, class_name: "RasterGroup", foreign_key: "parent_id"
+
+  has_many :children, class_name: "RasterGroup", foreign_key: "parent_id"
+  has_many :raster_variable_group_memberships
+  has_many :raster_variables, through: :raster_variable_group_memberships
+
+  has_and_belongs_to_many :tags, join_table: :raster_groups_tags
+
+  def parent_mnemonic
+    parent.mnemonic
+  end
+
+  def sorted_children
+    sort_operation == 'name' ? children.order(:name) : children
+  end
+
+
+  def self.sort_collection(rg_id, collection)
+    raster_group = RasterGroup.where(id: rg_id).first
+    return collection if raster_group.nil? || !raster_group.respond_to?('sort_operation')
+    case raster_group.sort_operation
+    when 'mnemonic'
+      collection.order(:mnemonic)
+    when 'label'
+      collection.order(:label)
+    when 'mnemonic_month'
+      sort_by_mnemonic_month(collection)
+    else
+      collection
+    end
+  end
+
+
+  def sorted_variables
+    case sort_operation
+    when 'mnemonic'
+      raster_variables.order(:mnemonic)
+    when 'label'
+      raster_variables.order(:label)
+    when 'mnemonic_month'
+      sort_by_mnemonic_month(raster_variables)
+    when 'alphabetical_weight'
+      raster_variables.sort_by{ |e| [e.sort_weight, e.label] }
+    else
+      raster_variables
+    end
+  end
+
+  def table_type
+    self.class.to_s
+  end
+
+  def child_count
+    raster_variables.count
+  end
+
+  def in_cart_count(mnemonics)
+    raster_variables.where(mnemonic: mnemonics).count
+  end
+
+  def raster_datasets_count
+    nil
+  end
+
+  def _raster_dataset_id_
+    nil
+  end
+
+  def description
+    name
+  end
+
+  def begin_year
+    nil
+  end
+
+  def end_year
+    nil
+  end
+
+  def raster_data_type_id
+    nil
+  end
+
+end

data/app/models/raster_metadata.rb

@@ -0,0 +1,6 @@
+class RasterMetadata < ActiveRecord::Base
+# Raster Metadata holds the original XML metadata output by ArcGIS for the raster files.
+
+  belongs_to :raster_variable
+
+end

data/app/models/raster_operation.rb

@@ -0,0 +1,10 @@
+class RasterOperation < ActiveRecord::Base
+
+  belongs_to :raster_data_type
+
+  belongs_to :parent, :class_name => "RasterOperation", :foreign_key => "parent_id"
+  has_many :children, :class_name => "RasterOperation", :foreign_key => "parent_id"
+
+  alias_attribute :data_type_id, :raster_data_type_id
+
+end

data/app/models/raster_raster_variable.rb

@@ -0,0 +1,2 @@
+class RasterRasterVariable < ActiveRecord::Base
+end

data/app/models/raster_statistic.rb

@@ -0,0 +1,6 @@
+class RasterStatistic < ActiveRecord::Base
+
+  belongs_to :geog_instance
+  belongs_to :raster_variable
+
+end

data/app/models/raster_value.rb

@@ -0,0 +1,83 @@
+# == RasterValue
+#    provides a non-ActiveRecord-based class to hold the results of a call
+#    to the terrapop_raster_summary() stored proc.
+#
+# Code based on http://asciicasts.com/episodes/219-active-model
+# and http://www.deploymentzone.com/2012/04/09/postgres-table-value-functions-and-rails-3/
+
+class RasterValue
+  include ActiveModel::Validations  # these might not be necessary.
+  include ActiveModel::Conversion  
+  extend ActiveModel::Naming
+
+  attr_reader :sample_geog_level_id, :raster_variable_id, :geog_instance_id, :raster_operation_name
+  attr_reader :raster_mnemonic, :boundary_area, :summary_value, :geog_instance
+
+  def initialize(r)
+    
+    @sample_geog_level_id         = r.sample_geog_level_id
+    @raster_variable_id           = r.raster_variable_id
+    @raster_operation_name        = r.raster_operation_name
+    @geog_instance_id             = r.geog_instance_id
+    @internal_geog_instance_label = r.geog_instance_label
+    @internal_geog_instance_code  = r.geog_instance_code
+    @raster_mnemonic              = r.raster_mnemonic
+    @boundary_area                = r.has_area_reference ? r.raster_area : r.boundary_area
+    @summary_value                = r.summary_value
+    @geog_instance                = r.geog_instance
+    @raster_band_idx              = r.band_index
+    @raster_dataset               = RasterDataset.find(r.raster_dataset_id)
+    
+    if @geog_instance.nil?
+      raise "Must supply a geog_instance when creating a RasterValue"
+    end
+  end
+  
+  def persisted?  
+    false
+  end
+
+  def value
+    @summary_value
+  end
+
+  def geog_instance_code
+    geog_instance.code
+  end
+
+  def geog_instance_label
+    geog_instance.label
+  end
+  
+  def geog_instance_id
+    geog_instance.id
+  end
+  
+  def construct_synthetic_mnemonic
+    #sample_geog_level = SampleGeogLevel.find(sample_geog_level_id)
+    #geog_level_name = ""
+    
+    #unless sample_geog_level.geolink_variable.nil?
+    #  geog_level_name = sample_geog_level.geolink_variable.mnemonic
+    #else
+    #  geog_level_name = sample_geog_level.country_level.country.short_name.upcase + "_" + sample_geog_level.country_level.geog_unit.code
+    #end
+    
+    #"#{@raster_mnemonic}_#{geog_level_name}"
+    @raster_mnemonic
+  end
+  
+  def mnemonic
+    @raster_mnemonic
+  end
+
+  def mnemonic_sym
+    @raster_mnemonic.to_sym
+  end
+
+  def to_s
+    value.nil? ? "<not set>" : @raster_mnemonic + ": #{value}"
+  end
+
+
+end

data/app/models/raster_variable.rb

@@ -0,0 +1,440 @@
+class RasterVariable < ActiveRecord::Base
+
+  has_one :raster_metadata, dependent: :destroy
+
+  has_many :raster_variable_group_memberships
+  has_many :raster_groups, through: :raster_variable_group_memberships
+  has_many :raster_dataset_raster_variables
+  has_many :raster_datasets, through: :raster_dataset_raster_variables
+  has_many :area_data_rasters
+  has_many :raster_categories
+  has_many :raster_statistics
+  has_many :raster_category_statistics
+  has_many :assoc_raster_variables, class_name: "RasterVariable", foreign_key: "area_reference_id"
+  has_many :second_assoc_raster_variables, class_name: "RasterVariable", foreign_key: "second_area_reference_id"
+  has_many :raster_variable_classifications
+  has_many :mosaic_raster_variables, through: :raster_variable_classifications
+
+  has_and_belongs_to_many :topics
+
+  belongs_to :raster_data_type
+  belongs_to :raster_group
+  belongs_to :area_reference, class_name: "RasterVariable", foreign_key: "area_reference_id"
+  belongs_to :second_area_reference, class_name: "RasterVariable", foreign_key: "second_area_reference_id"
+
+
+  def api_attributes
+    "TODO"
+  end
+
+
+  def availability_by_country
+    _availability_by_country = {}
+    TerrapopSample.select('DISTINCT countries.full_name', :year).joins(:country).where.not(year: nil).order('countries.full_name', :year).each do |terrapop_sample|
+      _availability_by_country[terrapop_sample.full_name] ||= []
+      _availability_by_country[terrapop_sample.full_name] << terrapop_sample.year
+    end
+    _availability_by_country
+  end
+
+
+  def table_type
+    self.class.to_s
+  end
+
+
+  def child_count
+    1
+  end
+
+
+  def in_cart_count(mnemonics)
+    0
+  end
+
+
+  def raster_datasets_count
+    raster_datasets.count
+  end
+
+
+  def _raster_dataset_id_
+    raster_datasets.count > 0 ? raster_datasets.first.id : nil
+  end
+
+
+  def _raster_dataset_ids
+    raster_dataset_ids
+  end
+
+
+  def raster_dataset_mnemonics
+    raster_datasets.pluck(:mnemonic)
+  end
+
+
+  def raster_group_mnemonic
+    raster_groups.pluck(:mnemonic).first
+  end
+
+
+  def build_raster_value_from_row(r) #, geog_instance)
+    raise "Cannot build raster values without geog_instance, but it is nil." if r.geog_instance.nil?
+    #result = RasterValue.new(r['sample_geog_level_id'],
+    #  r['raster_variable_id'], r['raster_operation_name'],
+    #  r['geog_instance_id'], r['geog_instance_label'], r['geog_instance_code'],
+    #  r['raster_mnemonic'], r['raster_area'],
+    #  r['summary_value'], geog_instance)
+    #trsc.sample_geog_level_id   = r['sample_geog_level_id'].to_i
+    #trsc.raster_variable_id     = r['raster_variable_id'].to_i
+    #trsc.raster_operation_name  = r['raster_operation_name']
+    #trsc.geog_instance_id       = r['geog_instance_id'].to_i
+    #trsc.geog_instance_label    = r['geog_instance_label']
+    #trsc.geog_instance_code     = r['geog_instance_code'].to_f
+    #trsc.raster_mnemonic        = r['raster_mnemonic']
+    #trsc.boundary_area          = r['boundary_area'].to_f
+    #trsc.raster_area            = r['raster_area'].to_f
+    #trsc.summary_value          = r['summary_value'].to_f
+    #trsc.has_area_reference     = has_area_reference
+    result = RasterValue.new(r)
+  end
+
+
+  def setup_raster_metadata(xml)
+    if self.raster_metadata
+      self.raster_metadata.original_metadata = xml
+    else
+      self.build_raster_metadata(original_metadata: xml)
+    end
+    raster_metadata.save
+  end
+
+
+  def build_raster_values(level, raster_operation, raster_dataset)
+    # We'll also want to get the geog_instances for the results, so get those first,
+    # and put them in a hash so we can quickly find them later.
+    result_geog_instances = level.geog_instances
+    operation = raster_operation.opcode
+    
+    raise "The level #{level.to_s} must have at least one geog_instance." if result_geog_instances.empty?
+
+    geog_instance_lookup = Hash.new
+    result_geog_instances.each{ |e| geog_instance_lookup[e.id] = e }
+
+    unless raster_datasets.include? raster_dataset
+      $stderr.puts "**** Ignoring out-of-universe RasterDataset[#{raster_dataset.inspect}] for RasterVariable[#{mnemonic}] ****"
+      return []
+    end
+
+    # call select * from terrapop_raster_summary(level.id, this.id, operation);
+    # or select (terrapop_raster_summary(level.id, this.id, operation)).*
+    # where level is the sample_geog_level.id, this.id is the raster_variable_id of this raster, and operation is one of
+    # min, max, mean, sum, count, or mode.
+    # Should return collection of results that look something like this:
+    #
+    # sample_geog_level_id | raster_variable_id | raster_operation_name | geog_instance_label | geog_instance_code | raster_mnemonic  |  boundary_area   | summary_value
+    # ---------------------+--------------------+-----------------------+---------------------+--------------------+------------------+------------------+---------------
+    #                    2 |                333 | max                   | Rondônia            |                 11 | coffee_yield_max | 237581357173.494 |        0.8789
+    #                    2 |                333 | max                   | Acre                |                 12 | coffee_yield_max | 152576633081.708 |        0.9766
+    #                    2 |                333 | max                   | Amazonas            |                 13 | coffee_yield_max | 1577624256765.11 |        1.1621
+
+    #sample_geog_lvl_id bigint, raster_var_id bigint, raster_op_name varchar(32)
+
+    band = raster_dataset.raster_band_index.to_i
+    band = 1 if band <= 0
+
+    terrapop_raster_summary_caches = TerrapopRasterSummaryCache.where({:sample_geog_level_id => level.id, :raster_variable_id => id, :raster_operation_name => operation, band_index: band})
+
+    has_area_reference = !area_reference.nil?
+
+    if terrapop_raster_summary_caches.count == 0
+
+      stored_proc_call =
+        case raster_data_type.code
+        when 'binary'
+          # RETURNS TABLE(geog_instance_id bigint, geog_instance_label character varying, pixel_count bigint, binary_area double precision, percent_area double precision, total_area double precision)
+          "SELECT * FROM terrapop_reclassify_categorical_raster_to_binary_summariz_v4(#{level.id}, #{id}, #{band})"
+
+        when 'categorical'
+          # RETURNS TABLE(geog_instance_id bigint, geog_instance_label character varying, num_class bigint, mod_class double precision, total_area double precision)
+          "SELECT * FROM terrapop_categorical_raster_v1( #{level.id}, #{id}, #{band} )"
+
+        when 'contin'
+          raise "AreaReference nil: '#{mnemonic}' - should not be nil" if area_reference.nil?
+
+          # RETURNS TABLE (geog_instance_id bigint, geog_instance_label character varying, min double precision, max double precision, mean double precision, count bigint, stddev double precision, total_area double precision)
+
+          "SELECT * FROM terrapop_continuous_summarization0(#{level.id}, #{id})"
+
+        when 'cont_ext_arearef'
+
+          # RETURNS TABLE (geog_instance_id bigint, geog_instance_label character varying, count bigint, total_area double precision, mean double precision, stddev double precision, min double precision, max double precision)
+
+          "SELECT * FROM terrapop_continuous_summarization_without_arearef(#{level.id}, #{id}, #{band})"
+
+        else
+          raise "Raster without area_reference has been detected: RasterVariable[#{id}]" unless has_area_reference
+
+          if mnemonic.match(/YLD$/)
+            # RETURNS TABLE (geog_instance_id bigint, geog_instance_label character varying, min double precision, max double precision, mean double precision, count bigint)
+            "SELECT * FROM terrapop_gli_yield_areal_summarization_v2(#{level.id}, #{id})"
+          elsif mnemonic.match(/HAR$/)
+            # RETURNS TABLE (geog_instance_id bigint, geog_instance_label character varying, percent_area double precision, harvest_area double precision)
+            "SELECT * FROM terrapop_gli_harvest_areal_summarization_v2(#{level.id}, #{id})"
+          else
+            # RETURNS TABLE(geog_instance_id bigint, geog_instance_label character varying, binary_area double precision, total_area double precision, percent_area double precision)
+            "SELECT * FROM terrapop_glc_binary_summarization_v7(#{level.id}, #{id})"
+          end
+        end
+
+      $stderr.puts "===[RASTERVARIABLE INFO]       ===> #{mnemonic} | #{level.internal_code} [#{level.id}] | operation: #{operation} | band: #{band}"
+      $stderr.puts "===[RASTER SUMMARIZATION QUERY]===> #{stored_proc_call}"
+
+      result = ActiveRecord::Base.connection.execute(stored_proc_call)
+
+      all_columns = ['min', 'max', 'mean', 'count', 'num_class', 'mod_class', 'binary_area', 'percent_area', 'total_area', 'harvest_area']
+
+      if result.count > 0
+        terrapop_raster_summary_caches = []
+
+        seen = false
+
+        result.each do |r|
+
+          geog_instance_id =
+            if r.has_key? 'geog_instance_id'
+              r['geog_instance_id']
+            elsif r.has_key? 'geog_instance'
+              r['geog_instance']
+            else
+              -1
+            end
+
+          column_overlap = all_columns & r.keys
+          columns_n_operations = {}
+
+          # this is some fanciness of taking an array of hashes and squashing it down to just a hash; originally, each array element is just a single key/value pair
+          column_overlap = column_overlap.map{|field| {field => get_operation(field)}}.reduce Hash.new, :merge
+
+          unless seen
+            $stderr.puts "==[COLUMNs, OPs, BAND] => [#{column_overlap.inspect}, '#{band}']=="
+            seen = true
+          end
+
+          column_overlap.each do |column, op|
+
+            unless op.nil?
+
+              cnt = TerrapopRasterSummaryCache.where(raster_dataset_id: raster_dataset.id, geog_instance_id: geog_instance_id.to_i, sample_geog_level_id: level.id, raster_variable_id: id, raster_operation_name: op, band_index: band).count
+
+              if cnt == 0
+
+                trsc = TerrapopRasterSummaryCache.new
+
+                val = get_value(r, op).to_f
+                
+                if op.match(/percent/)
+                  val *= 100
+                end
+
+                trsc.sample_geog_level_id   = (r.has_key?('sample_geog_level_id')  ? r['sample_geog_level_id'].to_i : level.id)
+                trsc.raster_variable_id     = id
+                trsc.raster_operation_name  = (r.has_key?('raster_operation_name') ? r['raster_operation_name']     : op)
+                trsc.geog_instance_id       = geog_instance_id
+                trsc.geog_instance_label    = r['geog_instance_label']
+                trsc.geog_instance_code     = (r.has_key?('geog_instance_code')    ? r['geog_instance_code'].to_f   : -1.0)
+                trsc.raster_mnemonic        = RequestRasterVariable.mnemonic(self, raster_operation, raster_dataset, level) #mnemonic + "_" + op + "_" + band.to_s
+                trsc.boundary_area          = (r.has_key?('boundary_area')         ? r['boundary_area'].to_f        : -1.0)
+                trsc.raster_area            = (r.has_key?('raster_area')           ? r['raster_area'].to_f          : (r.has_key?('total_area') ? r['total_area'].to_f : -1.0))
+                trsc.summary_value          = val
+                trsc.has_area_reference     = has_area_reference
+                trsc.band_index             = band
+                trsc.raster_dataset_id      = raster_dataset.id
+
+                trsc.save
+
+              end
+            else
+              $stderr.puts "**** get_operation('#{column}'), raster_data_type.code[#{raster_data_type.code}] passed thru without operation and returned nil; result had the fields: #{r.keys.join(", ")} ****"
+            end
+          end
+
+        end
+
+        ### UNCOMMENT WHEN RE-ENABLING CACHING
+        terrapop_raster_summary_caches = TerrapopRasterSummaryCache.where(raster_dataset_id: raster_dataset.id, sample_geog_level_id: level.id, raster_variable_id: id, raster_operation_name: operation, band_index: band)
+      end
+    end
+
+    output = terrapop_raster_summary_caches.map do |r|
+      # build_raster_value_from_row(r, geog_instance_lookup[r.geog_instance_id.to_i])
+      # build_raster_value_from_row(r)
+      RasterValue.new(r)
+    end
+    output
+  end
+
+
+  def get_operation(column_name)
+    case column_name
+    when 'mod_class'
+      'mode'
+    when 'num_class'
+      'num_classes'
+    when 'min'
+      'min'
+    when 'max'
+      'max'
+    when 'mean'
+      'mean'
+    when 'count'
+      'count'
+    when 'binary_area'
+      'binary_area'
+    when 'total_area'
+      if raster_data_type.code == 'cont_ext_arearef'
+        'total_area_ref'
+      elsif raster_data_type.code == 'binary'
+        'total_area_bin'
+      elsif raster_data_type.code == 'cont_ext_areaprop' or raster_data_type.code == 'contin'
+        'total_area_areal'
+      end
+    when 'harvest_area'
+      'total_area_areal'
+    when 'percent_area'
+      if raster_data_type.code == 'binary'
+        'percent_area_bin'
+      elsif raster_data_type.code == 'cont_ext_areaprop'
+        'percent_area_areal'
+      end
+    else
+      raise "ERR: unable to find operation for '#{column_name}'"
+    end
+  end
+
+
+  def get_value(raster_summary_row, operation)
+    # min double precision, max double precision, mean double precision, count double precision,stddev double precision, total_area double precision
+    case operation
+    when 'mode'
+      raster_summary_row['mod_class']
+    when 'num_classes'
+      raster_summary_row['num_class']
+    when 'min'
+      raster_summary_row['min']
+    when 'max'
+      raster_summary_row['max']
+    when 'mean'
+      raster_summary_row['mean']
+    when 'count'
+      raster_summary_row['count']
+    when 'total_area_areal'
+      if raster_summary_row.has_key? 'binary_area'
+        raster_summary_row['binary_area']
+      elsif raster_summary_row.has_key? 'total_area'
+        raster_summary_row['total_area']
+      elsif raster_summary_row.has_key? 'harvest_area'
+        raster_summary_row['harvest_area']
+      end
+    when 'total_area_ref'
+      raster_summary_row['total_area']
+    when 'total_area'
+      if raster_summary_row.has_key? 'total_area'
+        raster_summary_row['total_area']
+      elsif raster_summary_row.has_key? 'harvest_area'
+        raster_summary_row['harvest_area']
+      end
+    when 'percent_area_bin'
+      if raster_summary_row.has_key? 'percent_area'
+        raster_summary_row['percent_area']
+      end
+    when 'percent_area_areal'
+      if raster_summary_row.has_key? 'percent'
+        raster_summary_row['percent']
+      elsif raster_summary_row.has_key? 'percent_area'
+        raster_summary_row['percent_area']
+      end
+    when 'percent_area'
+      if raster_summary_row.has_key? 'percent'
+        raster_summary_row['percent']
+      elsif raster_summary_row.has_key? 'percent_area'
+        raster_summary_row['percent_area']
+      end
+    when 'total_area_bin'
+      raster_summary_row['binary_area']
+    when 'binary_area'
+      raster_summary_row['binary_area']
+    else
+      raise "Unknown/Unsupported raster operation - '#{operation}'"
+    end
+  end
+
+
+  def get_base_categorical_stats(sample_geog_level)
+    sql = "select label, terrapop_sample_id, code, ST_ValueCount(rast) as category_count from (
+        select label, code, terrapop_sample_id, st_union(rast) as rast from (
+          SELECT sgl.terrapop_sample_id as terrapop_sample_id, gi.label as label, gi.code as code, ST_Clip(them_rasters.rast, bound.geog::geometry) as rast
+          FROM sample_geog_levels sgl
+          inner join geog_instances gi on sgl.id = gi.sample_geog_level_id
+          inner join boundaries bound on bound.geog_instance_id = gi.id
+          inner join rasters AS them_rasters on ST_Intersects(them_rasters.rast, bound.geog::geometry)
+          where sgl.id = #{sample_geog_level.id} AND them_rasters.raster_variable_id = #{id}
+        ) base
+        group by label, code, terrapop_sample_id
+      ) unioned
+      order by code"
+    ActiveRecord::Base.connection.execute(sql)
+  end
+
+
+  def get_categorical_statistics(sample_geog_level)
+    get_base_categorical_stats(sample_geog_level).map{ |result|
+      result['category_count'].scan(/\(([0-9]+),([0-9]+)\)/).collect{ |category, count| {category => count} }
+    }.flatten.inject(:merge)
+  end
+
+
+  def get_statistics(sample_geog_level)
+    sample_precision = TerrapopConfiguration["application"]["environments"][Rails.env]["raster_sample_precision"]
+    sql = "SELECT label, terrapop_sample_id, code, (statistics).* FROM (
+            select label, terrapop_sample_id, code, _ST_SummaryStats(rast, 1, true, #{sample_precision}) as statistics from (
+              select label, code, terrapop_sample_id, st_union(rast) as rast from (
+                SELECT sgl.terrapop_sample_id as terrapop_sample_id, gi.label as label, gi.code as code, ST_Clip(them_rasters.rast, bound.geog::geometry) as rast
+                FROM sample_geog_levels sgl
+                inner join geog_instances gi on sgl.id = gi.sample_geog_level_id
+                inner join boundaries bound on bound.geog_instance_id = gi.id
+                inner join rasters AS them_rasters on ST_Intersects(them_rasters.rast, bound.geog::geometry)
+                where sgl.id = 1 AND them_rasters.raster_variable_id = 145
+              ) base
+              group by label, code, terrapop_sample_id
+            ) unioned
+            order by code
+          ) as block"
+    results = ActiveRecord::Base.connection.execute(sql)
+    results.first
+  end
+
+
+  def reclass_str
+    buckets = {}
+    self.raster_variable_classifications.each do |rvc|
+      buckets[rvc.grouping] ||= []
+      buckets[rvc.grouping] << rvc.mosaic_raster_variable
+    end
+    buckets
+  end
+
+
+  def self.long_description(raster_variables)
+    str = []
+    raster_variables.each{ |rv| str << rv.long_description }
+    str.join("\n")
+  end
+
+
+  def long_description
+    mnemonic + "\t" + label + "\t(" + units.to_s + ")\t" + raster_datasets.first.raster_dataset_group.label
+  end
+
+
+end