urbanopt-cli 0.5.2 → 0.6.3

data/example_files/resources/hpxml-measures/HPXMLtoOpenStudio/resources/HPXMLDataTypes.xsd

@@ -4663,4 +4663,23 @@
 			</xs:extension>
 		</xs:simpleContent>
 	</xs:complexType>
+	<xs:simpleType name="PerformanceClass_simple">
+		<xs:restriction base="xs:string">
+			<xs:enumeration value="residential"/>
+			<xs:enumeration value="architectural"/>
+			<xs:enumeration value="light commercial"/>
+			<xs:enumeration value="commercial"/>
+			<xs:enumeration value="heavy commercial"/>
+		</xs:restriction>
+	</xs:simpleType>
+	<xs:complexType name="PerformanceClass">
+		<xs:annotation>
+			<xs:documentation>The North American Fenestration Standard/Specification for windows, doors and, skylights provides a method for rating the structural performance, water resistance and air leakage of fenestration products.</xs:documentation>
+		</xs:annotation>
+		<xs:simpleContent>
+			<xs:extension base="PerformanceClass_simple">
+				<xs:attribute name="dataSource" type="DataSource"/>
+			</xs:extension>
+		</xs:simpleContent>
+	</xs:complexType>
 </xs:schema>

data/example_files/resources/hpxml-measures/HPXMLtoOpenStudio/resources/airflow.rb

@@ -1143,7 +1143,11 @@ class Airflow
     return if @spaces[HPXML::LocationAtticVented].nil?
 
     if not vented_attic.vented_attic_sla.nil?
-      vented_attic_sla = vented_attic.vented_attic_sla
+      if @apply_ashrae140_assumptions
+        vented_attic_const_ach = get_infiltration_ACH_from_SLA(vented_attic.vented_attic_sla, 8.202, weather)
+      else
+        vented_attic_sla = vented_attic.vented_attic_sla
+      end
     elsif not vented_attic.vented_attic_ach.nil?
       if @apply_ashrae140_assumptions
         vented_attic_const_ach = vented_attic.vented_attic_ach

data/example_files/resources/hpxml-measures/HPXMLtoOpenStudio/resources/constants.rb

@@ -357,6 +357,10 @@ class Constants
     return 'dhw source hx'
   end
 
+  def self.ObjectNameTotalLoadsProgram
+    return 'total loads program'
+  end
+
   def self.ObjectNameUnitHeater
     return 'unit heater'
   end

data/example_files/resources/hpxml-measures/HPXMLtoOpenStudio/resources/constructions.rb

@@ -1169,6 +1169,68 @@ class Constructions
     constr.create_and_assign_constructions(runner, [subsurface], model)
   end
 
+  def self.apply_window_skylight_shading(model, window_or_skylight, index, shading_vertices, parent_surface, sub_surface, shading_group,
+                                         shading_schedules, shading_ems, name, cooling_season)
+    sf_summer = window_or_skylight.interior_shading_factor_summer * window_or_skylight.exterior_shading_factor_summer
+    sf_winter = window_or_skylight.interior_shading_factor_winter * window_or_skylight.exterior_shading_factor_winter
+    if (sf_summer < 1.0) || (sf_winter < 1.0)
+      # Apply shading
+      # We use a ShadingSurface instead of a Shade so that we perfectly get the result we want.
+      # The latter object is complex and it is essentially impossible to achieve the target reduction in transmitted
+      # solar (due to, e.g., re-reflectance, absorptance, angle modifiers, effects on convection, etc.).
+
+      # Shading surface is used to reduce beam solar and sky diffuse solar
+      shading_surface = OpenStudio::Model::ShadingSurface.new(shading_vertices, model)
+      shading_surface.setName("#{window_or_skylight.id} shading surface")
+      shading_surface.additionalProperties.setFeature('Azimuth', window_or_skylight.azimuth)
+      shading_surface.additionalProperties.setFeature('ParentSurface', parent_surface.name.to_s)
+
+      # Create transmittance schedule for heating/cooling seasons
+      trans_values = cooling_season.map { |c| c == 1 ? sf_summer : sf_winter }
+      if shading_schedules[trans_values].nil?
+        trans_sch = MonthWeekdayWeekendSchedule.new(model, "trans schedule winter=#{sf_winter} summer=#{sf_summer}", Array.new(24, 1), Array.new(24, 1), trans_values, Constants.ScheduleTypeLimitsFraction, false)
+        shading_schedules[trans_values] = trans_sch
+      end
+      shading_surface.setTransmittanceSchedule(shading_schedules[trans_values].schedule)
+
+      # EMS to actuate view factor to ground
+      sub_surface_type = sub_surface.subSurfaceType.downcase.to_s
+      actuator = OpenStudio::Model::EnergyManagementSystemActuator.new(sub_surface, *EPlus::EMSActuatorSurfaceViewFactorToGround)
+      actuator.setName("#{sub_surface_type}#{index}_actuator")
+
+      if shading_ems[:sensors][trans_values].nil?
+        shading_schedule_name = shading_schedules[trans_values].schedule.name.to_s
+        shading_coeff_sensor = OpenStudio::Model::EnergyManagementSystemSensor.new(model, 'Schedule Value')
+        shading_coeff_sensor.setName("#{sub_surface_type}_shading_coefficient")
+        shading_coeff_sensor.setKeyName(shading_schedule_name)
+        shading_ems[:sensors][trans_values] = shading_coeff_sensor
+      end
+
+      default_vf_to_ground = ((1.0 - Math::cos(sub_surface.tilt)) / 2.0).round(2)
+      shading_coeff = shading_ems[:sensors][trans_values].name
+      if shading_ems[:program].nil?
+        program = OpenStudio::Model::EnergyManagementSystemProgram.new(model)
+        program.setName("#{sub_surface_type}_view_factor_to_ground_program")
+        program.addLine("Set #{actuator.name} = #{default_vf_to_ground}*#{shading_coeff}")
+        shading_ems[:program] = program
+
+        program_cm = OpenStudio::Model::EnergyManagementSystemProgramCallingManager.new(model)
+        program_cm.setName("#{program.name} calling manager")
+        program_cm.setCallingPoint('BeginZoneTimestepAfterInitHeatBalance') # https://github.com/NREL/EnergyPlus/pull/8477#discussion_r567320478
+        program_cm.addProgram(program)
+      else
+        shading_ems[:program].addLine("Set #{actuator.name} = #{default_vf_to_ground}*#{shading_coeff}")
+      end
+
+      if shading_group.nil?
+        shading_group = OpenStudio::Model::ShadingSurfaceGroup.new(model)
+        shading_group.setName(name)
+      end
+      shading_surface.setShadingSurfaceGroup(shading_group)
+    end
+    return shading_group
+  end
+
   def self.calc_non_cavity_r(film_r, constr_set)
     # Calculate R-value for all non-cavity layers
     non_cavity_r = film_r

data/example_files/resources/hpxml-measures/HPXMLtoOpenStudio/resources/energyplus.rb

@@ -7,6 +7,7 @@ class EPlus
   EMSActuatorPumpMassFlowRate = 'Pump', 'Pump Mass Flow Rate'
   EMSActuatorPumpPressureRise = 'Pump', 'Pump Pressure Rise'
   EMSActuatorScheduleConstantValue = 'Schedule:Constant', 'Schedule Value'
+  EMSActuatorSurfaceViewFactorToGround = 'Surface', 'View Factor To Ground'
   EMSActuatorZoneInfiltrationFlowRate = 'Zone Infiltration', 'Air Exchange Flow Rate'
   EMSActuatorZoneMixingFlowRate = 'ZoneMixing', 'Air Exchange Flow Rate'
   EMSIntVarFanMFR = 'Fan Maximum Mass Flow Rate'

data/example_files/resources/hpxml-measures/HPXMLtoOpenStudio/resources/generator.rb

@@ -10,6 +10,7 @@ class Generator
     else
       # Apportion to single dwelling unit by # bedrooms
       fail if generator.number_of_bedrooms_served.to_f <= nbeds.to_f # EPvalidator.xml should prevent this
+
       annual_consumption_kbtu = generator.annual_consumption_kbtu * nbeds.to_f / generator.number_of_bedrooms_served.to_f
       annual_output_kwh = generator.annual_output_kwh * nbeds.to_f / generator.number_of_bedrooms_served.to_f
     end
@@ -40,7 +41,7 @@ class Generator
     gmt.setElectricalEfficiencyFunctionofTemperatureCurve(curve_cubic_constant)
     gmt.setElectricalEfficiencyFunctionofPartLoadRatioCurve(curve_cubic_constant)
 
-    elcd = gmt.electricLoadCenterDistribution.get
+    elcd = OpenStudio::Model::ElectricLoadCenterDistribution.new(model)
     elcd.setName("#{obj_name} elec load center dist")
     elcd.setGeneratorOperationSchemeType('Baseload')
     elcd.addGenerator(gmt)

data/example_files/resources/hpxml-measures/HPXMLtoOpenStudio/resources/geometry.rb

@@ -1,6 +1,380 @@
 # frozen_string_literal: true
 
 class Geometry
+  def self.create_space_and_zone(model, spaces, space_type)
+    if not spaces.keys.include? space_type
+      thermal_zone = OpenStudio::Model::ThermalZone.new(model)
+      thermal_zone.setName(space_type)
+
+      space = OpenStudio::Model::Space.new(model)
+      space.setName(space_type)
+
+      st = OpenStudio::Model::SpaceType.new(model)
+      st.setStandardsSpaceType(space_type)
+      space.setSpaceType(st)
+
+      space.setThermalZone(thermal_zone)
+      spaces[space_type] = space
+    end
+  end
+
+  def self.get_surface_transformation(offset, x, y, z)
+    x = UnitConversions.convert(x, 'ft', 'm')
+    y = UnitConversions.convert(y, 'ft', 'm')
+    z = UnitConversions.convert(z, 'ft', 'm')
+
+    m = OpenStudio::Matrix.new(4, 4, 0)
+    m[0, 0] = 1
+    m[1, 1] = 1
+    m[2, 2] = 1
+    m[3, 3] = 1
+    m[0, 3] = x * offset
+    m[1, 3] = y * offset
+    m[2, 3] = z.abs * offset
+
+    return OpenStudio::Transformation.new(m)
+  end
+
+  def self.create_floor_vertices(length, width, z_origin, default_azimuths)
+    length = UnitConversions.convert(length, 'ft', 'm')
+    width = UnitConversions.convert(width, 'ft', 'm')
+    z_origin = UnitConversions.convert(z_origin, 'ft', 'm')
+
+    vertices = OpenStudio::Point3dVector.new
+    vertices << OpenStudio::Point3d.new(-length / 2, -width / 2, z_origin)
+    vertices << OpenStudio::Point3d.new(-length / 2, width / 2, z_origin)
+    vertices << OpenStudio::Point3d.new(length / 2, width / 2, z_origin)
+    vertices << OpenStudio::Point3d.new(length / 2, -width / 2, z_origin)
+
+    # Rotate about the z axis
+    # This is not strictly needed, but will make the floor edges
+    # parallel to the walls for a better geometry rendering.
+    azimuth_rad = UnitConversions.convert(default_azimuths[0], 'deg', 'rad')
+    m = OpenStudio::Matrix.new(4, 4, 0)
+    m[0, 0] = Math::cos(-azimuth_rad)
+    m[1, 1] = Math::cos(-azimuth_rad)
+    m[0, 1] = -Math::sin(-azimuth_rad)
+    m[1, 0] = Math::sin(-azimuth_rad)
+    m[2, 2] = 1
+    m[3, 3] = 1
+    transformation = OpenStudio::Transformation.new(m)
+
+    return transformation * vertices
+  end
+
+  def self.create_wall_vertices(length, height, z_origin, azimuth, add_buffer: false, subsurface_area: 0)
+    length = UnitConversions.convert(length, 'ft', 'm')
+    height = UnitConversions.convert(height, 'ft', 'm')
+    z_origin = UnitConversions.convert(z_origin, 'ft', 'm')
+
+    if add_buffer
+      buffer = calculate_subsurface_parent_buffer(length, height)
+      buffer /= 2.0 # Buffer on each side
+    else
+      buffer = 0
+    end
+
+    vertices = OpenStudio::Point3dVector.new
+    vertices << OpenStudio::Point3d.new(-length / 2 - buffer, 0, z_origin - buffer)
+    vertices << OpenStudio::Point3d.new(-length / 2 - buffer, 0, z_origin + height + buffer)
+    if subsurface_area > 0
+      subsurface_area = UnitConversions.convert(subsurface_area, 'ft^2', 'm^2')
+      sub_length = length / 10.0
+      sub_height = subsurface_area / sub_length
+      if sub_height >= height
+        sub_height = height - 0.1
+        sub_length = subsurface_area / sub_height
+      end
+      vertices << OpenStudio::Point3d.new(length / 2 - sub_length + buffer, 0, z_origin + height + buffer)
+      vertices << OpenStudio::Point3d.new(length / 2 - sub_length + buffer, 0, z_origin + height - sub_height + buffer)
+      vertices << OpenStudio::Point3d.new(length / 2 + buffer, 0, z_origin + height - sub_height + buffer)
+    else
+      vertices << OpenStudio::Point3d.new(length / 2 + buffer, 0, z_origin + height + buffer)
+    end
+    vertices << OpenStudio::Point3d.new(length / 2 + buffer, 0, z_origin - buffer)
+
+    # Rotate about the z axis
+    azimuth_rad = UnitConversions.convert(azimuth, 'deg', 'rad')
+    m = OpenStudio::Matrix.new(4, 4, 0)
+    m[0, 0] = Math::cos(-azimuth_rad)
+    m[1, 1] = Math::cos(-azimuth_rad)
+    m[0, 1] = -Math::sin(-azimuth_rad)
+    m[1, 0] = Math::sin(-azimuth_rad)
+    m[2, 2] = 1
+    m[3, 3] = 1
+    transformation = OpenStudio::Transformation.new(m)
+
+    return transformation * vertices
+  end
+
+  def self.create_roof_vertices(length, width, z_origin, azimuth, tilt, add_buffer: false)
+    length = UnitConversions.convert(length, 'ft', 'm')
+    width = UnitConversions.convert(width, 'ft', 'm')
+    z_origin = UnitConversions.convert(z_origin, 'ft', 'm')
+
+    if add_buffer
+      buffer = calculate_subsurface_parent_buffer(length, width)
+      buffer /= 2.0 # Buffer on each side
+    else
+      buffer = 0
+    end
+
+    vertices = OpenStudio::Point3dVector.new
+    vertices << OpenStudio::Point3d.new(length / 2 + buffer, -width / 2 - buffer, 0)
+    vertices << OpenStudio::Point3d.new(length / 2 + buffer, width / 2 + buffer, 0)
+    vertices << OpenStudio::Point3d.new(-length / 2 - buffer, width / 2 + buffer, 0)
+    vertices << OpenStudio::Point3d.new(-length / 2 - buffer, -width / 2 - buffer, 0)
+
+    # Rotate about the x axis
+    m = OpenStudio::Matrix.new(4, 4, 0)
+    m[0, 0] = 1
+    m[1, 1] = Math::cos(Math::atan(tilt))
+    m[1, 2] = -Math::sin(Math::atan(tilt))
+    m[2, 1] = Math::sin(Math::atan(tilt))
+    m[2, 2] = Math::cos(Math::atan(tilt))
+    m[3, 3] = 1
+    transformation = OpenStudio::Transformation.new(m)
+    vertices = transformation * vertices
+
+    # Rotate about the z axis
+    azimuth_rad = UnitConversions.convert(azimuth, 'deg', 'rad')
+    rad180 = UnitConversions.convert(180, 'deg', 'rad')
+    m = OpenStudio::Matrix.new(4, 4, 0)
+    m[0, 0] = Math::cos(rad180 - azimuth_rad)
+    m[1, 1] = Math::cos(rad180 - azimuth_rad)
+    m[0, 1] = -Math::sin(rad180 - azimuth_rad)
+    m[1, 0] = Math::sin(rad180 - azimuth_rad)
+    m[2, 2] = 1
+    m[3, 3] = 1
+    transformation = OpenStudio::Transformation.new(m)
+    vertices = transformation * vertices
+
+    # Shift up by z
+    new_vertices = OpenStudio::Point3dVector.new
+    vertices.each do |vertex|
+      new_vertices << OpenStudio::Point3d.new(vertex.x, vertex.y, vertex.z + z_origin)
+    end
+
+    return new_vertices
+  end
+
+  def self.create_ceiling_vertices(length, width, z_origin, default_azimuths)
+    return OpenStudio::reverse(create_floor_vertices(length, width, z_origin, default_azimuths))
+  end
+
+  def self.explode_surfaces(runner, model, hpxml, walls_top)
+    # Re-position surfaces so as to not shade each other and to make it easier to visualize the building.
+
+    gap_distance = UnitConversions.convert(10.0, 'ft', 'm') # distance between surfaces of the same azimuth
+    rad90 = UnitConversions.convert(90, 'deg', 'rad')
+
+    # Determine surfaces to shift and distance with which to explode surfaces horizontally outward
+    surfaces = []
+    azimuth_lengths = {}
+    model.getSurfaces.sort.each do |surface|
+      next unless ['wall', 'roofceiling'].include? surface.surfaceType.downcase
+      next unless ['outdoors', 'foundation', 'adiabatic'].include? surface.outsideBoundaryCondition.downcase
+      next if surface.additionalProperties.getFeatureAsDouble('Tilt').get <= 0 # skip flat roofs
+
+      surfaces << surface
+      azimuth = surface.additionalProperties.getFeatureAsInteger('Azimuth').get
+      if azimuth_lengths[azimuth].nil?
+        azimuth_lengths[azimuth] = 0.0
+      end
+      azimuth_lengths[azimuth] += surface.additionalProperties.getFeatureAsDouble('Length').get + gap_distance
+    end
+    max_azimuth_length = azimuth_lengths.values.max
+
+    # Using the max length for a given azimuth, calculate the apothem (radius of the incircle) of a regular
+    # n-sided polygon to create the smallest polygon possible without self-shading. The number of polygon
+    # sides is defined by the minimum difference between two azimuths.
+    min_azimuth_diff = 360
+    azimuths_sorted = azimuth_lengths.keys.sort
+    azimuths_sorted.each_with_index do |az, idx|
+      diff1 = (az - azimuths_sorted[(idx + 1) % azimuths_sorted.size]).abs
+      diff2 = 360.0 - diff1 # opposite direction
+      if diff1 < min_azimuth_diff
+        min_azimuth_diff = diff1
+      end
+      if diff2 < min_azimuth_diff
+        min_azimuth_diff = diff2
+      end
+    end
+    if min_azimuth_diff > 0
+      nsides = [(360.0 / min_azimuth_diff).ceil, 4].max # assume rectangle at the minimum
+    else
+      nsides = 4
+    end
+    explode_distance = max_azimuth_length / (2.0 * Math.tan(UnitConversions.convert(180.0 / nsides, 'deg', 'rad')))
+
+    add_neighbor_shading(runner, model, max_azimuth_length, hpxml, walls_top)
+
+    # Initial distance of shifts at 90-degrees to horizontal outward
+    azimuth_side_shifts = {}
+    azimuth_lengths.keys.each do |azimuth|
+      azimuth_side_shifts[azimuth] = max_azimuth_length / 2.0
+    end
+
+    # Explode neighbors
+    model.getShadingSurfaceGroups.each do |shading_group|
+      next unless shading_group.name.to_s == Constants.ObjectNameNeighbors
+
+      shading_group.shadingSurfaces.each do |shading_surface|
+        azimuth = shading_surface.additionalProperties.getFeatureAsInteger('Azimuth').get
+        azimuth_rad = UnitConversions.convert(azimuth, 'deg', 'rad')
+        distance = shading_surface.additionalProperties.getFeatureAsDouble('Distance').get
+
+        unless azimuth_lengths.keys.include? azimuth
+          fail "A neighbor building has an azimuth (#{azimuth}) not equal to the azimuth of any wall."
+        end
+
+        # Push out horizontally
+        distance += explode_distance
+        transformation = get_surface_transformation(distance, Math::sin(azimuth_rad), Math::cos(azimuth_rad), 0)
+
+        shading_surface.setVertices(transformation * shading_surface.vertices)
+      end
+    end
+
+    # Explode walls, windows, doors, roofs, and skylights
+    surfaces_moved = []
+
+    surfaces.sort.each do |surface|
+      next if surface.additionalProperties.getFeatureAsDouble('Tilt').get <= 0 # skip flat roofs
+
+      if surface.adjacentSurface.is_initialized
+        next if surfaces_moved.include? surface.adjacentSurface.get
+      end
+
+      azimuth = surface.additionalProperties.getFeatureAsInteger('Azimuth').get
+      azimuth_rad = UnitConversions.convert(azimuth, 'deg', 'rad')
+
+      # Get associated shading surfaces (e.g., overhangs, interior shading surfaces)
+      overhang_surfaces = []
+      shading_surfaces = []
+      surface.subSurfaces.each do |subsurface|
+        next unless subsurface.subSurfaceType.downcase == 'fixedwindow'
+
+        subsurface.shadingSurfaceGroups.each do |overhang_group|
+          overhang_group.shadingSurfaces.each do |overhang|
+            overhang_surfaces << overhang
+          end
+        end
+      end
+      model.getShadingSurfaceGroups.each do |shading_group|
+        next unless [Constants.ObjectNameSkylightShade, Constants.ObjectNameWindowShade].include? shading_group.name.to_s
+
+        shading_group.shadingSurfaces.each do |window_shade|
+          next unless window_shade.additionalProperties.getFeatureAsString('ParentSurface').get == surface.name.to_s
+
+          shading_surfaces << window_shade
+        end
+      end
+
+      # Push out horizontally
+      distance = explode_distance
+
+      if surface.surfaceType.downcase == 'roofceiling'
+        # Ensure pitched surfaces are positioned outward justified with walls, etc.
+        tilt = surface.additionalProperties.getFeatureAsDouble('Tilt').get
+        width = surface.additionalProperties.getFeatureAsDouble('Width').get
+        distance -= 0.5 * Math.cos(Math.atan(tilt)) * width
+      end
+      transformation = get_surface_transformation(distance, Math::sin(azimuth_rad), Math::cos(azimuth_rad), 0)
+      transformation_shade = get_surface_transformation(distance + 0.001, Math::sin(azimuth_rad), Math::cos(azimuth_rad), 0) # Offset slightly from window
+
+      ([surface] + surface.subSurfaces + overhang_surfaces).each do |s|
+        s.setVertices(transformation * s.vertices)
+      end
+      shading_surfaces.each do |s|
+        s.setVertices(transformation_shade * s.vertices)
+      end
+      if surface.adjacentSurface.is_initialized
+        surface.adjacentSurface.get.setVertices(transformation * surface.adjacentSurface.get.vertices)
+      end
+
+      # Shift at 90-degrees to previous transformation, so surfaces don't overlap and shade each other
+      azimuth_side_shifts[azimuth] -= surface.additionalProperties.getFeatureAsDouble('Length').get / 2.0
+      transformation_shift = get_surface_transformation(azimuth_side_shifts[azimuth], Math::sin(azimuth_rad + rad90), Math::cos(azimuth_rad + rad90), 0)
+
+      ([surface] + surface.subSurfaces + overhang_surfaces + shading_surfaces).each do |s|
+        s.setVertices(transformation_shift * s.vertices)
+      end
+      if surface.adjacentSurface.is_initialized
+        surface.adjacentSurface.get.setVertices(transformation_shift * surface.adjacentSurface.get.vertices)
+      end
+
+      azimuth_side_shifts[azimuth] -= (surface.additionalProperties.getFeatureAsDouble('Length').get / 2.0 + gap_distance)
+
+      surfaces_moved << surface
+    end
+  end
+
+  def self.add_neighbor_shading(runner, model, length, hpxml, walls_top)
+    z_origin = 0 # shading surface always starts at grade
+
+    shading_surfaces = []
+    hpxml.neighbor_buildings.each do |neighbor_building|
+      height = neighbor_building.height.nil? ? walls_top : neighbor_building.height
+
+      vertices = Geometry.create_wall_vertices(length, height, z_origin, neighbor_building.azimuth)
+      shading_surface = OpenStudio::Model::ShadingSurface.new(vertices, model)
+      shading_surface.additionalProperties.setFeature('Azimuth', neighbor_building.azimuth)
+      shading_surface.additionalProperties.setFeature('Distance', neighbor_building.distance)
+      shading_surface.setName("Neighbor azimuth #{neighbor_building.azimuth} distance #{neighbor_building.distance}")
+
+      shading_surfaces << shading_surface
+    end
+
+    unless shading_surfaces.empty?
+      shading_surface_group = OpenStudio::Model::ShadingSurfaceGroup.new(model)
+      shading_surface_group.setName(Constants.ObjectNameNeighbors)
+      shading_surfaces.each do |shading_surface|
+        shading_surface.setShadingSurfaceGroup(shading_surface_group)
+      end
+    end
+  end
+
+  def self.set_zone_volumes(runner, model, spaces, hpxml, apply_ashrae140_assumptions)
+    # Living space
+    spaces[HPXML::LocationLivingSpace].thermalZone.get.setVolume(UnitConversions.convert(hpxml.building_construction.conditioned_building_volume, 'ft^3', 'm^3'))
+
+    # Basement, crawlspace, garage
+    spaces.keys.each do |space_type|
+      next unless [HPXML::LocationBasementUnconditioned, HPXML::LocationCrawlspaceUnvented, HPXML::LocationCrawlspaceVented, HPXML::LocationGarage].include? space_type
+
+      floor_area = hpxml.slabs.select { |s| s.interior_adjacent_to == space_type }.map { |s| s.area }.sum(0.0)
+      if space_type == HPXML::LocationGarage
+        height = 8.0
+      else
+        height = hpxml.foundation_walls.select { |w| w.interior_adjacent_to == space_type }.map { |w| w.height }.max
+      end
+
+      spaces[space_type].thermalZone.get.setVolume(UnitConversions.convert(floor_area * height, 'ft^3', 'm^3'))
+    end
+
+    # Attic
+    spaces.keys.each do |space_type|
+      next unless [HPXML::LocationAtticUnvented, HPXML::LocationAtticVented].include? space_type
+
+      floor_area = hpxml.frame_floors.select { |f| [f.interior_adjacent_to, f.exterior_adjacent_to].include? space_type }.map { |s| s.area }.sum(0.0)
+      roofs = hpxml.roofs.select { |r| r.interior_adjacent_to == space_type }
+      avg_pitch = roofs.map { |r| r.pitch }.sum(0.0) / roofs.size
+
+      if apply_ashrae140_assumptions
+        # Hardcode the attic volume to match ASHRAE 140 Table 7-2 specification
+        volume = 3463
+      else
+        # Assume square hip roof for volume calculations; energy results are very insensitive to actual volume
+        length = floor_area**0.5
+        height = 0.5 * Math.sin(Math.atan(avg_pitch / 12.0)) * length
+        volume = [floor_area * height / 3.0, 0.01].max
+      end
+
+      spaces[space_type].thermalZone.get.setVolume(UnitConversions.convert(volume, 'ft^3', 'm^3'))
+    end
+  end
+
   def self.get_temperature_scheduled_space_values(space_type)
     if space_type == HPXML::LocationOtherHeatedSpace
       # Average of indoor/outdoor temperatures with minimum of heating setpoint
@@ -48,8 +422,8 @@ class Geometry
     fail "Unhandled space type: #{space_type}."
   end
 
-  # Calculates space heights as the max z coordinate minus the min z coordinate
   def self.get_height_of_spaces(spaces)
+    # Calculates space heights as the max z coordinate minus the min z coordinate
     minzs = []
     maxzs = []
     spaces.each do |space|
@@ -60,8 +434,8 @@ class Geometry
     return maxzs.max - minzs.min
   end
 
-  # Return an array of z values for surfaces passed in. The values will be relative to the parent origin. This was intended for spaces.
   def self.getSurfaceZValues(surfaceArray)
+    # Return an array of z values for surfaces passed in. The values will be relative to the parent origin. This was intended for spaces.
     zValueArray = []
     surfaceArray.each do |surface|
       surface.vertices.each do |vertex|
@@ -90,15 +464,17 @@ class Geometry
     return UnitConversions.convert(tilts.max, 'rad', 'deg')
   end
 
-  # TODO: Remove these methods
+  # TODO: Remove this method
   def self.is_living(space_or_zone)
     return space_or_zone_is_of_type(space_or_zone, HPXML::LocationLivingSpace)
   end
 
+  # TODO: Remove this method
   def self.is_unconditioned_basement(space_or_zone)
     return space_or_zone_is_of_type(space_or_zone, HPXML::LocationBasementUnconditioned)
   end
 
+  # TODO: Remove this method
   def self.is_garage(space_or_zone)
     return space_or_zone_is_of_type(space_or_zone, HPXML::LocationGarage)
   end
@@ -128,7 +504,7 @@ class Geometry
     end
   end
 
-  def self.process_occupants(model, num_occ, cfa, space, schedules_file)
+  def self.apply_occupants(model, num_occ, cfa, space, schedules_file)
     occ_gain, hrs_per_day, sens_frac, lat_frac = Geometry.get_occupancy_default_values()
     weekday_sch = Schedule.OccupantsWeekdayFractions
     weekday_sch_sum = weekday_sch.split(',').map(&:to_f).sum(0.0)
@@ -220,4 +596,12 @@ class Geometry
       runner.registerWarning('The model contains existing objects and is being reset.')
     end
   end
+
+  def self.calculate_subsurface_parent_buffer(length, width)
+    # Calculates the minimum buffer distance that the parent surface
+    # needs relative to the subsurface in order to prevent E+ warnings
+    # about "Very small surface area".
+    min_surface_area = 0.005 # m^2
+    return 0.5 * (((length + width)**2 + 4.0 * min_surface_area)**0.5 - length - width)
+  end
 end