openstudio-standards 0.2.16 → 0.2.17.rc1

data/lib/openstudio-standards/standards/Standards.PlanarSurface.rb

@@ -18,17 +18,45 @@ class Standard
   #   and the value is the newly created construction.
   #   This can be used to avoid creating duplicate constructions.
   # @todo Align the standard construction enumerations in the
-  #   spreadsheet with the enumerations in OpenStudio (follow CBECC-Com).
-  def planar_surface_apply_standard_construction(planar_surface, climate_zone, previous_construction_map = {})
+  # spreadsheet with the enumerations in OpenStudio (follow CBECC-Com).
+  def planar_surface_apply_standard_construction(planar_surface, climate_zone, previous_construction_map = {}, wwr_building_type = nil, wwr_info = {}, surface_category)
     # Skip surfaces not in a space
     return previous_construction_map if planar_surface.space.empty?
 
     space = planar_surface.space.get
+    if surface_category == 'ExteriorSubSurface'
+      surface_type = planar_surface.subSurfaceType
+    else
+      surface_type = planar_surface.surfaceType
+    end
 
     # Skip surfaces that don't have a construction
-    return previous_construction_map if planar_surface.construction.empty?
+    # return previous_construction_map if planar_surface.construction.empty?
+    if !planar_surface.construction.empty?
+      construction = planar_surface.construction.get
+    else
+      # Get appropriate default construction if not defined inside surface object
+      construction = nil
+      space_type = space.spaceType.get
+      if space.defaultConstructionSet.is_initialized
+        cons_set = space.defaultConstructionSet.get
+        construction = get_default_surface_cons_from_surface_type(surface_category, surface_type, cons_set)
+      end
+      if construction.nil? && space_type.defaultConstructionSet.is_initialized
+        cons_set = space_type.defaultConstructionSet.get
+        construction = get_default_surface_cons_from_surface_type(surface_category, surface_type, cons_set)
+      end
+      if construction.nil? && space.buildingStory.get.defaultConstructionSet.is_initialized
+        cons_set = space.buildingStory.get.defaultConstructionSet.get
+        construction = get_default_surface_cons_from_surface_type(surface_category, surface_type, cons_set)
+      end
+      if construction.nil? && space.model.building.get.defaultConstructionSet.is_initialized
+        cons_set = space.model.building.get.defaultConstructionSet.get
+        construction = get_default_surface_cons_from_surface_type(surface_category, surface_type, cons_set)
+      end
 
-    construction = planar_surface.construction.get
+      return previous_construction_map if construction.nil?
+    end
 
     # Determine if residential or nonresidential
     # based on the space type.
@@ -43,6 +71,7 @@ class Standard
     # Get the intended surface type
     standards_info = construction.standardsInformation
     surf_type = standards_info.intendedSurfaceType
+
     if surf_type.empty?
       OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.PlanarSurface', "Could not determine the intended surface type for #{planar_surface.name} from #{construction.name}.  This surface will not have the standard applied.")
       return previous_construction_map
@@ -54,23 +83,32 @@ class Standard
     # Mapping is between standards-defined enumerations and the
     # enumerations available in OpenStudio.
     stds_type = nil
-    # Windows
-    if surf_type == 'ExteriorWindow'
+    # Windows and Glass Doors
+    if surf_type == 'ExteriorWindow' || surf_type == 'GlassDoor'
       stds_type = standards_info.fenestrationFrameType
       if stds_type.is_initialized
         stds_type = stds_type.get
+        if !wwr_building_type.nil?
+          stds_type = 'Any Vertical Glazing'
+        end
         case stds_type
         when 'Metal Framing', 'Metal Framing with Thermal Break'
           stds_type = 'Metal framing (all other)'
         when 'Non-Metal Framing'
           stds_type = 'Nonmetal framing (all)'
+        when 'Any Vertical Glazing'
+          stds_type = 'Any Vertical Glazing'
         else
           OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.PlanarSurface', "The standards fenestration frame type #{stds_type} cannot be used on #{surf_type} in #{planar_surface.name}.  This surface will not have the standard applied.")
           return previous_construction_map
         end
       else
-        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.PlanarSurface', "Could not determine the standards fenestration frame type for #{planar_surface.name} from #{construction.name}.  This surface will not have the standard applied.")
-        return previous_construction_map
+        if !wwr_building_type.nil?
+          stds_type = 'Any Vertical Glazing'
+        else
+          OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.PlanarSurface', "Could not determine the standards fenestration frame type for #{planar_surface.name} from #{construction.name}.  This surface will not have the standard applied.")
+          return previous_construction_map
+        end
       end
     # Skylights
     elsif surf_type == 'Skylight'
@@ -120,8 +158,20 @@ class Standard
 
     # Check if the construction type was already created.
     # If yes, use that construction.  If no, make a new one.
+
+    # for multi-building type - search for the surface wwr type
+    surface_std_wwr_type = wwr_building_type
     new_construction = nil
     type = [template, climate_zone, surf_type, stds_type, occ_type]
+    # Only apply the surface_std_wwr_type update when wwr_building_type has Truthy values
+    if !wwr_building_type.nil? && (surf_type == 'ExteriorWindow' || surf_type == 'GlassDoor')
+      space = planar_surface.space.get
+      if space.hasAdditionalProperties && space.additionalProperties.hasFeature('building_type_for_wwr')
+        surface_std_wwr_type = space.additionalProperties.getFeatureAsString('building_type_for_wwr').get
+      end
+      type.push(surface_std_wwr_type)
+    end
+
     if previous_construction_map[type]
       new_construction = previous_construction_map[type]
     else
@@ -129,7 +179,9 @@ class Standard
                                                          climate_zone_set,
                                                          surf_type,
                                                          stds_type,
-                                                         occ_type)
+                                                         occ_type,
+                                                         wwr_building_type: surface_std_wwr_type,
+                                                         wwr_info: wwr_info)
       if !new_construction == false
         previous_construction_map[type] = new_construction
       end
@@ -146,4 +198,73 @@ class Standard
 
     return previous_construction_map
   end
+
+  # Get appropriate construction object based on type of surface or subsurface
+  # @author: Doug Maddox, PNNL
+  # @param: surface_category [string] type of surface: this is not an OpenStudio string
+  # @param: surface_type [string] SubSurfaceType: this is an OpenStudio string
+  # @param: cons_set [object] DefaultSubSurfaceConstructions object
+  # @return: [object] Construction object
+  def get_default_surface_cons_from_surface_type(surface_category, surface_type, cons_set)
+    # Get DefaultSurfaceContstructions or DefaultSubSurfaceConstructions object
+    if surface_category == 'ExteriorSurface'
+      cons_list = cons_set.defaultExteriorSurfaceConstructions.get
+    elsif surface_category == 'GroundSurface'
+      cons_list = cons_set.defaultGroundContactSurfaceConstructions.get
+    elsif surface_category == 'ExteriorSubSurface'
+      cons_list = cons_set.defaultExteriorSubSurfaceConstructions.get
+    else
+      cons_list = nil
+    end
+
+    cons = nil
+    case surface_type
+    when 'FixedWindow'
+      if cons_list.fixedWindowConstruction.is_initialized
+        cons = cons_list.fixedWindowConstruction.get
+      end
+    when 'OperableWindow'
+      if cons_list.operableWindowConstruction.is_initialized
+        cons = cons_list.operableWindowConstruction.get
+      end
+    when 'Door'
+      if cons_list.doorConstruction.is_initialized
+        cons = cons_list.doorConstruction.get
+      end
+    when 'GlassDoor'
+      if cons_list.glassDoorConstruction.is_initialized
+        cons = cons_list.glassDoorConstruction.get
+      end
+    when 'OverheadDoor'
+      if cons_list.overheadDoorConstruction.is_initialized
+        cons = cons_list.overheadDoorConstruction.get
+      end
+    when 'Skylight'
+      if cons_list.skylightConstruction.is_initialized
+        cons = cons_list.skylightConstruction.get
+      end
+    when 'TubularDaylightDome'
+      if cons_list.tubularDaylightDomeConstruction.is_initialized
+        cons = cons_list.tubularDaylightDomeConstruction.get
+      end
+    when 'TubularDaylightDiffuser'
+      if cons_list.tubularDaylightDiffuserConstruction.is_initialized
+        cons = cons_list.tubularDaylightDiffuserConstruction.get
+      end
+    when 'Floor'
+      if cons_list.floorConstruction.is_initialized
+        cons = cons_list.floorConstruction.get
+      end
+    when 'Wall'
+      if cons_list.wallConstruction.is_initialized
+        cons = cons_list.wallConstruction.get
+      end
+    when 'Roof'
+      if cons_list.roofConstruction.is_initialized
+        cons = cons_list.roofConstruction.get
+      end
+    end
+
+    return cons
+  end
 end

data/lib/openstudio-standards/standards/Standards.PlantLoop.rb

@@ -11,6 +11,53 @@ class Standard
     # plant_loop_enable_supply_water_temperature_reset(plant_loop) if plant_loop_supply_water_temperature_reset_required?(plant_loop)
   end
 
+  # Apply sizing and controls to chilled water loop
+  #
+  # @param model [OpenStudio::Model::Model] OpenStudio model object
+  # @param chilled_water_loop [OpenStudio::Model::PlantLoop] chilled water loop
+  # @param dsgn_sup_wtr_temp [Double] design chilled water supply T
+  # @param dsgn_sup_wtr_temp_delt [Double] design chilled water supply delta T
+  # @return [Bool] returns true if successful, false if not
+  def chw_sizing_control(model, chilled_water_loop, dsgn_sup_wtr_temp, dsgn_sup_wtr_temp_delt)
+    # chilled water loop sizing and controls
+    if dsgn_sup_wtr_temp.nil?
+      dsgn_sup_wtr_temp = 44.0
+      dsgn_sup_wtr_temp_c = OpenStudio.convert(dsgn_sup_wtr_temp, 'F', 'C').get
+    else
+      dsgn_sup_wtr_temp_c = OpenStudio.convert(dsgn_sup_wtr_temp, 'F', 'C').get
+    end
+    if dsgn_sup_wtr_temp_delt.nil?
+      dsgn_sup_wtr_temp_delt_k = OpenStudio.convert(10.1, 'R', 'K').get
+    else
+      dsgn_sup_wtr_temp_delt_k = OpenStudio.convert(dsgn_sup_wtr_temp_delt, 'R', 'K').get
+    end
+    chilled_water_loop.setMinimumLoopTemperature(1.0)
+    chilled_water_loop.setMaximumLoopTemperature(40.0)
+    sizing_plant = chilled_water_loop.sizingPlant
+    sizing_plant.setLoopType('Cooling')
+    sizing_plant.setDesignLoopExitTemperature(dsgn_sup_wtr_temp_c)
+    sizing_plant.setLoopDesignTemperatureDifference(dsgn_sup_wtr_temp_delt_k)
+    chw_temp_sch = model_add_constant_schedule_ruleset(model,
+                                                       dsgn_sup_wtr_temp_c,
+                                                       name = "#{chilled_water_loop.name} Temp - #{dsgn_sup_wtr_temp.round(0)}F")
+    chw_stpt_manager = OpenStudio::Model::SetpointManagerScheduled.new(model, chw_temp_sch)
+    chw_stpt_manager.setName("#{chilled_water_loop.name} Setpoint Manager")
+    chw_stpt_manager.addToNode(chilled_water_loop.supplyOutletNode)
+    # @todo Yixing check the CHW Setpoint from standards
+    # @todo Should be a OutdoorAirReset, see the changes I've made in Standards.PlantLoop.apply_prm_baseline_temperatures
+
+    return true
+  end
+
+  # Set configuration in model for chilled water primary/secondary loop interface
+  #
+  # @param model [OpenStudio::Model::Model] OpenStudio model object
+  # @return [String] common_pipe or heat_exchanger
+  def plant_loop_set_chw_pri_sec_configuration(model)
+    pri_sec_config = 'common_pipe'
+    return pri_sec_config
+  end
+
   # Determine if the plant loop is variable flow.
   # Returns true if primary and/or secondary pumps are variable speed.
   #
@@ -771,7 +818,7 @@ class Standard
       end
     end
 
-    # Modify all the secondary pumps
+    # Modify all the secondary pumps besides constant pumps
     plant_loop.demandComponents.each do |sc|
       if sc.to_PumpVariableSpeed.is_initialized
         pump = sc.to_PumpVariableSpeed.get
@@ -914,9 +961,9 @@ class Standard
   # Splits the single chiller used for the initial sizing run
   # into multiple separate chillers based on Appendix G.
   #
-  # @param plant_loop [OpenStudio::Model::PlantLoop] chilled water loop
+  # @param plant_loop_args [Array] chilled water loop (OpenStudio::Model::PlantLoop), sizing run directory
   # @return [Bool] returns true if successful, false if not
-  def plant_loop_apply_prm_number_of_chillers(plant_loop)
+  def plant_loop_apply_prm_number_of_chillers(plant_loop, sizing_run_dir = nil)
     # Skip non-cooling plants
     return true unless plant_loop.sizingPlant.loopType == 'Cooling'
 

data/lib/openstudio-standards/standards/Standards.ScheduleCompact.rb

@@ -1,6 +1,50 @@
 class Standard
   # @!group ScheduleCompact
 
+  # Returns the min and max value in a design day (heating or cooling) from a Compact schedule
+  #
+  # @author Weili Xu, PNNL
+  # @param schedule_compact [OpenStudio::Model::ScheduleCompact] schedule ruleset object
+  # @param type [String] 'winter' will enable the winter design day search, 'summer' enables summer design day search
+  # @return [Hash] Hash has two keys, min and max.
+  def schedule_compact_design_day_min_max_value(schedule_compact, type = 'winter')
+    vals = []
+    design_day_flag = false
+    prev_str = ''
+    schedule_compact.extensibleGroups.each do |eg|
+      if design_day_flag && prev_str.include?('until')
+        val = eg.getDouble(0)
+        if val.is_initialized
+          vals << val.get
+        end
+      end
+
+      str = eg.getString(0)
+      if str.is_initialized
+        prev_str = str.get.downcase
+        if prev_str.include?('for:')
+          # Process a new day schedule, turn the flag off.
+          design_day_flag = false
+          # in the same line, if there is design day label and matches the type, turn the flag back on.
+          if prev_str.include?(type) || prev_str.include?('alldays')
+            design_day_flag = true
+          end
+        end
+      end
+    end
+
+    # Error if no values were found
+    if vals.size.zero?
+      OpenStudio.logFree(OpenStudio::Error, 'openstudio::standards::ScheduleCompact', "Could not find any value in #{schedule_compact.name} design day schedule when determining min and max.")
+      result = { 'min' => 999.9, 'max' => 999.9 }
+      return result
+    end
+
+    result = { 'min' => vals.min, 'max' => vals.max }
+
+    return result
+  end
+
   # Returns the min and max value for this schedule.
   #
   # @author Andrew Parker, NREL.

data/lib/openstudio-standards/standards/Standards.ScheduleConstant.rb

@@ -26,3 +26,30 @@ class Standard
     return result
   end
 end
+
+# Create a sequential array of values from a ScheduleConstant object
+# Will actually include 24 extra values if model year is a leap year
+# Will also include 24 values at end of array representing the holiday day schedule
+# Intended use is for storing fan schedules to hash of ZoneName:SchedArray so schedules
+# can be saved when HVAC objects are deleted
+# @author Doug Maddox, PNNL
+# @param [object] model
+# @param [Object] schedule_ruleset
+# @return [Array<Double>] Array of sequential hourly values for year + 24 hours at end for holiday
+def get_8760_values_from_schedule_constant(model, schedule_constant)
+  yd = model.getYearDescription
+  start_date = yd.makeDate(1, 1)
+  sch_value = schedule_constant.value
+
+  # Start with 365 days + 24 hrs for holiday
+  hrs_per_year = 8759 + 24
+  # Add 24 hours if leap year
+  hrs_per_year += 24 if start_date.isLeapYear
+
+  values = []
+  (0..hrs_per_year).each do |ihr|
+    values << sch_value
+  end
+
+  return values
+end