openstudio-standards 0.7.1 → 0.8.0.rc1

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

@@ -22,16 +22,17 @@
 require 'fileutils'
 require 'csv'
 require 'securerandom'
+require 'digest'
 
 
 module BTAP
   module FileIO
 
-    #Test Constructions Module
+  #Test Constructions Module
     if __FILE__ == $0
       require 'test/unit'
-      class FileIOTests < Test::Unit::TestCase
-
+      class FileIOTests < Test::Unit::TestCase 
+ 
         def setup
         end
 
@@ -1191,10 +1192,175 @@ module BTAP
       return new_model
     end
 
-  end #FileIO
 
+    def self.clean_osm_file( file_path: , 
+                        output_path:  )
+
+      def self.read_osm_file(file_path)
+        data = []
+        current_hash = {}
+      
+        File.foreach(file_path) do |line|
+          line.strip!
+          next if line.empty?
+      
+          if line.start_with?('OS:')
+            current_hash = { type: line.split(/[;,]/).first }
+            data << current_hash
+          elsif line.include?('!-')
+            key, value = line.split('!-').map(&:strip)
+            current_hash[value] = key.chomp(',;').strip
+          else
+            current_hash[:id] ||= line.chomp(',;').strip
+          end
+        end
+      
+        data
+      end
+      
+      def self.remove_special_characters(hash)
+        hash.keys.each do |key|
+            new_key = key.to_s.sub(/[;,]$/, '')
+          hash[new_key] = hash.delete(key)
+        end
+      
+        hash.each do |key, value|
+          next unless value.is_a?(String)
+        
+          hash[key] = value.gsub(/[;,]$/, '')
+        end
+      end
+      
+      def self.rename_handles(osm_data)
+
+        hash = Digest::SHA1.hexdigest("fixed_seed")
+        handle_map = {}
+        new_handle_index = 0
+        object_type_index = 0
+        last_object_type = nil
+      
+        osm_data.each do |hash|
+          if hash['Handle']
+            #puts hash
+            #puts "#{hash['type']} == #{last_object_type}"
+            if hash['type'] != last_object_type
+              last_object_type = hash['type']
+              object_type_index += 1
+              new_handle_index = 1
+            else
+              new_handle_index += 1
+            end
+
+            # create a formatted string that is 12 charecters created with new_handle_index, but padded with 0s on the left.
+            formatted_index = new_handle_index.to_s.rjust(12, '0')
+            formatted_index_object_type = object_type_index.to_s.rjust(4, '0')
+            new_handle = "{00000000-0000-0000-#{formatted_index_object_type}-#{formatted_index}}"
+            handle_map[hash['Handle']] = new_handle
+            hash['Handle'] = new_handle
+          end
+        end
+      
+        osm_data.each do |hash|
+          hash.each do |key, value|
+            if handle_map.key?(value)
+              hash[key] = handle_map[value]
+            end
+          end
+        end
+        
+       # Go through all hashes in osm_data and if the "Name" field value fits this pattern {9386c18d-e70a-447e-8b69-9a0a39fd8f06} replace it with an incremented value.
+      name_map = {}
+      new_name_index = 0
+      osm_data.each do |hash|
+        if hash['Name'] && hash['Name'].match?(/\{[a-fA-F0-9\-]{36}\}/)
+          new_name_index += 1
+          formatted_new_name_index = new_name_index.to_s.rjust(4, '0')
+          new_name = "{00000000-0000-#{formatted_new_name_index}-0000-000000000000}"
+          name_map[hash['Name']] = new_name
+          hash['Name'] = new_name
+        end
+      end
+
+      osm_data.each do |hash|
+        hash.each do |key, value|
+          if name_map.key?(value)
+            hash[key] = name_map[value]
+          end
+        end
+      end
+
+
+      end
+      
+
+
+
+      def self.save_osm_file(osm_data, output_path)
+        File.open(output_path, 'w') do |file|
+          osm_data.each do |hash|
+            file.puts "#{hash["type"]},"
+            hash.each do |key, value|
+              next if key == "type"
+              is_last_key = (hash.keys - [:type]).last == key
+              if key == :id
+                file.puts "  #{value},"
+              else
+                file.puts "  #{value}#{is_last_key ? ';' : ','}".ljust(42) + " !- #{key}"
+              end
+            end
+            file.puts
+          end
+        end
+      end
+
+      def self.set_all_data_time(osm_data)
+        osm_data.each do |hash|
+          hash.each do |key, value|
+            #Check if value is in a date-time format like this "2024-10-17 01:19:35 UTC"
+            if value.match?(/\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} UTC/)
+              hash[key] = "2024-01-01 01:00:00 UTC"
+            end
+          end
+        end
+      end
+
+      def self.set_all_epw_paths(osm_data)
+        osm_data.each do |hash|
+          hash.each do |key, value|
+            #Check if value is in a epw file path format like this "USA_CA_San.Francisco.Intl.AP.724940_TMY3.epw"
+            if value.match?(/.*\.epw/)
+              # Get name of file without path from value
+              hash[key] = File.basename(value)
+            end
+          end
+        end
+      end
 
+              
+      osm_data = read_osm_file(file_path)
+      osm_data.sort_by! { |hash| [hash[:type], hash['Name'] || ''] }
 
+      handles = osm_data.map { |hash| hash['Handle'] }.compact
+      duplicates = handles.select { |e| handles.count(e) > 1 }
+      raise "Duplicate handles found: #{duplicates.uniq}" if duplicates.any?
 
+      osm_data.each { |hash| remove_special_characters(hash) }
+      set_all_data_time(osm_data)
+      set_all_epw_paths(osm_data)
+      rename_handles(osm_data)
+      save_osm_file(osm_data, output_path)
+    end
 
-end #BTAP
+    def self.get_relative_path(abs_path_to_file, working_folder)
+      path = Pathname.new(abs_path_to_file).relative_path_from(Pathname.new(working_folder)).to_s
+      file = File.basename(abs_path_to_file)
+      rel_path= File.join(path)
+      # Check if file exists
+      if File.file?(File.join(working_folder, rel_path))
+        return rel_path
+      else
+        raise "File does not exist at #{File.join(working_folder, rel_path)}"
+      end
+    end
+  end #FileIO
+end #BTAP

data/lib/openstudio-standards/constructions/create.rb

@@ -5,15 +5,49 @@ module OpenstudioStandards
     # Methods to create Constructions
 
     # This will create a deep copy of the construction, meaning it will clone and create new material objects as well
+    # This function will clone
     #
     # @param construction [OpenStudio::Model::Construction] OpenStudio Construction object object
     # @return [OpenStudio::Model::Construction] New OpenStudio Construction object
     def self.construction_deep_copy(construction)
-      new_construction = construction.clone.to_Construction.get
-      (0..new_construction.layers.length - 1).each do |layer_number|
-        cloned_layer = new_construction.getLayer(layer_number).clone.to_Material.get
-        new_construction.setLayer(layer_number, cloned_layer)
+      cons_obj_type = construction.iddObjectType.valueName.to_s
+      case cons_obj_type
+      when 'OS_Construction_FfactorGroundFloor'
+        new_construction = construction.clone.to_FFactorGroundFloorConstruction.get
+        f_const = construction.to_FFactorGroundFloorConstruction.get
+        new_construction.setFFactor(f_const.fFactor)
+        new_construction.setArea(f_const.area)
+        new_construction.setPerimeterExposed(f_const.perimeterExposed)
+      when 'OS_Construction_CfactorUndergroundWall'
+        c_const = construction.to_CFactorUndergroundWallConstruction.get
+        new_construction = c_const.clone.to_CFactorUndergroundWallConstruction.get
+        new_construction.setCFactor(c_const.cFactor)
+        new_construction.setHeight(c_const.height)
+      when 'OS_Construction_AirBoundary'
+        a_const = construction.to_ConstructionAirBoundary.get
+        new_construction = a_const.clone.to_ConstructionAirBoundary.get
+        new_construction.setAirExchangeMethod(a_const.airExchangeMethod)
+        new_construction.setSimpleMixingAirChangesPerHour(a_const.simpleMixingAirChangesPerHour)
+        new_construction.setSimpleMixingSchedule(a_const.simpleMixingSchedule)
+      else
+        # Layer by layer construction
+        if cons_obj_type == 'OS_Construction_InternalSource'
+          new_construction = construction.clone.to_ConstructionWithInternalSource.get
+          i_const = construction.to_ConstructionWithInternalSource.get
+          new_construction.setSourcePresentAfterLayerNumber(i_const.sourcePresentAfterLayerNumber)
+          new_construction.setTemperatureCalculationRequestedAfterLayerNumber(i_const.temperatureCalculationRequestedAfterLayerNumber)
+          new_construction.setDimensionsForTheCTFCalculation(i_const.dimensionsForTheCTFCalculation)
+          new_construction.setTubeSpacing(i_const.tubeSpacing)
+          new_construction.setTwoDimensionalTemperatureCalculationPosition(i_const.twoDimensionalTemperatureCalculationPosition)
+        else
+          new_construction = construction.clone.to_Construction.get
+        end
+        (0..new_construction.layers.length - 1).each do |layer_number|
+          cloned_layer = new_construction.getLayer(layer_number).clone.to_Material.get
+          new_construction.setLayer(layer_number, cloned_layer)
+        end
       end
+
       return new_construction
     end
 

data/lib/openstudio-standards/constructions/modify.rb

@@ -336,11 +336,18 @@ module OpenstudioStandards
         return false
       end
 
-      # Change construction name
-      construction.setName("#{construction.name}_#{surface.name}_#{target_f_factor_ip}")
-
       # Set properties
       f_factor_si = target_f_factor_ip * OpenStudio.convert(1.0, 'Btu/ft*h*R', 'W/m*K').get
+
+      # Exception alert on tiny piece of outdoor ground floors in a space
+      # data is taken out from Eplus - Area / Perimeter > (R_concrete + R_film_in + R_film_out) * Ffactor
+      # where R_concrete = 0.15 / 1.95, R_film_in = 0.135, R_film_out = 0.03
+      unless area / perimeter >= ((0.15 / 1.95) + 0.135 + 0.03) * f_factor_si
+        OpenStudio.logFree(OpenStudio::Warn, 'OpenstudioStandards::Construction', 'The calculated area to exposed perimeter ratio is smaller than the threshold set in EnergyPlus.')
+        return false
+      end
+      # Change construction name
+      construction.setName("#{construction.name}_#{surface.name}_#{target_f_factor_ip}")
       construction.setFFactor(f_factor_si)
       construction.setArea(area)
       construction.setPerimeterExposed(perimeter)

data/lib/openstudio-standards/create_typical/create_typical.rb

@@ -20,7 +20,7 @@ module OpenstudioStandards
     # @param cooling_fuel [String] The primary HVAC cooling fuel type
     #   Options are 'Electricity', 'DistrictCooling', 'DistrictAmbient'
     # @param kitchen_makeup [String] Source of makeup air for kitchen exhaust
-    #   Options are 'None', 'Largest Zone', 'Adjacent'
+    #   Options are 'None', 'Adjacent'
     # @param exterior_lighting_zone [String] The exterior lighting zone for exterior lighting allowance.
     #   Options are '0 - Undeveloped Areas Parks', '1 - Developed Areas Parks', '2 - Neighborhood', '3 - All Other Areas', '4 - High Activity'
     # @param add_constructions [Boolean] Create and apply default construction set
@@ -28,6 +28,7 @@ module OpenstudioStandards
     #  Options are 'Inferred', 'Mass', 'Metal Building', 'WoodFramed', 'SteelFramed'
     # @param add_space_type_loads [Boolean] Populate existing standards space types in the model with internal loads
     # @param add_daylighting_controls [Boolean] Add daylighting controls
+    # @param add_infiltration [Boolean] Adds infiltration to the model based on cosntruction
     # @param add_elevators [Boolean] Apply elevators directly to a space in the model instead of to a space type
     # @param add_internal_mass [Boolean] Add internal mass to each space
     # @param add_exterior_lights [Boolean] Add exterior lightings objects to parking, canopies, and facades
@@ -36,6 +37,7 @@ module OpenstudioStandards
     # @param add_swh [Boolean] Add service water heating supply and demand objects
     # @param add_thermostat [Boolean] Add thermostats to thermal zones based on the standards space type
     # @param add_refrigeration [Boolean] Add refrigerated cases and walkin refrigeration
+    # @param refrigeration_template [String] The refrigeration technology level, either 'old', 'new', or 'advanced'
     # @param modify_wkdy_op_hrs [Boolean] Modify the default weekday hours of operation
     # @param wkdy_op_hrs_start_time [Double] Weekday operating hours start time. Enter as a fractional value, e.g. 5:15pm is 17.25. Only used if modify_wkdy_op_hrs is true.
     # @param wkdy_op_hrs_duration [Double] Weekday operating hours duration from start time. Enter as a fractional value, e.g. 5:15pm is 17.25. Only used if modify_wkdy_op_hrs is true.
@@ -66,6 +68,7 @@ module OpenstudioStandards
                                                 wall_construction_type: 'Inferred',
                                                 add_space_type_loads: true,
                                                 add_daylighting_controls: true,
+                                                add_infiltration: true,
                                                 add_elevators: true,
                                                 add_internal_mass: true,
                                                 add_exterior_lights: true,
@@ -74,6 +77,7 @@ module OpenstudioStandards
                                                 add_swh: true,
                                                 add_thermostat: true,
                                                 add_refrigeration: true,
+                                                refrigeration_template: 'new',
                                                 modify_wkdy_op_hrs: false,
                                                 wkdy_op_hrs_start_time: 8.0,
                                                 wkdy_op_hrs_duration: 8.0,
@@ -225,8 +229,7 @@ module OpenstudioStandards
         end
 
         model.getSpaceTypes.sort.each do |space_type|
-          # Don't add infiltration here; will be added later in the script
-          test = standard.space_type_apply_internal_loads(space_type, true, true, true, true, true, false)
+          test = standard.space_type_apply_internal_loads(space_type, true, true, true, true, true)
           if test == false
             OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CreateTypical', "Could not add loads for #{space_type.name}. Not expected for #{template}")
             next
@@ -234,7 +237,7 @@ module OpenstudioStandards
 
           # apply internal load schedules
           # the last bool test it to make thermostat schedules. They are now added in HVAC section instead of here
-          standard.space_type_apply_internal_load_schedules(space_type, true, true, true, true, true, true, false)
+          standard.space_type_apply_internal_load_schedules(space_type, true, true, true, true, true, false)
 
           # extend space type name to include the template. Consider this as well for load defs
           space_type.setName("#{space_type.name} - #{template}")
@@ -399,15 +402,22 @@ module OpenstudioStandards
           surface.setOutsideBoundaryCondition('Adiabatic')
         end
 
-        # modify the infiltration rates
+
+        # set ground temperatures from DOE prototype buildings
+        OpenstudioStandards::Weather.model_set_ground_temperatures(model, climate_zone: climate_zone)
+      end
+
+      # add infiltration
+      if add_infiltration
         if remove_objects
           model.getSpaceInfiltrationDesignFlowRates.each(&:remove)
         end
-        standard.model_apply_infiltration_standard(model)
-        standard.model_modify_infiltration_coefficients(model, primary_bldg_type, climate_zone)
 
-        # set ground temperatures from DOE prototype buildings
-        OpenstudioStandards::Weather.model_set_ground_temperatures(model, climate_zone: climate_zone)
+        # use NIST method for determining infiltration
+        # this sets a default always on; schedules are adjusted later if HVAC is added
+        OpenstudioStandards::Infiltration.model_set_nist_infiltration(model,
+                                                                      airtightness_value: standard.default_airtightness,
+                                                                      air_barrier: standard.default_air_barrier)
       end
 
       # add elevators (returns ElectricEquipment object)
@@ -448,9 +458,11 @@ module OpenstudioStandards
             ext_light.remove
           end
         end
-
-        exterior_lights = standard.model_add_typical_exterior_lights(model, exterior_lighting_zone.chars[0].to_i, onsite_parking_fraction)
-        exterior_lights.each do |k, v|
+        exterior_lights = OpenstudioStandards::ExteriorLighting.model_create_typical_exterior_lighting(model,
+                                                                                                       lighting_generation: 'default',
+                                                                                                       lighting_zone: exterior_lighting_zone.chars[0].to_i,
+                                                                                                       onsite_parking_fraction: onsite_parking_fraction)
+        exterior_lights.each do |v|
           OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CreateTypical', "Adding Exterior Lights named #{v.exteriorLightsDefinition.name} with design level of #{v.exteriorLightsDefinition.designLevel} * #{OpenStudio.toNeatString(v.multiplier, 0, true)}.")
         end
       end
@@ -463,17 +475,10 @@ module OpenstudioStandards
           model.getFanZoneExhausts.each(&:remove)
         end
 
-        zone_exhaust_fans = standard.model_add_exhaust(model, kitchen_makeup) # second argument is strategy for finding makeup zones for exhaust zones
-        zone_exhaust_fans.each do |k, v|
-          max_flow_rate_ip = OpenStudio.convert(k.maximumFlowRate.get, 'm^3/s', 'cfm').get
-          if v.key?(:zone_mixing)
-            zone_mixing = v[:zone_mixing]
-            mixing_source_zone_name = zone_mixing.sourceZone.get.name
-            mixing_design_flow_rate_ip = OpenStudio.convert(zone_mixing.designFlowRate.get, 'm^3/s', 'cfm').get
-            OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CreateTypical', "Adding #{OpenStudio.toNeatString(max_flow_rate_ip, 0, true)} (cfm) of exhaust to #{k.thermalZone.get.name}, with #{OpenStudio.toNeatString(mixing_design_flow_rate_ip, 0, true)} (cfm) of makeup air from #{mixing_source_zone_name}")
-          else
-            OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CreateTypical', "Adding #{OpenStudio.toNeatString(max_flow_rate_ip, 0, true)} (cfm) of exhaust to #{k.thermalZone.get.name}")
-          end
+        zone_exhaust_fans = standard.model_add_exhaust(model, makeup_source: kitchen_makeup)
+        zone_exhaust_fans.each do |zone_exhaust_fan|
+          max_flow_rate_ip = OpenStudio.convert(zone_exhaust_fan.maximumFlowRate.get, 'm^3/s', 'cfm').get
+          OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.CreateTypical', "Adding #{OpenStudio.toNeatString(max_flow_rate_ip, 0, true)} (cfm) of exhaust to #{zone_exhaust_fan.thermalZone.get.name}")
         end
       end
 
@@ -504,7 +509,7 @@ module OpenstudioStandards
           end
         end
 
-        typical_swh = standard.model_add_typical_swh(model, water_heater_fuel: service_water_heating_fuel)
+        typical_swh = OpenstudioStandards::ServiceWaterHeating.create_typical_service_water_heating(model, water_heating_fuel: service_water_heating_fuel)
         midrise_swh_loops = []
         stripmall_swh_loops = []
         typical_swh.each do |loop|
@@ -551,10 +556,14 @@ module OpenstudioStandards
         # remove refrigeration equipment
         if remove_objects
           model.getRefrigerationSystems.each(&:remove)
+          model.getRefrigerationCases.each(&:remove)
+          model.getRefrigerationWalkIns.each(&:remove)
+          model.getRefrigerationCompressorRacks.each(&:remove)
+          model.getRefrigerationCompressors.each(&:remove)
         end
 
         # Add refrigerated cases and walkins
-        standard.model_add_typical_refrigeration(model, primary_bldg_type)
+        OpenstudioStandards::Refrigeration.create_typical_refrigeration(model, template: refrigeration_template)
       end
 
       # @todo add slab modeling and slab insulation
@@ -575,7 +584,7 @@ module OpenstudioStandards
           next if standard.space_type_get_standards_data(space_type).empty?
 
           # the last bool test it to make thermostat schedules. They are added to the model but not assigned
-          standard.space_type_apply_internal_load_schedules(space_type, false, false, false, false, false, false, true)
+          standard.space_type_apply_internal_load_schedules(space_type, false, false, false, false, false, true)
 
           # identify thermal thermostat and apply to zones (apply_internal_load_schedules names )
           model.getThermostatSetpointDualSetpoints.sort.each do |thermostat|
@@ -803,6 +812,11 @@ module OpenstudioStandards
           # Apply the HVAC efficiency standard
           standard.model_apply_hvac_efficiency_standard(model, climate_zone)
         end
+
+        # adjust infiltration schedules
+        if add_infiltration
+          OpenstudioStandards::Infiltration.model_set_nist_infiltration_schedules(model)
+        end
       end
 
       # set unmet hours tolerance
@@ -919,13 +933,13 @@ module OpenstudioStandards
           space_types_new << space_type
 
           # add internal loads (the nil check isn't necessary, but I will keep it in as a warning instad of an error)
-          test = standard.space_type_apply_internal_loads(space_type, true, true, true, true, true, true)
+          test = standard.space_type_apply_internal_loads(space_type, true, true, true, true, true)
           if test.nil?
             OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.CreateTypical', "Could not add loads for #{space_type.name}. Not expected for #{template} #{lookup_building_type}")
           end
 
           # the last bool test it to make thermostat schedules. They are added to the model but not assigned
-          standard.space_type_apply_internal_load_schedules(space_type, true, true, true, true, true, true, true)
+          standard.space_type_apply_internal_load_schedules(space_type, true, true, true, true, true, true)
 
           # assign colors
           standard.space_type_apply_rendering_color(space_type)

data/lib/openstudio-standards/create_typical/space_type_information.rb

@@ -0,0 +1,160 @@
+module OpenstudioStandards
+  # The CreateTypical module provides methods to create and modify an entire building energy model of a typical building
+  module CreateTypical
+    # @!group Space Type Information
+    # Assigns information like number of units, number of beds, number of students, etc. to spaces in the model. Some methods that add exterior lighting or elevators require this information
+
+    # Assign information like number of units, number of beds, number of students, etc. to spaces in the model.
+    #
+    # @param model [OpenStudio::Model::Model] OpenStudio model object
+    # @param assign_properties_to_spaces [Boolean] Assign properties to Space objects
+    # @return [Hash] A hash of space properties
+    def self.model_get_space_information(model, assign_properties_to_spaces: true)
+      spaces_hash = {}
+
+      model.getSpaces.sort.each do |space|
+        space_type = space.spaceType.is_initialized ? space.spaceType.get : nil
+        next if space_type.nil?
+
+        # skip space if not part of floor area
+        next unless space.partofTotalFloorArea
+
+        standards_building_type = space_type.standardsBuildingType.is_initialized ? space_type.standardsBuildingType.get : nil
+        standards_space_type = space_type.standardsSpaceType.is_initialized ? space_type.standardsSpaceType.get : nil
+        next if standards_space_type.nil?
+
+        effective_number_of_spaces = space.multiplier
+        floor_area = space.floorArea * space.multiplier
+        number_of_people = space.numberOfPeople * space.multiplier
+
+        # determine number of units
+        number_of_units = 0
+        case standards_space_type
+        when 'GuestRoom', 'GuestRm', 'GuestRmOcc', 'GuestRmUnOcc', 'GuestRoom123Occ', 'GuestRoom123Vac', 'GuestRoom4Occ', 'GuestRoom4Vac', 'PatientRoom', 'PatRoom'
+          average_unit_size = OpenStudio.convert(350.0, 'ft^2', 'm^2').get
+          average_unit_size = OpenStudio.convert(280.0, 'ft^2', 'm^2').get if standards_building_type == 'LargeHotel'
+          number_of_units = floor_area / average_unit_size
+        when 'Apartment', 'ResBedroom', 'ResLiving'
+          average_unit_size = OpenStudio.convert(950.0, 'ft^2', 'm^2').get
+          number_of_units = floor_area / average_unit_size
+        when 'Strip mall - type 1', 'Strip mall - type 2', 'Strip mall - type 3'
+          average_unit_size = OpenStudio.convert(2250.0, 'ft^2', 'm^2').get
+          number_of_units = floor_area / average_unit_size
+        end
+
+        # determine number of beds
+        number_of_beds = 0
+        case standards_space_type
+        when 'PatientRoom', 'PatRoom', 'HspSurgOutptLab', 'HspNursing', 'ICU_PatRm', 'ICU_Open'
+          number_of_beds = number_of_people
+        end
+
+        # determine number of students
+        number_of_students = 0
+        case standards_space_type
+        when 'Classroom'
+          # assume 1 teacher
+          number_of_students = number_of_people - 1.0
+        end
+
+        # populate space hash
+        spaces_hash[space] = {}
+        spaces_hash[space][:standards_building_type] = standards_building_type
+        spaces_hash[space][:standards_space_type] = standards_space_type
+        spaces_hash[space][:effective_number_of_spaces] = effective_number_of_spaces
+        spaces_hash[space][:floor_area] = floor_area
+        spaces_hash[space][:number_of_people] = number_of_people
+        spaces_hash[space][:number_of_units] = number_of_units
+        spaces_hash[space][:number_of_beds] = number_of_beds
+        spaces_hash[space][:number_of_students] = number_of_students
+
+        if assign_properties_to_spaces
+          space.additionalProperties.setFeature('number_of_units', number_of_units)
+          space.additionalProperties.setFeature('number_of_beds', number_of_beds)
+          space.additionalProperties.setFeature('number_of_students', number_of_students)
+        end
+      end
+
+      return spaces_hash
+    end
+
+    # Assign information like number of units, number of beds, number of students, etc. to space types in the model.
+    #
+    # @param model [OpenStudio::Model::Model] OpenStudio model object
+    # @param assign_properties_to_space_types [Boolean] Aggregate and assign properties to SpaceType objects
+    # @return [Hash] A hash of space type properties
+    def self.model_get_space_type_information(model, assign_properties_to_space_types: true)
+      space_properties = OpenstudioStandards::CreateTypical.model_get_space_information(model, assign_properties_to_spaces: false)
+
+      space_type_hash = {}
+      model.getSpaceTypes.sort.each do |space_type|
+        standards_building_type = space_type.standardsBuildingType.is_initialized ? space_type.standardsBuildingType.get : nil
+        standards_space_type = space_type.standardsSpaceType.is_initialized ? space_type.standardsSpaceType.get : nil
+        next if standards_space_type.nil?
+
+        effective_number_of_spaces = 0
+        floor_area = 0.0
+        number_of_people = 0
+        number_of_units = 0
+        number_of_beds = 0
+        number_of_students = 0
+        space_type.spaces.sort.each do |space|
+          # skip space if not part of floor area
+          next unless space.partofTotalFloorArea
+
+          effective_number_of_spaces += space_properties[space][:effective_number_of_spaces]
+          floor_area += space_properties[space][:floor_area]
+          number_of_people += space_properties[space][:number_of_people]
+          number_of_units += space_properties[space][:number_of_units]
+          number_of_beds += space_properties[space][:number_of_beds]
+          number_of_students += space_properties[space][:number_of_students]
+        end
+
+        space_type_hash[space_type] = {}
+        space_type_hash[space_type][:standards_building_type] = standards_building_type
+        space_type_hash[space_type][:standards_space_type] = standards_space_type
+        space_type_hash[space_type][:effective_number_of_spaces] = effective_number_of_spaces
+        space_type_hash[space_type][:floor_area] = floor_area
+        space_type_hash[space_type][:number_of_people] = number_of_people
+        space_type_hash[space_type][:number_of_units] = number_of_units
+        space_type_hash[space_type][:number_of_beds] = number_of_beds
+        space_type_hash[space_type][:number_of_students] = number_of_students
+
+        if assign_properties_to_space_types
+          space_type.additionalProperties.setFeature('number_of_units', number_of_units)
+          space_type.additionalProperties.setFeature('number_of_beds', number_of_beds)
+          space_type.additionalProperties.setFeature('number_of_students', number_of_students)
+        end
+      end
+
+      return space_type_hash
+    end
+
+    # Assign information like number of units, number of beds, number of students, etc. to the building object in the model.
+    #
+    # @param model [OpenStudio::Model::Model] OpenStudio model object
+    # @param assign_properties_to_building [Boolean] Aggregate and assign properties to the Building object
+    # @return [Hash] A hash of building properties
+    def self.model_get_building_information(model, assign_properties_to_building: true)
+      space_type_properties = OpenstudioStandards::CreateTypical.model_get_space_type_information(model, assign_properties_to_space_types: false)
+
+      building = model.getBuilding
+      building_hash = {}
+      building_hash[:standards_building_type] = building.standardsBuildingType.is_initialized ? building.standardsBuildingType.get : nil
+      building_hash[:effective_number_of_spaces] = space_type_properties.values.sum { |v| v[:effective_number_of_spaces] || 0 }
+      building_hash[:floor_area] = space_type_properties.values.sum { |v| v[:floor_area] || 0 }
+      building_hash[:number_of_people] = space_type_properties.values.sum { |v| v[:number_of_people] || 0 }
+      building_hash[:number_of_units] = space_type_properties.values.sum { |v| v[:number_of_units] || 0 }
+      building_hash[:number_of_beds] = space_type_properties.values.sum { |v| v[:number_of_beds] || 0 }
+      building_hash[:number_of_students] = space_type_properties.values.sum { |v| v[:number_of_students] || 0 }
+
+      if assign_properties_to_building
+        building.additionalProperties.setFeature('number_of_units', building_hash[:number_of_units])
+        building.additionalProperties.setFeature('number_of_beds', building_hash[:number_of_beds])
+        building.additionalProperties.setFeature('number_of_students', building_hash[:number_of_students])
+      end
+
+      return building_hash
+    end
+  end
+end