openstudio-standards 0.8.5 → 0.8.7

data/lib/openstudio-standards/btap/linear_regression.rb

@@ -0,0 +1,130 @@
+module BTAP
+  module LinearRegression
+    @extrapolation_boundaries_exceeded = false
+
+    # Read and reset the error to not carry over from previous calls in the case
+    # of using this module across different facilities.
+    # @return [TrueClass|FalseClass]
+    def self.extrapolation_boundaries_exceeded?
+      value = @extrapolation_boundaries_exceeded
+      @extrapolation_boundaries_exceeded = false
+      return value
+    end
+
+    # @param message [String]
+    # @return [String]
+    def self.fmt(message)
+      return "#{[BTAP::LinearRegression]} #{message}"
+    end
+
+    # Interpolate a 2D array for the dependent variable `x2` and get the
+    # y-intercept. Sets the extrapolation class variable if extrapolation
+    # boundaries were exceeded.
+    # @param x_y_array           [Array[Array]] 2D array of floats.
+    # @param x2                  [Float]        Dependent variable to be
+    #                                           interpolated.
+    # @param extrapolation_range [Float]
+    # @return [[Float, String]] The interpolated y-intercept and the warning
+    #                           message, "OK" if none.
+    def self.interpolate(x_y_array:, x2:, extrapolation_range: 0.02)
+      notes = "OK"
+      array = x_y_array.uniq.sort { |a, b| a[0] <=> b[0] }
+      extrapolation_percent = extrapolation_range * 100
+
+      if array.empty? 
+        return 0.0, fmt("Empty array given for interpolation, returning zero.")
+      elsif array.size == 1
+        return array.first[1].to_f, notes
+      end
+
+      x_lower_bound = (1.0 - extrapolation_range) * array[0][0]
+      x_upper_bound = (1.0 + extrapolation_range) * array[-1][0]
+      y_lower_bound = (1.0 - extrapolation_range) * array[0][1]
+      y_upper_bound = (1.0 + extrapolation_range) * array[-1][1]
+
+      if x2 < x_lower_bound
+        return y_lower_bound, fmt("Warning: Dependent variable #{x2} precedes the lower bound " \
+                            "(#{x_lower_bound}) for the #{extrapolation_percent}% range. Returning the lower " \
+                            "bound.")
+      elsif x2 > x_upper_bound
+        @extrapolation_boundaries_exceeded = true
+        return y_upper_bound, fmt("Warning: Dependent variable #{x2} exceeds the upper bound " \
+                            "(#{x_upper_bound}) for the #{extrapolation_percent}% range. Returning the upper " \
+                            "bound.")
+      elsif x2 < array.first[0].to_f
+
+        # Extrapolate down using first and second cost value to this
+        # out-of-range input.
+        x_array      = [array[0][0].to_f, array[1][0].to_f]
+        y_array      = [array[0][1].to_f, array[1][1].to_f]
+        linear_model = LinearModel.new(x_array, y_array)
+        y2           = linear_model.y_intercept + linear_model.slope * x2
+        return y2, notes
+      elsif x2 > array.last[0].to_f
+
+        # Extrapolate up using second to last and last cost value to this
+        # out-of-range input.
+        x_array      = [array[-2][0].to_f, array[-1][0].to_f]
+        y_array      = [array[-2][1].to_f, array[-1][1].to_f]
+        linear_model = LinearModel.new(x_array, y_array)
+        y2           = linear_model.y_intercept + linear_model.slope * x2
+        return y2, notes
+      else
+        array.each_index do |counter|
+
+          # skip last value.
+          next if array[counter] == array.last
+
+          x0 = array[counter][0]
+          y0 = array[counter][1]
+          x1 = array[counter + 1][0]
+          y1 = array[counter + 1][1]
+
+          # Skip if x2 is not between x0 and x1.
+          next if x2 < x0 || x2 > x1
+
+          y2 = y0 # Just in-case x0, x1 and x2 are identical.
+          if (x1 - x0) > 0.0
+            y2 = y0.to_f + ((y1 - y0).to_f * (x2 - x0).to_f / (x1 - x0).to_f)
+          end
+          return y2, notes
+        end
+      end
+    end
+
+    class LinearModel
+      def initialize(xs, ys)
+        @xs, @ys = xs, ys
+        if @xs.length != @ys.length
+          raise "Unbalanced data. xs need to be same length as ys"
+        end
+      end
+
+      def y_intercept
+        return mean(@ys) - (slope * mean(@xs))
+      end
+
+      def slope
+        x_mean = mean(@xs)
+        y_mean = mean(@ys)
+
+        numerator = (0...@xs.length).reduce(0) do |sum, i|
+          sum + ((@xs[i] - x_mean) * (@ys[i] - y_mean))
+        end
+
+        denominator = @xs.reduce(0) do |sum, x|
+          sum + ((x - x_mean) ** 2)
+        end
+
+        return (numerator / denominator)
+      end
+
+      def mean(values)
+        total = values.reduce(0) { |sum, x| x + sum }
+        return Float(total) / Float(values.length)
+      end
+    end
+  end
+end
+
+

data/lib/openstudio-standards/btap/paths.rb

@@ -0,0 +1,46 @@
+# BTAP Paths
+#
+# File paths related to the common folder.
+
+module BTAP
+  module Paths
+    class << self
+
+      # Costing paths are mutable in the `BTAP::Costing` constructor.
+      attr_accessor :costs_path
+      attr_accessor :costs_local_factors_path
+    end
+    btap_common               = Pathname(__dir__) / "common"
+    necb_common               = Pathname(__dir__) / "../standards/necb/common"
+    @costs_path               = btap_common / "costs.csv"
+    @costs_local_factors_path = btap_common / "costs_local_factors.csv"
+
+    COSTING_DATA_PATHS = [
+      btap_common / "locations.csv",
+      btap_common / "materials_opaque.csv",
+      btap_common / "materials_glazing.csv",
+      btap_common / "lighting_sets.csv",
+      btap_common / "lighting.csv",
+      btap_common / "materials_lighting.csv",
+      btap_common / "hvac_vent_ahu.csv",
+      btap_common / "materials_hvac.csv"
+    ]
+
+    CONSTRUCTIONS_PATH        = btap_common / "constructions.json"
+    CARBON_OPAQUE_PATH        = btap_common / "carbon_opaque.csv"
+    CARBON_GLAZING_PATH       = btap_common / "carbon_glazing.csv"
+    CARBON_FRAME_PATH         = btap_common / "carbon_frame.csv"
+    THERMAL_BRIDGING_PATH     = btap_common / "thermal_bridging.csv"
+    MECH_SIZING_PATH          = btap_common / "mech_sizing.json"
+    NECB_BUILDING_TYPES_PATH  = btap_common / "necb_building_types.csv"
+    NECB_SPACE_TYPES_PATH     = btap_common / "necb_space_types.csv"
+
+    NEB_PRICES_PATH           = necb_common / "neb_end_use_prices.csv"
+
+    # (Retrieved March 11, 2025)
+    # ECCC's emissions factors for the current and future years for GHG "without
+    # Biomass and RNG CO2 emissions":
+    # https://data-donnees.az.ec.gc.ca/data/substances/monitor/canada-s-greenhouse-gas-emissions-projections/Current-Projections-Actuelles/Energy-Energie/AM%20Scenario%20AMS/Grid-O%26G-Intensities-Intensites-Reseau-Delectricite-P%26G?lang=en
+    ECCC_GHG_ELECTRICITY_PATH = necb_common / "eccc_electric_grid_intensity_20250311.csv"
+  end
+end

data/lib/openstudio-standards/btap/qaqc/analysis.rb

@@ -0,0 +1,163 @@
+require 'openstudio'
+
+module BTAP
+
+  # BTAP Analysis
+  #
+  # Class to instantiate post-analysis mechanisms like costing or carbon
+  # calculation. Can be done during a simulation or without one given an OSM file
+  # and its SQL file, along with a few other parameters.
+  #
+  # Abstract class, only instantiate BTAP::NoSimAnalysis or BTAP::DatapointAnalysis.
+  class Analysis
+    attr_accessor :attributes
+
+    # @param output_folder [String]
+    def initialize(output_folder:)
+      @output_folder = output_folder
+    end
+
+    # Run BTAP Costing.
+    #
+    # @param costs_csv [String] Path to a custom costing CSV file if custom
+    #                           costing is desired.
+    # @param factors_csv [String] Path to a custom costing localization factors
+    #                             CSV file if custom costing is desired.
+    def run_costing(costs_csv: Paths.costs_path, factors_csv: Paths.costs_local_factors_path)
+      costing = Costing.new(costs_csv: costs_csv, factors_csv: factors_csv, attributes: @attributes)
+
+      cost_result, _ = costing.cost_audit_all(
+        model: @model,
+        prototype_creator: @standard,
+        template_type: @model.getBuilding.standardsTemplate.get)
+
+      if not @qaqc.nil?
+        @qaqc[:costing_information] = cost_result
+      end
+
+      File.open(File.join(@output_folder, 'cost_results.json'), 'w') do |f|
+        f.write(JSON.pretty_generate(cost_result, allow_nan: true))
+      end
+      puts "Wrote File cost_results.json in #{@output_folder} "
+
+      return cost_result
+    end
+
+    # Run BTAP Carbon.
+    def run_carbon
+      carbon = Carbon.new(attributes: @attributes, standards_data: @standard.standards_data)
+      carbon_result = carbon.audit_embodied_carbon
+
+      if not @qaqc.nil?
+        @qaqc[:carbon_information] = carbon_result
+      end
+
+      File.open(File.join(@output_folder, 'carbon_results.json'), 'w') do |f|
+        f.write(JSON.pretty_generate(carbon_result, allow_nan: true))
+      end
+      puts "Wrote File carbon_results.json in #{@output_folder} "
+
+      return carbon_result
+    end
+
+    # @param model [OpenStudio::Model::Model]
+    # @return [(Boolean, Hash)]
+    def self.get_tbd_attributes(model:)
+
+      # The "psi_quality" additional property is only initialized when TBD
+      # is run, used as a marker here to determine the "tbd_enabled" attribute.
+      tbd_enabled      = model.getBuilding.additionalProperties.hasFeature("psi_quality")
+      tbd_edge_tallies = {}
+
+      # Process the thermal bridging edge tallies out of the building's
+      # additional properties and format them into a hash.
+      if tbd_enabled
+        BTAP::BridgingData.admissible_edges.map(&:to_s).each do |edge_type|
+          (1..model.getDefaultConstructionSets.length).each do |id|
+            edge_key     = "PSI#{edge_type}#{id}"
+            keep_looking = false
+            if model.getBuilding.additionalProperties.hasFeature(edge_key)
+              keep_looking = true
+              tbd_edge_tallies[edge_type] = {} unless tbd_edge_tallies.has_key?(edge_type)
+              wall_reference, quantity =
+                model.getBuilding.additionalProperties.getFeatureAsString(edge_key).get.split(/\s(?=\d)/)
+
+              tbd_edge_tallies[edge_type][wall_reference] = quantity.to_f
+            end
+            break unless keep_looking
+          end
+        end
+      end
+      return tbd_enabled, tbd_edge_tallies
+    end
+  end
+
+  # BTAP No Simulation Analysis
+  #
+  # Instantiate this class and run `run_costing` and/or `run_carbon` to run one
+  # of those modules without performing a full annual simulation or building a
+  # standard. This requires a number of parameters to be passed, all of which are
+  # provided from the simulation results of a full annual simulation. This
+  # requires some parameters of the Standard class to be manually loaded
+  # Therefore, a no-simulation analysis requires a full simulation to be run to
+  # retrieve the files necessary. Those files and other parameters are listed
+  # below:
+  #
+  # @param model_path      [String] The path of the OSM file for a model.
+  # @param sql_file_path   [String] SQL file of the model required for hourly
+  #                                 data.
+  # @param output_folder   [String]
+  # @param template        [String]
+  # @param datapoint_id    [String]
+  # @param analysis_id     [String]
+  class NoSimAnalysis < Analysis
+    def initialize(
+      model_path:,
+      sql_file_path:,
+      output_folder:,
+      datapoint_id:,
+      analysis_id: SecureRandom.uuid)
+
+      super(output_folder: output_folder)
+      @model    = BTAP::FileIO.load_osm(model_path)
+      @standard = Standard.build(@model.getBuilding.standardsTemplate.get)
+      @standard.assign_building_activity(model: @model)
+      @standard.assign_building_structure(model: @model, activity: @standard.activity)
+      @datapoint_id = datapoint_id
+      @analysis_id  = analysis_id
+
+      tbd_enabled, tbd_edge_tallies = Analysis.get_tbd_attributes(model: @model)
+      @attributes = BTAP::Attributes.new(
+        model: @model,
+        standard: @standard,
+        tbd_enabled: tbd_enabled,
+        tbd_edge_tallies: tbd_edge_tallies)
+      @model.setSqlFile(OpenStudio::SqlFile.new(sql_file_path))
+      @qaqc = BTAP::Datapoint.build_qaqc(@model, @standard, @datapoint_id, @analysis_id)
+    end
+  end
+
+  # BTAP Datapoint Analysis
+  #
+  # Helper function to run post-analysis mechanisms in `btap_datapoint.rb`.
+  # @param model    [OpenStudio::Model::Model]
+  # @param standard [Standard]
+  # @param template [String]
+  # @param qaqc     [Hash] Doesn't seem to be currently relevant but still
+  #                        required.
+  class DatapointAnalysis < Analysis
+    def initialize(model:, output_folder:, standard:, qaqc:)
+      super(output_folder: output_folder)
+      @model    = model
+      @standard = standard
+      @qaqc     = qaqc
+
+      tbd_enabled, tbd_edge_tallies = Analysis.get_tbd_attributes(model: @model)
+      @attributes = BTAP::Attributes.new(
+        model: @model,
+        standard: @standard,
+        tbd_enabled: tbd_enabled,
+        tbd_edge_tallies: tbd_edge_tallies)
+    end
+  end
+end