honeybee-openstudio 2.0.1 → 2.3.0

data/lib/from_honeybee/construction/window.rb

@@ -74,7 +74,6 @@ module FromHoneybee
 
   end #WindowConstructionAbridged
 end #FromHoneybee
-    
 
     
     

data/lib/from_honeybee/construction/windowshade.rb

@@ -0,0 +1,207 @@
+# *******************************************************************************
+# Honeybee OpenStudio Gem, Copyright (c) 2020, Alliance for Sustainable 
+# Energy, LLC, Ladybug Tools LLC and other contributors. All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# (1) Redistributions of source code must retain the above copyright notice,
+# this list of conditions and the following disclaimer.
+#
+# (2) Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation
+# and/or other materials provided with the distribution.
+#
+# (3) Neither the name of the copyright holder nor the names of any contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission from the respective party.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND ANY CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S), ANY CONTRIBUTORS, THE
+# UNITED STATES GOVERNMENT, OR THE UNITED STATES DEPARTMENT OF ENERGY, NOR ANY OF
+# THEIR EMPLOYEES, BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+# OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+# *******************************************************************************
+
+require 'from_honeybee/model_object'
+require 'from_honeybee/construction/window'
+
+require 'openstudio'
+
+module FromHoneybee
+  class WindowConstructionShadeAbridged < ModelObject
+    attr_reader :errors, :warnings
+
+    def initialize(hash = {})
+      super(hash)
+      @construction = nil
+      @shade_construction = nil
+      @shade_location = nil
+      @shade_material = nil
+      @control_type = nil
+      @setpoint = nil
+      @schedule = nil
+    end
+
+    def defaults
+      @@schema[:components][:schemas][:WindowConstructionShadeAbridged][:properties]
+    end
+
+    def find_existing_openstudio_object(openstudio_model)
+      object = openstudio_model.getConstructionByName(@hash[:identifier])
+      return object.get if object.is_initialized
+      nil
+    end
+
+    def to_openstudio(openstudio_model)
+      # write the shaded and unsaded versions of the construciton into the model
+      # reverse the shaded and unshaded identifiers so unshaded one is assigned to apertures
+      unshd_id = @hash[:identifier]
+      shd_id = @hash[:window_construction][:identifier]
+      @hash[:window_construction][:identifier] = unshd_id
+      @hash[:identifier] = shd_id
+
+      # create the unshaded construction
+      unshd_constr_obj = WindowConstructionAbridged.new(@hash[:window_construction])
+      @construction = unshd_constr_obj.to_openstudio(openstudio_model)
+
+      # create the shaded construction
+      @shade_construction = OpenStudio::Model::Construction.new(openstudio_model)
+      @shade_construction.setName(shd_id)
+
+      # create the layers of the unshaded construction into which we will insert the shade
+      os_materials = []
+      @hash[:window_construction][:layers].each do |layer|
+        material_identifier = layer
+        material = openstudio_model.getMaterialByName(material_identifier)
+        unless material.empty?
+          os_material = material.get
+          os_materials << os_material
+        end
+      end
+
+      # figure out where to insert the shade material and insert it
+      if @hash[:shade_location]
+        @shade_location = @hash[:shade_location]
+      else
+        @shade_location = defaults[:shade_location][:default]
+      end
+
+      # insert the shade material
+      shd_mat_name = openstudio_model.getMaterialByName(@hash[:shade_material])
+      unless shd_mat_name.empty?
+        @shade_material = shd_mat_name.get
+      end
+      unless @shade_material.nil?
+        if @shade_material.is_a? OpenStudio::Model::StandardGlazing
+          if @shade_location == 'Interior'
+              os_materials[-1] = @shade_material
+          elsif @shade_location == 'Exterior' | os_materials.length < 2
+              os_materials[0] = @shade_material
+          else  # middle glass pane
+              os_materials[-3] = @shade_material
+          end
+        else
+          if @shade_location == 'Interior'
+              os_materials << @shade_material
+          elsif @shade_location == 'Exterior'
+              os_materials.unshift(@shade_material)
+          else  # between glass shade/blind
+            split_gap = split_gas_gap(openstudio_model, os_materials[-2], @shade_material)
+            os_materials[-2] = split_gap
+            os_materials.insert(-2, @shade_material)
+            os_materials.insert(-2, split_gap)
+          end
+        end
+      end
+
+      # assign the layers to the shaded construction
+      os_materials_vec = OpenStudio::Model::MaterialVector.new
+      os_materials.each do |mat|
+        os_materials_vec << mat
+      end
+      @shade_construction.setLayers(os_materials)
+
+      # set defaults for control type, setpoint, and schedule
+      if @hash[:control_type]
+        @control_type = @hash[:control_type]
+      else
+        @control_type = defaults[:control_type][:default]
+      end
+
+      if @hash[:setpoint]
+        @setpoint = @hash[:setpoint]
+      else
+        @setpoint = defaults[:setpoint][:default]
+      end
+
+      unless @hash[:schedule].nil?
+        schedule_ref = openstudio_model.getScheduleByName(@hash[:schedule])
+        unless schedule_ref.empty?
+            @schedule = schedule_ref.get
+            if @control_type == 'AlwaysOn'
+                @control_type = 'OnIfScheduleAllows'
+            end
+        end
+      end
+
+      @shade_construction
+    end
+
+    def to_openstudio_shading_control(openstudio_model)
+      # add a WindowShadingControl object to a model for a given aperture and room
+      os_shade_control = OpenStudio::Model::ShadingControl.new(@shade_construction)
+
+      # figure out the shading type
+      if @shade_material.is_a? OpenStudio::Model::StandardGlazing
+        shd_type = 'SwitchableGlazing'
+      elsif @shade_material.is_a? OpenStudio::Model::Blind
+        if @shade_location == 'Between'
+          shd_type = 'BetweenGlassBlind'
+        else
+          shd_type = @shade_location + 'Blind'
+        end
+      else
+        if @shade_location == 'Between'
+          shd_type = 'BetweenGlassShade'
+        else
+          shd_type = @shade_location + 'Shade'
+        end
+      end
+      os_shade_control.setShadingType(shd_type)
+
+      # set the shade control type and schedule
+      os_shade_control.setShadingControlType(@control_type)
+      unless @setpoint.nil?
+        os_shade_control.setSetpoint(@setpoint)
+      end
+      unless @schedule.nil?
+        os_shade_control.setSchedule(@schedule)
+      end
+
+      os_shade_control
+    end
+
+    def split_gas_gap(openstudio_model, original_gap, shade_material)
+        # split a gas gap material in two when it is interrupeted by a shade/blind
+        if shade_material.is_a? OpenStudio::Model::Blind
+          shd_thick = 0
+        else
+          shd_thick = shade_material.thickness
+        end
+        gap_thick = (original_gap.thickness - shd_thick) / 2
+        gap_obj = $gas_gap_hash[original_gap.name.get]
+        new_gap = gap_obj.to_openstudio(openstudio_model)
+        new_gap.setName(original_gap.name.get + gap_thick.to_s)
+        new_gap.setThickness(gap_thick)
+        new_gap
+    end
+
+  end #WindowConstructionShadeAbridged
+end #FromHoneybee

data/lib/from_honeybee/extension.rb

@@ -37,6 +37,7 @@ require 'openstudio/extension'
 module FromHoneybee
   class Extension < OpenStudio::Extension::Extension
     @@schema = nil
+    @@standards = nil
 
     # Override parent class
     def initialize
@@ -49,6 +50,7 @@ module FromHoneybee
 
       @instance_lock = Mutex.new
       @@schema ||= schema
+      @@standards ||= standards
     end
 
     # Return the absolute path of the measures or nil if there is none.
@@ -73,7 +75,12 @@ module FromHoneybee
 
     # return path to the model schema file
     def schema_file
-      File.join(@lib_dir, 'from_honeybee', '_openapi', 'model.json')
+      File.join(@lib_dir, 'from_honeybee', '_defaults', 'model.json')
+    end
+
+    # return path to the model standards file
+    def standards_file
+      File.join(@lib_dir, 'from_honeybee', '_defaults', 'energy_default.json')
     end
 
     # return the model schema
@@ -89,6 +96,19 @@ module FromHoneybee
       @@schema
     end
 
+    # return the JSON of default standards
+    def standards
+      @instance_lock.synchronize do
+        if @@standards.nil?
+          File.open(standards_file, 'r') do |f|
+            @@standards = JSON.parse(f.read, symbolize_names: true)
+          end
+        end
+      end
+
+      @@standards
+    end
+
     # check if the model schema is valid
     def schema_valid?
       if Gem.loaded_specs.has_key?("json-schema")

data/lib/from_honeybee/model.rb

@@ -50,6 +50,7 @@ require 'from_honeybee/hvac/ideal_air'
 # import the construction objects
 require 'from_honeybee/construction/opaque'
 require 'from_honeybee/construction/window'
+require 'from_honeybee/construction/windowshade'
 require 'from_honeybee/construction/shade'
 require 'from_honeybee/construction/air'
 
@@ -94,12 +95,12 @@ module FromHoneybee
       # initialize class variable @@extension only once
       @@extension ||= Extension.new
       @@schema ||= @@extension.schema
+      @@standards ||= @@extension.standards
 
       @hash = hash
       @type = @hash[:type]
       raise 'Unknown model type' if @type.nil?
       raise "Incorrect model type '#{@type}'" unless @type == 'Model'
-
     end
 
     # check if the model is valid
@@ -156,40 +157,75 @@ module FromHoneybee
       building = @openstudio_model.getBuilding
       building.setStandardsBuildingType('MediumOffice')
 
+      # initialize global hashes for various model properties
+      $gas_gap_hash = Hash.new  # hash to track gas gaps in case they are split by shades
+      $air_boundary_hash = Hash.new  # hash to track any air boundary constructions
+      $window_shade_hash = Hash.new  # hash to track any window constructions with shade
+      $programtype_setpoint_hash = Hash.new  # hash to track Setpoint objects
+
       # create all of the non-geometric model elements
       if log_report
         puts 'Translating Materials'
       end
-      create_materials
+      if @hash[:properties][:energy][:materials]
+        create_materials(@hash[:properties][:energy][:materials])
+      end
 
       if log_report
         puts 'Translating Constructions'
       end
-      create_constructions
+      if @hash[:properties][:energy][:constructions]
+        create_constructions(@hash[:properties][:energy][:constructions])
+      end
       
       if log_report
         puts 'Translating ConstructionSets'
       end
-      create_construction_set
-      create_global_construction_set
+      if @hash[:properties][:energy][:construction_sets]
+        create_construction_sets(@hash[:properties][:energy][:construction_sets])
+      end
 
       if log_report
         puts 'Translating Schedules'
       end
-      create_schedule_type_limits
-      create_schedules
+      if @hash[:properties][:energy][:schedule_type_limits]
+        create_schedule_type_limits(@hash[:properties][:energy][:schedule_type_limits])
+      end
+      if @hash[:properties][:energy][:schedules]
+        create_schedules(@hash[:properties][:energy][:schedules])
+      end
 
       if log_report
         puts 'Translating ProgramTypes'
       end
-      create_program_types
+      if @hash[:properties][:energy][:program_types]
+        create_program_types(@hash[:properties][:energy][:program_types])
+      end
+
+      # create the default construction set to catch any cases of unassigned constructions
+      if log_report
+        puts 'Translating Default ConstructionSet'
+      end
+      create_default_construction_set
 
-      # create all of the model geometry
+      # create the geometry and add any extra properties to it
       if log_report
         puts 'Translating Room Geometry'
       end
       create_rooms
 
+      unless $window_shade_hash.empty?
+        if log_report
+          puts 'Translating Window Shading Control'
+        end
+        create_shading_control
+      end
+
+      if log_report
+        puts 'Translating HVAC Systems'
+      end
+      create_hvacs
+
       if log_report
         puts 'Translating Context Shade Geometry'
       end
@@ -197,100 +233,141 @@ module FromHoneybee
       create_orphaned_faces
       create_orphaned_apertures
       create_orphaned_doors
-
-      # create the hvac systems
-      if log_report
-        puts 'Translating HVAC Systems'
-      end
-      create_hvacs
     end
 
-    def create_materials
-      @hash[:properties][:energy][:materials].each do |material|
-        material_type = material[:type]
-
-        case material_type
-        when 'EnergyMaterial'
-          material_object = EnergyMaterial.new(material)
-        when 'EnergyMaterialNoMass'
-          material_object = EnergyMaterialNoMass.new(material)
-        when 'EnergyWindowMaterialGas'
-          material_object = EnergyWindowMaterialGas.new(material)
-        when 'EnergyWindowMaterialGasCustom'
-          material_object = EnergyWindowMaterialGasCustom.new(material)
-        when 'EnergyWindowMaterialSimpleGlazSys'
-          material_object = EnergyWindowMaterialSimpleGlazSys.new(material)
-        when 'EnergyWindowMaterialBlind'
-          material_object = EnergyWindowMaterialBlind.new(material)
-        when 'EnergyWindowMaterialGlazing'
-          material_object = EnergyWindowMaterialGlazing.new(material)
-        when 'EnergyWindowMaterialShade'
-          material_object = EnergyWindowMaterialShade.new(material)
-        else
-          raise "Unknown material type #{material_type}"
+    def create_materials(material_dicts, check_existing=false)
+      material_dicts.each do |material|
+        # check if there's already a material in the model with the identifier
+        add_obj = true
+        if check_existing
+          object = @openstudio_model.getMaterialByName(material[:identifier])
+          if object.is_initialized
+            add_obj = false
+          end
+        end
+
+        # add the material object to the Model
+        if add_obj
+          material_type = material[:type]
+          case material_type
+          when 'EnergyMaterial'
+            material_object = EnergyMaterial.new(material)
+          when 'EnergyMaterialNoMass'
+            material_object = EnergyMaterialNoMass.new(material)
+          when 'EnergyWindowMaterialGas'
+            material_object = EnergyWindowMaterialGas.new(material)
+            $gas_gap_hash[material[:identifier]] = material_object
+          when 'EnergyWindowMaterialGasMixture'
+            material_object = EnergyWindowMaterialGasMixture.new(material)
+            $gas_gap_hash[material[:identifier]] = material_object
+          when 'EnergyWindowMaterialGasCustom'
+            material_object = EnergyWindowMaterialGasCustom.new(material)
+            $gas_gap_hash[material[:identifier]] = material_object
+          when 'EnergyWindowMaterialSimpleGlazSys'
+            material_object = EnergyWindowMaterialSimpleGlazSys.new(material)
+          when 'EnergyWindowMaterialBlind'
+            material_object = EnergyWindowMaterialBlind.new(material)
+          when 'EnergyWindowMaterialGlazing'
+            material_object = EnergyWindowMaterialGlazing.new(material)
+          when 'EnergyWindowMaterialShade'
+            material_object = EnergyWindowMaterialShade.new(material)
+          else
+            raise "Unknown material type #{material_type}"
+          end
+          material_object.to_openstudio(@openstudio_model)
         end
-        material_object.to_openstudio(@openstudio_model)
       end
     end
 
-    def create_constructions
-      $air_boundary_hash = Hash.new  # hash to track any air boundary constructions
+    def create_constructions(construction_dicts, check_existing=false)
+      construction_dicts.each do |construction|
+        # check if there's already a construction in the model with the identifier
+        add_obj = true
+        if check_existing
+          object = @openstudio_model.getConstructionByName(construction[:identifier])
+          if object.is_initialized
+            add_obj = false
+          end
+        end
 
-      @hash[:properties][:energy][:constructions].each do |construction|
-        identifier = construction[:identifier]
-        construction_type = construction[:type]
-        
-        case construction_type
-        when 'OpaqueConstructionAbridged'
-          construction_object = OpaqueConstructionAbridged.new(construction)
-        when 'WindowConstructionAbridged'
-          construction_object = WindowConstructionAbridged.new(construction)
-        when 'ShadeConstruction'
-          construction_object = ShadeConstruction.new(construction)
-        when 'AirBoundaryConstructionAbridged'
-          construction_object = AirBoundaryConstructionAbridged.new(construction)
-          $air_boundary_hash[construction[:identifier]] = construction
-        else
-          raise "Unknown construction type #{construction_type}."
+        # add the construction object to the Model
+        if add_obj
+          construction_type = construction[:type]
+          case construction_type
+          when 'OpaqueConstructionAbridged'
+            construction_object = OpaqueConstructionAbridged.new(construction)
+          when 'WindowConstructionAbridged'
+            construction_object = WindowConstructionAbridged.new(construction)
+          when 'WindowConstructionShadeAbridged'
+            construction_object = WindowConstructionShadeAbridged.new(construction)
+            $window_shade_hash[construction[:identifier]] = construction_object
+          when 'ShadeConstruction'
+            construction_object = ShadeConstruction.new(construction)
+          when 'AirBoundaryConstructionAbridged'
+            construction_object = AirBoundaryConstructionAbridged.new(construction)
+            $air_boundary_hash[construction[:identifier]] = construction
+          else
+            raise "Unknown construction type #{construction_type}."
+          end
+          construction_object.to_openstudio(@openstudio_model)
         end
-        construction_object.to_openstudio(@openstudio_model)
       end
     end
 
-    def create_construction_set
-      if @hash[:properties][:energy][:construction_sets]
-        @hash[:properties][:energy][:construction_sets].each do |construction_set|
-        construction_set_object = ConstructionSetAbridged.new(construction_set)
-        construction_set_object.to_openstudio(@openstudio_model)
+    def create_construction_sets(construction_set_dicts, check_existing=false)
+      construction_set_dicts.each do |construction_set|
+        # check if there's already a construction set in the model with the identifier
+        add_obj = true
+        if check_existing
+          object = @openstudio_model.getDefaultConstructionSetByName(
+            construction_set[:identifier])
+          if object.is_initialized
+            add_obj = false
+          end
         end
-      end
-    end
 
-    def create_global_construction_set
-      if @hash[:properties][:energy][:global_construction_set]
-        construction_id = @hash[:properties][:energy][:global_construction_set]
-        construction = @openstudio_model.getDefaultConstructionSetByName(construction_id)
-        unless construction.empty?
-          openstudio_construction = construction.get
+        # add the construction set object to the Model
+        if add_obj
+          construction_set_object = ConstructionSetAbridged.new(construction_set)
+          construction_set_object.to_openstudio(@openstudio_model)
         end
-        @openstudio_model.getBuilding.setDefaultConstructionSet(openstudio_construction)
       end
     end
 
-    def create_schedule_type_limits
-      if @hash[:properties][:energy][:schedule_type_limits]
-        @hash[:properties][:energy][:schedule_type_limits].each do |schedule_type_limit|
+    def create_schedule_type_limits(stl_dicts, check_existing=false)
+      stl_dicts.each do |schedule_type_limit|
+        # check if there's already a schedule type limit in the model with the identifier
+        add_obj = true
+        if check_existing
+          object = @openstudio_model.getScheduleTypeLimitsByName(
+            schedule_type_limit[:identifier])
+          if object.is_initialized
+            add_obj = false
+          end
+        end
+
+        # add the schedule type limit object to the Model
+        if add_obj
           schedule_type_limit_object = ScheduleTypeLimit.new(schedule_type_limit)
           schedule_type_limit_object.to_openstudio(@openstudio_model)
         end
       end
     end
 
-    def create_schedules
-      if @hash[:properties][:energy][:schedules]
-        @hash[:properties][:energy][:schedules].each do |schedule|
-          schedule_type = schedule[:type]
+    def create_schedules(schedule_dicts, check_existing=false)
+      schedule_dicts.each do |schedule|
+        # check if there's already a schedule in the model with the identifier
+        add_obj = true
+        if check_existing
+          object = @openstudio_model.getScheduleByName(schedule[:identifier])
+          if object.is_initialized
+            add_obj = false
+          end
+        end
 
+        # add the schedule object to the Model
+        if add_obj
+          schedule_type = schedule[:type]
           case schedule_type
           when 'ScheduleRulesetAbridged'
             schedule_object = ScheduleRulesetAbridged.new(schedule)
@@ -300,21 +377,56 @@ module FromHoneybee
             raise("Unknown schedule type #{schedule_type}.")
           end
           schedule_object.to_openstudio(@openstudio_model)
-        
         end
       end
     end
 
-    def create_program_types
-      if @hash[:properties][:energy][:program_types]
-        $programtype_setpoint_hash = Hash.new  # hash to track Setpoint objects
-        @hash[:properties][:energy][:program_types].each do |space_type|
+    def create_program_types(program_dicts, check_existing=false)
+      program_dicts.each do |space_type|
+        # check if there's already a space type in the model with the identifier
+        add_obj = true
+        if check_existing
+          object = @openstudio_model.getSpaceTypeByName(space_type[:identifier])
+          if object.is_initialized
+            add_obj = false
+          end
+        end
+
+        # add the space type object to the Model
+        if add_obj
           space_type_object = ProgramTypeAbridged.new(space_type)
           space_type_object.to_openstudio(@openstudio_model)
         end
       end
     end
 
+    def create_default_construction_set
+      # create the materials, constructions and construction set
+      create_materials(@@standards[:materials], true)
+      create_constructions(@@standards[:constructions], true)
+      create_construction_sets(@@standards[:construction_sets], true)
+
+      # write the fractional schedule type and always on schedule if they are not there
+      @@standards[:schedule_type_limits].each do |sch_type_limit|
+        if sch_type_limit[:identifier] == 'Fractional'
+          create_schedule_type_limits([sch_type_limit], true)
+        end
+      end
+      @@standards[:schedules].each do |schedule|
+        if schedule[:identifier] == 'Always On'
+          create_schedules([schedule], true)
+        end
+      end
+
+      # set the default construction set to the building level of the Model
+      construction_id = 'Default Generic Construction Set'
+      construction = @openstudio_model.getDefaultConstructionSetByName(construction_id)
+      unless construction.empty?
+        os_constructionset = construction.get
+        @openstudio_model.getBuilding.setDefaultConstructionSet(os_constructionset)
+      end
+    end
+
     def create_rooms
       if @hash[:rooms]
         $air_mxing_array = []  # list to track any air mixing between Rooms
@@ -344,7 +456,7 @@ module FromHoneybee
           end
         end
       
-        # Create mixing objects between Rooms
+        # create mixing objects between Rooms
         $air_mxing_array.each do |air_mix_props|
           zone_mixing = OpenStudio::Model::ZoneMixing.new(air_mix_props[0])
           zone_mixing.setDesignFlowRate(air_mix_props[1])
@@ -361,35 +473,25 @@ module FromHoneybee
         end
       end
     end
-          
-    
-    def create_orphaned_shades
-      if @hash[:orphaned_shades]
-        shading_surface_group = OpenStudio::Model::ShadingSurfaceGroup.new(@openstudio_model)
-        shading_surface_group.setShadingSurfaceType('Building')
-        @hash[:orphaned_shades].each do |shade|
-        shade_object = Shade.new(shade)
-        openstudio_shade = shade_object.to_openstudio(@openstudio_model)
-        openstudio_shade.setShadingSurfaceGroup(shading_surface_group)
-        end
-      end
-    end
-
-    def create_orphaned_faces
-      if @hash[:orphaned_faces]
-        raise "Orphaned Faces are not translatable to OpenStudio."
-      end
-    end
 
-    def create_orphaned_apertures
-      if @hash[:orphaned_apertures]
-        raise "Orphaned Apertures are not translatable to OpenStudio."
-      end
-    end
-    
-    def create_orphaned_doors
-      if @hash[:orphaned_doors]
-        raise "Orphaned Doors are not translatable to OpenStudio."
+    def create_shading_control
+      # assign any shading control objects to windows with shades
+      # this is run as a separate step once all logic about construction sets is in place
+      sub_faces = @openstudio_model.getSubSurfaces()
+      sub_faces.each do |sub_face|
+        constr_ref = sub_face.construction
+        unless constr_ref.empty?
+          constr = constr_ref.get
+          constr_name_ref = constr.name
+          unless constr_name_ref.empty?
+            constr_name = constr_name_ref.get
+            unless $window_shade_hash[constr_name].nil?
+              window_shd_constr = $window_shade_hash[constr_name]
+              os_shd_control = window_shd_constr.to_openstudio_shading_control(@openstudio_model)
+              sub_face.setShadingControl(os_shd_control)
+            end
+          end
+        end
       end
     end
 
@@ -428,6 +530,36 @@ module FromHoneybee
       end
     end 
 
+    def create_orphaned_shades
+      if @hash[:orphaned_shades]
+        shading_surface_group = OpenStudio::Model::ShadingSurfaceGroup.new(@openstudio_model)
+        shading_surface_group.setShadingSurfaceType('Building')
+        @hash[:orphaned_shades].each do |shade|
+        shade_object = Shade.new(shade)
+        openstudio_shade = shade_object.to_openstudio(@openstudio_model)
+        openstudio_shade.setShadingSurfaceGroup(shading_surface_group)
+        end
+      end
+    end
+
+    def create_orphaned_faces
+      if @hash[:orphaned_faces]
+        raise "Orphaned Faces are not translatable to OpenStudio."
+      end
+    end
+
+    def create_orphaned_apertures
+      if @hash[:orphaned_apertures]
+        raise "Orphaned Apertures are not translatable to OpenStudio."
+      end
+    end
+    
+    def create_orphaned_doors
+      if @hash[:orphaned_doors]
+        raise "Orphaned Doors are not translatable to OpenStudio."
+      end
+    end
+
     #TODO: create runlog for errors. 
     
   end # Model