urbanopt-reopt 0.11.0 → 1.0.0

data/lib/urbanopt/reopt/reopt_ghp_adapter.rb

@@ -0,0 +1,337 @@
+# *********************************************************************************
+# URBANopt (tm), Copyright (c) Alliance for Sustainable Energy, LLC.
+# See also https://github.com/urbanopt/urbanopt-reopt-gem/blob/develop/LICENSE.md
+# *********************************************************************************
+
+module URBANopt # :nodoc:
+  module REopt # :nodoc:
+    class REoptGHPAdapter
+
+      def initialize
+        # initialize @@logger
+        @@logger ||= URBANopt::REopt.reopt_logger
+        # Define class variable
+        @@hours_in_year = 8760
+      end
+
+      def create_reopt_input_building(run_dir, system_parameter_hash, reopt_ghp_assumptions_hash, building_id, modelica_result)
+
+        # Define variables
+        reopt_inputs_building = {}
+        if !reopt_ghp_assumptions_hash.nil?
+          reopt_inputs_building = reopt_ghp_assumptions_hash
+        else
+          @@logger.info('Using default REopt assumptions')
+          # create a dictionary for REopt Inputs
+          reopt_inputs_building = {
+            Site: {},
+            SpaceHeatingLoad: {},
+            DomesticHotWaterLoad: {},
+            ElectricLoad: {},
+            ElectricTariff: {
+              urdb_label: ""
+            },
+            GHP: {},
+            ExistingBoiler: {}
+          }
+        end
+
+        # The URDB label is required to be specified in the input assumption file
+        if reopt_inputs_building[:ElectricTariff][:urdb_label].nil? || reopt_inputs_building[:ElectricTariff][:urdb_label].empty?
+          raise "Missing value for urdb_label - this is a required input"
+        end
+
+        scenario_json_path = File.join(run_dir, "default_scenario_report.json")
+        if File.exist?(scenario_json_path)
+          File.open(scenario_json_path, 'r') do |file|
+            scenario_json_data = JSON.parse(file.read, symbolize_names: true)
+            # update site location
+            @latitude = scenario_json_data[:scenario_report][:location][:latitude_deg]
+            @longitude = scenario_json_data[:scenario_report][:location][:longitude_deg]
+            reopt_inputs_building[:Site][:latitude] = @latitude
+            reopt_inputs_building[:Site][:longitude] = @longitude
+
+          end
+        end
+
+        reopt_inputs_building[:SpaceHeatingLoad][:fuel_loads_mmbtu_per_hour] = []
+        # Read the default csv report
+        default_feature_report_path = File.join(run_dir, building_id.to_s, "feature_reports", "default_feature_report.csv")
+        if File.exist?(default_feature_report_path)
+          timeseries_data = CSV.read(default_feature_report_path, headers: true)
+
+          # Initialize the total kBtu sum
+          total_kbtu = 0.0
+
+          # Convert each value in "Heating:NaturalGas(kBtu)" to MMBtu and store in the array
+          timeseries_data.each do |row|
+            if row['Heating:NaturalGas(kBtu)'] # Ensure the value exists
+              kBtu_value = row['Heating:NaturalGas(kBtu)'].to_f # Convert to float
+              total_kbtu += kBtu_value # Sum kBtu values
+            end
+          end
+            # Check if the total kBtu is zero
+          if total_kbtu.zero?
+            # If zero, populate with hourly values meet reopts formatting requirements
+            reopt_inputs_building[:SpaceHeatingLoad][:fuel_loads_mmbtu_per_hour] = [0.000001] * @@hours_in_year
+          else
+            # If not zero, convert and append to the array
+            timeseries_data.each do |row|
+              if row['Heating:NaturalGas(kBtu)'] # Ensure the value exists
+                kBtu_value = row['Heating:NaturalGas(kBtu)'].to_f # Convert to float
+                mMBtu_value = kBtu_value / 1000 # Convert kBtu to MMBtu
+                reopt_inputs_building[:SpaceHeatingLoad][:fuel_loads_mmbtu_per_hour] << mMBtu_value # Append to the array
+              end
+            end
+          end
+
+        else
+          # Calculate space heating load
+          reopt_inputs_building[:SpaceHeatingLoad][:fuel_loads_mmbtu_per_hour] = [0.000001] * @@hours_in_year
+          puts "Existing heating fuel cost was not taken into consideration in result calculations."
+        end
+
+
+        # read_modelica_result
+        modelica_project = File.expand_path(modelica_result)
+        project_name = File.basename(modelica_project)
+        @modelica_csv = File.join(
+          modelica_project,
+          "#{project_name}.Districts.DistrictEnergySystem_results",
+          "#{project_name}.Districts.DistrictEnergySystem_result.csv"
+        )
+
+        if File.exist?(@modelica_csv)
+          modelica_data = CSV.read(@modelica_csv, headers: true)
+          heating_power = "heating_electric_power_#{building_id}"
+          cooling_power = "cooling_electric_power_#{building_id}"
+          pump_power = "pump_power_#{building_id}"
+          ets_pump_power = "ets_pump_power_#{building_id}"
+          heating_system_capacity = "heating_system_capacity_#{building_id}"
+          cooling_system_capacity = "cooling_system_capacity_#{building_id}"
+
+          heating_power_values = cooling_power_values = pump_power_values = ets_pump_power_values = []
+          total_electric_load_building = []
+          # Ensure the column exists
+          if modelica_data.headers.include?(heating_power)
+            heating_power_values = modelica_data[heating_power]
+          end
+          if modelica_data.headers.include?(cooling_power)
+            cooling_power_values = modelica_data[cooling_power]
+          end
+          if modelica_data.headers.include?(pump_power)
+            pump_power_values = modelica_data[pump_power]
+          end
+          if modelica_data.headers.include?(ets_pump_power)
+            ets_pump_power_values = modelica_data[ets_pump_power]
+          end
+
+          total_electric_load_building = heating_power_values.zip(cooling_power_values, pump_power_values, ets_pump_power_values).map do |elements|
+            # Convert watts to kilowatts
+            elements.map { |e| e.to_f / 1000 }.sum
+          end
+
+          peak_combined_heatpump_thermal_ton = 0
+
+          if modelica_data.headers.include?(heating_system_capacity)
+            heating_system_capacity_value = modelica_data[heating_system_capacity][0]
+          end
+          if modelica_data.headers.include?(cooling_system_capacity)
+            cooling_system_capacity_value = modelica_data[cooling_system_capacity][0]
+          end
+
+          watts_per_ton_cooling_capacity = 3517
+          peak_combined_heatpump_thermal_ton = ([heating_system_capacity_value.to_f.abs, cooling_system_capacity_value.to_f.abs].max) / watts_per_ton_cooling_capacity
+
+          # Store the result in reopt_inputs_building ElectricLoad
+          reopt_inputs_building[:ElectricLoad][:loads_kw] = total_electric_load_building
+
+
+          domestic_hot_water = total_electric_load_building.map do |load|
+            load * 0
+          end
+
+          # This is not used in REopt calculation but required for formatting.
+          reopt_inputs_building[:DomesticHotWaterLoad][:fuel_loads_mmbtu_per_hour] = domestic_hot_water
+
+          # Add GHP Fields
+          reopt_inputs_building[:GHP] = {}
+          # REopt default
+          reopt_inputs_building[:GHP][:require_ghp_purchase] = 1
+          reopt_inputs_building[:GHP][:om_cost_per_sqft_year] = 0
+          reopt_inputs_building[:GHP][:heatpump_capacity_sizing_factor_on_peak_load] = 1.0
+          # Add the floor area
+          building_json_path = File.join(run_dir, building_id.to_s, "feature_reports", "default_feature_report.json")
+          if File.exist?(building_json_path)
+            File.open(building_json_path, 'r') do |file|
+              building_json_data = JSON.parse(file.read, symbolize_names: true)
+              reopt_inputs_building[:GHP][:building_sqft] = building_json_data[:program][:floor_area_sqft]
+            end
+          else
+            puts "File not found: #{building_json_path}"
+          end
+
+          # Add existing boiler fuel cost
+          # TODO : Add this as optional user input
+          nat_gas_dollars_per_mmbtu = 13.5
+          reopt_inputs_building[:ExistingBoiler][:fuel_cost_per_mmbtu] = nat_gas_dollars_per_mmbtu
+
+          # Add ghpghx_responses
+          ghpghx_output = {}
+          ghpghx_output[:outputs] = {}
+          ghpghx_output[:inputs] = {}
+          ghpghx_output[:outputs][:heat_pump_configuration] = "WSHP"
+          # This is not used in REopt calculation but required for formatting.
+          ghpghx_output[:outputs][:yearly_ghx_pump_electric_consumption_series_kw] = [0] * @@hours_in_year
+          ghpghx_output[:outputs][:number_of_boreholes] = 0
+          ghpghx_output[:outputs][:length_boreholes_ft] = 0
+
+          ghpghx_output[:outputs][:peak_combined_heatpump_thermal_ton] = peak_combined_heatpump_thermal_ton
+          ghpghx_output[:outputs][:yearly_total_electric_consumption_kwh] = total_electric_load_building.sum
+          ghpghx_output[:outputs][:yearly_total_electric_consumption_series_kw] = total_electric_load_building
+          ghpghx_output[:outputs][:yearly_heating_heatpump_electric_consumption_series_kw] = total_electric_load_building
+          ghpghx_output[:outputs][:yearly_cooling_heatpump_electric_consumption_series_kw] = [0] * @@hours_in_year
+          # This is not used in REopt calculation but required for formatting.
+          ghpghx_output[:inputs][:heating_thermal_load_mmbtu_per_hr] = [0.0001] * @@hours_in_year
+          # This is not used in REopt calculation but required for formatting.
+          ghpghx_output[:inputs][:cooling_thermal_load_ton] = [0] * @@hours_in_year
+
+          ghpghx_output_all = [ghpghx_output]
+          reopt_inputs_building[:GHP][:ghpghx_responses] = {}
+          reopt_inputs_building[:GHP][:ghpghx_responses] = ghpghx_output_all
+
+        end
+
+        #save output report in reopt_ghp directory
+        reopt_ghp_dir = File.join(run_dir, "reopt_ghp", "reopt_ghp_inputs")
+        json_file_path = File.join(reopt_ghp_dir, "GHP_building_#{building_id}.json")
+        pretty_json = JSON.pretty_generate(reopt_inputs_building)
+        File.write(json_file_path, pretty_json)
+
+      end
+
+      def create_reopt_input_district(run_dir, system_parameter_hash, reopt_ghp_assumptions_hash, ghp_id, modelica_result)
+
+        reopt_inputs_district = {}
+
+        if !reopt_ghp_assumptions_hash.nil?
+          reopt_inputs_district = reopt_ghp_assumptions_hash
+        else
+          @@logger.info('Using default REopt assumptions')
+          # create a dictionary for REopt Inputs
+          reopt_inputs_district = {
+            Site: {},
+            SpaceHeatingLoad: {},
+            DomesticHotWaterLoad: {},
+            ElectricLoad: {},
+            ElectricTariff: {
+              "urdb_label": ""
+            },
+            GHP: {},
+            ExistingBoiler: {}
+          }
+        end
+
+        reopt_inputs_district[:Site] = {}
+        reopt_inputs_district[:Site][:latitude] = @latitude
+        reopt_inputs_district[:Site][:longitude] = @longitude
+        # The URDB label is required to be specified in the input assumption file
+        if reopt_inputs_district[:ElectricTariff][:urdb_label].nil? || reopt_inputs_district[:ElectricTariff][:urdb_label].empty?
+
+          raise "Missing value for urdb_label - this is a required input"
+
+        end
+
+        # This is not used in REopt calculation but required for formatting.
+        reopt_inputs_district[:SpaceHeatingLoad][:fuel_loads_mmbtu_per_hour] = [0.000001]*@@hours_in_year
+        # This is not used in REopt calculation but required for formatting.
+        reopt_inputs_district[:DomesticHotWaterLoad][:fuel_loads_mmbtu_per_hour] = [0.0000001]*@@hours_in_year
+
+        # Adding year for ElectricLoad so district electric load can be calculated with REopt API v3.11
+        reopt_inputs_district[:ElectricLoad] = {:year => 2017}
+        #required for reopt formatting
+        reopt_inputs_district[:ElectricLoad][:loads_kw] = [0.00001]*@@hours_in_year
+
+        reopt_inputs_district[:ExistingBoiler] = {}
+        reopt_inputs_district[:ExistingBoiler][:fuel_cost_per_mmbtu] = 13.5
+
+        # GHP inputs
+        reopt_inputs_district[:GHP] = {}
+        reopt_inputs_district[:GHP][:require_ghp_purchase] = 1
+        reopt_inputs_district[:GHP][:building_sqft] = 0.00001
+        reopt_inputs_district[:GHP][:om_cost_per_sqft_year] = 0
+        reopt_inputs_district[:GHP][:heatpump_capacity_sizing_factor_on_peak_load] = 1.0
+
+        # Add ghpghx outputs
+        ghpghx_output = {}
+        ghpghx_output[:outputs] = {}
+        ghpghx_output[:inputs] = {}
+
+        ghpghx_output[:inputs][:heating_thermal_load_mmbtu_per_hr] = [0]*@@hours_in_year
+        ghpghx_output[:inputs][:cooling_thermal_load_ton] = [0] * @@hours_in_year
+
+
+        # Read GHX sizes from system parameter hash
+        ghe_specific_params = system_parameter_hash[:district_system][:fifth_generation][:ghe_parameters][:ghe_specific_params]
+        ghe_specific_params.each do |ghe_specific_param|
+          if ghe_specific_param[:ghe_id] = ghp_id
+            number_of_boreholes = ghe_specific_param[:borehole][:number_of_boreholes]
+            length_of_boreholes = ghe_specific_param[:borehole][:length_of_boreholes]
+            ghpghx_output[:outputs][:number_of_boreholes] = number_of_boreholes
+            # convert meters to feet
+            ghpghx_output[:outputs][:length_boreholes_ft] = (length_of_boreholes)*3.28084
+          end
+        end
+
+        if File.exist?(@modelica_csv)
+
+          modelica_data = CSV.read(@modelica_csv, headers: true)
+
+          electrical_power_consumed = modelica_data["electrical_power_consumed"]
+          # Convert watts to kilowatts
+          electrical_power_consumed_kw = electrical_power_consumed.map { |e| e.to_f / 1000 }
+          # if ghp_id.include?('-')
+          #   # Note: For some reason when reading columns, '-' from the column headers are removed, whereas ghp_id has -
+          #   ghp_id_formatted = ghp_id.delete('-')
+          #   ghp_column = "electrical_power_consumed_#{ghp_id_formatted}".to_sym
+
+          # else
+          #   # Note: For some reason when reading columns, '-' from the column headers are removed, whereas ghp_id has -
+          #   ghp_column = "electrical_power_consumed_#{ghp_id}".to_sym
+          # end
+
+          # # Ensure the column exists
+          # unless modelica_data.headers.include?(ghp_column)
+          #   puts "Column #{ghp_column} does not exist in the CSV file."
+          # end
+
+          # # Access values from the column
+          # column_values = modelica_data.by_col[ghp_column]
+
+          ghpghx_output[:outputs][:yearly_ghx_pump_electric_consumption_series_kw] = electrical_power_consumed_kw
+        else
+          ghpghx_output[:outputs][:yearly_ghx_pump_electric_consumption_series_kw] = [0.000000001]*@@hours_in_year
+        end
+
+        # This is not used in REopt calculation but required for formatting.
+        ghpghx_output[:outputs][:peak_combined_heatpump_thermal_ton] = 0.000000001
+
+        ghpghx_output[:outputs][:heat_pump_configuration] = "WSHP"
+        # Required for REpot formatting
+        ghpghx_output[:outputs][:yearly_total_electric_consumption_series_kw] = [0.00001] * @@hours_in_year
+        ghpghx_output[:outputs][:yearly_heating_heatpump_electric_consumption_series_kw] = [0] * @@hours_in_year
+        ghpghx_output[:outputs][:yearly_cooling_heatpump_electric_consumption_series_kw] = [0] * @@hours_in_year
+
+        ghpghx_output_all = [ghpghx_output, ghpghx_output]
+        reopt_inputs_district[:GHP][:ghpghx_responses] = ghpghx_output_all
+
+        #save output report in reopt_ghp directory
+        reopt_ghp_dir = File.join(run_dir, "reopt_ghp", "reopt_ghp_inputs")
+        json_file_path = File.join(reopt_ghp_dir, "GHX_#{ghp_id}.json")
+        pretty_json = JSON.pretty_generate(reopt_inputs_district)
+        File.write(json_file_path, pretty_json)
+      end
+
+    end
+  end
+end

data/lib/urbanopt/reopt/reopt_ghp_api.rb

@@ -0,0 +1,156 @@
+# *********************************************************************************
+# URBANopt (tm), Copyright (c) Alliance for Sustainable Energy, LLC.
+# See also https://github.com/urbanopt/urbanopt-reopt-gem/blob/develop/LICENSE.md
+# *********************************************************************************
+
+require 'net/https'
+require 'openssl'
+require 'uri'
+require 'json'
+require 'securerandom'
+require_relative '../../../developer_nrel_key'
+require 'urbanopt/reopt/reopt_logger'
+
+module URBANopt # :nodoc:
+  module REopt  # :nodoc:
+    class REoptLiteGHPAPI
+
+        def initialize(reopt_input_file, nrel_developer_key = nil, reopt_output_file, use_localhost)
+
+            # Store developer key
+            if [nil, '', '<insert your key here>'].include? nrel_developer_key
+                if [nil, '', '<insert your key here>'].include? DEVELOPER_NREL_KEY
+                    raise 'A developer.nrel.gov API key is required. Please see https://developer.nrel.gov/signup/ then update the file urbanopt-reopt-gem/developer_nrel_key.rb'
+                else
+                    #Store the NREL developer key
+                    nrel_developer_key = DEVELOPER_NREL_KEY
+                end
+            end
+
+            @use_localhost = use_localhost
+            if @use_localhost
+                @root_url = "http://localhost:8000/v3"
+            else
+                @root_url = "https://developer.nrel.gov/api/reopt/v3"
+            end
+            # add REopt URL
+            @nrel_developer_key = nrel_developer_key
+            @reopt_input_file = reopt_input_file
+            @reopt_output_file = reopt_output_file
+            # initialize @@logger
+            @@logger ||= URBANopt::REopt.reopt_logger
+            @@logger.level = Logger::INFO
+        end
+
+
+        def get_api_results(run_id=nil)
+
+            reopt_input_file = @reopt_input_file
+            nrel_developer_key = @nrel_developer_key
+            root_url = @root_url
+            reopt_output_file = @reopt_output_file
+
+            if run_id.nil?
+                run_id = get_run_uuid(reopt_input_file, nrel_developer_key, reopt_output_file)
+            end
+            if !run_id.nil?
+                results_url = "#{@root_url}/job/#{run_id}/results/?api_key=#{nrel_developer_key}"
+                puts "This is results URL #{results_url}"
+                results = reopt_request(results_url)
+
+                File.open(reopt_output_file, 'w') do |f|
+                    f.write(JSON.pretty_generate(results))
+                    @@logger.info("Saved results to #{reopt_output_file}")
+                end
+            else
+                results = nil
+                @@logger.error("Unable to get results: no UUID returned.")
+            end
+            results
+        end
+
+        def get_run_uuid(reopt_input_file, nrel_developer_key, root_url)
+
+            reopt_input_file = @reopt_input_file
+            nrel_developer_key = @nrel_developer_key
+            root_url = @root_url
+            post_url = "#{root_url}/job/?api_key=#{nrel_developer_key}"
+            puts "This is URL: #{post_url}"
+            @@logger.info("Connecting to #{post_url}")
+
+            # Parse the URL and prepare the HTTP request
+            uri = URI.parse(post_url)
+            request = Net::HTTP::Post.new(uri)
+            request.content_type = 'application/json'
+
+            # Add the JSON payload (assuming 'post' is the body data)
+            request.body = reopt_input_file.to_json
+
+            # Send the HTTP request
+            response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
+                http.request(request)
+            end
+
+            run_id = nil
+
+            if !response.is_a?(Net::HTTPSuccess)
+                @@logger.error("Status code #{response.code}. #{response.body}")
+                @@logger.error("Status code #{response.code}")
+            else
+                @@logger.info("Response OK from #{post_url}.")
+                run_id_dict = JSON.parse(response.body)
+
+                begin
+                    run_id = run_id_dict['run_uuid']
+                rescue KeyError
+                    msg = "Response from #{post_url} did not contain run_uuid."
+                    @@logger.error(msg)
+                end
+            end
+            # Return run_id
+            run_id
+        end
+
+        def reopt_request(results_url, poll_interval = 5, max_timeout = 300)
+
+            key_error_count = 0
+            key_error_threshold = 3
+            status = "Optimizing..."
+            @@logger.info("Polling #{results_url} for results with interval of #{poll_interval}...")
+            resp_dict = {}
+            start_time = Time.now
+
+            loop do
+                uri = URI.parse(results_url)
+                response = Net::HTTP.get_response(uri)
+                resp_dict = JSON.parse(response.body)
+
+                begin
+                  status = resp_dict['status']
+                rescue KeyError
+                  key_error_count += 1
+                  @@logger.info("KeyError count: #{key_error_count}")
+                  if key_error_count > key_error_threshold
+                    @@logger.info("Breaking polling loop due to KeyError count threshold of #{key_error_threshold} exceeded.")
+                    break
+                  end
+                end
+
+                if status != "Optimizing..."
+                    break
+                end
+
+                if Time.now - start_time > max_timeout
+                    @@logger.info("Breaking polling loop due to max timeout of #{max_timeout} seconds exceeded.")
+                    break
+                end
+
+                sleep(poll_interval)
+
+            end
+            resp_dict
+        end
+
+    end
+  end
+end

data/lib/urbanopt/reopt/reopt_ghp_files/reopt_ghp_assumption.json

@@ -0,0 +1,27 @@
+{
+    "Site": {
+        "latitude": 42.81428490645775,
+        "longitude": -78.84701778930912
+    },
+    "SpaceHeatingLoad": {
+    },
+    "DomesticHotWaterLoad": {
+    },
+    "ElectricLoad": {
+        "year": 2017
+    },
+    "ElectricTariff": {
+        "urdb_label": "594976725457a37b1175d089"
+    },
+    "GHP":{
+        "installed_cost_heatpump_per_ton": 1075,
+        "installed_cost_ghx_per_ft": 14,
+        "installed_cost_building_hydronic_loop_per_sqft": 1.7,
+        "om_cost_per_sqft_year": 0,
+        "macrs_bonus_fraction": 0.6,
+        "macrs_itc_reduction": 0.5,
+        "federal_itc_fraction": 0.3
+    },
+    "ExistingBoiler": {
+    }
+}

data/lib/urbanopt/reopt/reopt_ghp_post_processor.rb

@@ -0,0 +1,149 @@
+# *********************************************************************************
+# URBANopt (tm), Copyright (c) Alliance for Sustainable Energy, LLC.
+# See also https://github.com/urbanopt/urbanopt-reopt-gem/blob/develop/LICENSE.md
+# *********************************************************************************
+
+require 'bundler/setup'
+require 'urbanopt/reopt/reopt_logger'
+require 'urbanopt/reopt/reopt_ghp_api'
+require 'csv'
+require 'json'
+require 'fileutils'
+
+module URBANopt # :nodoc:
+  module REopt # :nodoc:
+    class REoptGHPPostProcessor
+      def initialize(run_dir, system_parameter, modelica_result, reopt_ghp_assumptions = nil, nrel_developer_key = nil, localhost)
+        # initialize @@logger
+        @@logger ||= URBANopt::REopt.reopt_logger
+
+        @nrel_developer_key = nrel_developer_key
+        @localhost = localhost
+        @reopt_ghp_output_district = nil
+        @reopt_ghp_output_building = []
+        @reopt_ghp_assumptions_hash = nil
+        @reopt_ghp_assumptions = nil
+        @system_parameter = nil
+        @system_parameter_hash = nil
+        @modelica_result = nil
+        @building_ids = nil
+        @run_dir = run_dir
+
+        if !reopt_ghp_assumptions.nil?
+          @reopt_ghp_assumptions = reopt_ghp_assumptions
+          File.open(reopt_ghp_assumptions, 'r') do |file|
+            @reopt_ghp_assumptions_input_hash = JSON.parse(file.read, symbolize_names: true)
+          end
+        end
+
+        if !system_parameter.nil?
+          @system_parameter = system_parameter
+          File.open(system_parameter, 'r') do |file|
+            @system_parameter_input_hash = JSON.parse(file.read, symbolize_names: true)
+          end
+          # Determine loop order
+          loop_order = File.join(File.dirname(system_parameter), '_loop_order.json')
+          if File.exist?(loop_order)
+            File.open(loop_order, 'r') do |file|
+              loop_order_input = JSON.parse(file.read, symbolize_names: true)
+              # Check the type of the parsed data
+              if loop_order_input.is_a?(Array)
+                @loop_order_input_hash = loop_order_input
+                @loop_order_input_hash.each do |item|
+                  puts "Building IDs in group: #{item[:list_bldg_ids_in_group].inspect}"
+                  puts "GHE IDs in group: #{item[:list_ghe_ids_in_group].inspect}"
+                end
+              elsif loop_order_input.is_a?(Hash)
+                @loop_order_input_hash = [loop_order_input] # Wrap in array if a single object
+                @loop_order_input_hash.each do |item|
+                  puts "Building IDs in group: #{item[:list_bldg_ids_in_group].inspect}"
+                  puts "GHE IDs in group: #{item[:list_ghe_ids_in_group].inspect}"
+                end
+              else
+                puts 'Unexpected JSON structure'
+              end
+            end
+          end
+
+        end
+
+        if !modelica_result.nil?
+          @modelica_result_input = modelica_result
+        end
+      end
+
+      attr_accessor :run_dir, :system_parameter_input_hash, :reopt_ghp_assumptions_input_hash, :loop_order_input_hash, :modelica_result_input
+
+      # # Create REopt input and output building report
+      def run_reopt_lcca(system_parameter_hash: nil, reopt_ghp_assumptions_hash: nil, modelica_result: nil)
+        adapter = URBANopt::REopt::REoptGHPAdapter.new
+
+        # if these arguments are specified, use them
+        if !system_parameter_hash.nil?
+          @system_parameter_input_hash = system_parameter_hash
+        end
+
+        if !reopt_ghp_assumptions_hash.nil?
+          @reopt_ghp_assumptions_input_hash = reopt_ghp_assumptions_hash
+        end
+
+        if !modelica_result.nil?
+          @modelica_result_input = modelica_result
+        end
+
+        # Create folder for REopt input files only if they dont exist
+        reopt_ghp_dir = File.join(@run_dir, 'reopt_ghp')
+        reopt_ghp_input = File.join(reopt_ghp_dir, 'reopt_ghp_inputs')
+        unless Dir.exist?(reopt_ghp_dir)
+          FileUtils.mkdir_p(reopt_ghp_dir)
+        end
+        unless Dir.exist?(reopt_ghp_input)
+          FileUtils.mkdir_p(reopt_ghp_input)
+        end
+
+        reopt_ghp_output = File.join(reopt_ghp_dir, 'reopt_ghp_outputs')
+        unless Dir.exist?(reopt_ghp_output)
+          FileUtils.mkdir_p(reopt_ghp_output)
+        end
+
+        # get building IDs from _loop_order.json
+        building_ids = []
+        ghp_ids = []
+        @loop_order_input_hash.each do |loop|
+          building_ids.concat(loop[:list_bldg_ids_in_group].flatten)
+          ghp_ids.concat(loop[:list_ghe_ids_in_group].flatten)
+        end
+
+        building_ids.each do |building_id|
+          # create REopt building input file for all buildings in loop order list
+          reopt_input_building = adapter.create_reopt_input_building(@run_dir, @system_parameter_input_hash, @reopt_ghp_assumptions_input_hash, building_id, @modelica_result_input)
+        end
+        ghp_ids.each do |ghp_id|
+          # create REopt district input file
+          reopt_input_district = adapter.create_reopt_input_district(@run_dir, @system_parameter_input_hash, @reopt_ghp_assumptions_input_hash, ghp_id, @modelica_result_input)
+        end
+
+        Dir.foreach(reopt_ghp_input) do |input_file|
+          # Skip '.' and '..' (current and parent directory entries)
+          next if input_file == '.' || input_file == '..'
+
+          reopt_ghp_input_file_path = File.join(reopt_ghp_input, input_file)
+
+          reopt_input_data = nil
+
+          File.open(reopt_ghp_input_file_path, 'r') do |f|
+            reopt_input_data = JSON.parse(f.read)
+          end
+
+          base_name = File.basename(input_file, '.json')
+
+          # reopt_ghp_output_file
+          reopt_output_file = File.join(reopt_ghp_output, "#{base_name}_output.json")
+          # call the REopt API
+          api = URBANopt::REopt::REoptLiteGHPAPI.new(reopt_input_data, DEVELOPER_NREL_KEY, reopt_output_file, @localhost)
+          api.get_api_results
+        end
+      end
+    end # REoptGHPPostProcessor
+  end # REopt
+end # URBANopt