openstudio-ee 0.2.0 → 0.2.1

data/lib/measures/replace_hvac_with_gshp_and_doas/resources/OsLib_HelperMethods.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module OsLib_HelperMethods
+  # populate choice argument from model objects
+  def self.populateChoiceArgFromModelObjects(model, modelObject_args_hash, includeBuilding = nil)
+    # populate choice argument for constructions that are applied to surfaces in the model
+    modelObject_handles = OpenStudio::StringVector.new
+    modelObject_display_names = OpenStudio::StringVector.new
+
+    # looping through sorted hash of constructions
+    modelObject_args_hash.sort.map do |key, value|
+      modelObject_handles << value.handle.to_s
+      modelObject_display_names << key
+    end
+
+    if !includeBuilding.nil?
+      # add building to string vector with space type
+      building = model.getBuilding
+      modelObject_handles << building.handle.to_s
+      modelObject_display_names << includeBuilding
+    end
+
+    result = { 'modelObject_handles' => modelObject_handles, 'modelObject_display_names' => modelObject_display_names }
+    return result
+  end # end of OsLib_HelperMethods.populateChoiceArgFromModelObjects
+
+  # check choice argument made from model objects
+  def self.checkChoiceArgFromModelObjects(object, variableName, to_ObjectType, runner, user_arguments)
+    apply_to_building = false
+    modelObject = nil
+    if object.empty?
+      handle = runner.getStringArgumentValue(variableName, user_arguments)
+      if handle.empty?
+        runner.registerError("No #{variableName} was chosen.") # this logic makes this not work on an optional model object argument
+      else
+        runner.registerError("The selected #{variableName} with handle '#{handle}' was not found in the model. It may have been removed by another measure.")
+      end
+      return false
+    else
+      if !eval("object.get.#{to_ObjectType}").empty?
+        modelObject = eval("object.get.#{to_ObjectType}").get
+      elsif !object.get.to_Building.empty?
+        apply_to_building = true
+      else
+        runner.registerError("Script Error - argument not showing up as #{variableName}.")
+        return false
+      end
+    end # end of if construction.empty?
+
+    result = { 'modelObject' => modelObject, 'apply_to_building' => apply_to_building }
+  end # end of OsLib_HelperMethods.checkChoiceArgFromModelObjects
+
+  # check choice argument made from model objects
+  def self.checkOptionalChoiceArgFromModelObjects(object, variableName, to_ObjectType, runner, user_arguments)
+    apply_to_building = false
+    modelObject = nil
+    if object.empty?
+      handle = runner.getOptionalStringArgumentValue(variableName, user_arguments)
+      if handle.empty?
+        # do nothing, this is a valid option
+        modelObject = nil
+        apply_to_building = false
+      else
+        runner.registerError("The selected #{variableName} with handle '#{handle}' was not found in the model. It may have been removed by another measure.")
+        return false
+      end
+    else
+      if !eval("object.get.#{to_ObjectType}").empty?
+        modelObject = eval("object.get.#{to_ObjectType}").get
+      elsif !object.get.to_Building.empty?
+        apply_to_building = true
+      else
+        runner.registerError("Script Error - argument not showing up as #{variableName}.")
+        return false
+      end
+    end # end of if construction.empty?
+
+    result = { 'modelObject' => modelObject, 'apply_to_building' => apply_to_building }
+  end # end of OsLib_HelperMethods.checkChoiceArgFromModelObjects
+
+  # check value of double arguments
+  def self.checkDoubleArguments(runner, min, max, argumentHash)
+    # error flag
+    error = false
+
+    argumentHash.each do |display, argument|
+      if !min.nil?
+        if argument < min
+          runner.registerError("Please enter value between #{min} and #{max} for #{display}.") # add in argument display name
+          error = true
+        end
+      end
+      if !max.nil?
+        if argument > max
+          runner.registerError("Please enter value between #{min} and #{max} for #{display}.") # add in argument display name
+          error = true
+        end
+      end
+    end # end of argumentArray.each do
+
+    # check for any errors
+    if error
+      return false
+    else
+      return true
+    end
+  end # end of OsLib_HelperMethods.checkDoubleArguments
+
+  # OpenStudio has built in toNeatString method
+  # OpenStudio::toNeatString(double,2,true)# double,decimals, show commas
+
+  # OpenStudio has built in helper for unit conversion. That can be done using OpenStudio::convert() as shown below.
+  # OpenStudio::convert(double,"from unit string","to unit string").get
+end

data/lib/measures/replace_hvac_with_gshp_and_doas/resources/OsLib_LightingAndEquipment.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "#{File.dirname(__FILE__)}/OsLib_Schedules"
+
+# load OpenStudio measure libraries
+module OsLib_LightingAndEquipment
+  include OsLib_Schedules
+
+  # return min ans max from array
+  def self.getExteriorLightsValue(model)
+    facility = model.getFacility
+    starting_exterior_lights_power = 0
+    starting_exterior_lights = facility.exteriorLights
+    starting_exterior_lights.each do |starting_exterior_light|
+      starting_exterior_light_multiplier = starting_exterior_light.multiplier
+      starting_exterior_light_def = starting_exterior_light.exteriorLightsDefinition
+      starting_exterior_light_base_power = starting_exterior_light_def.designLevel
+      starting_exterior_lights_power += starting_exterior_light_base_power * starting_exterior_light_multiplier
+    end
+
+    result = { 'exteriorLightingPower' => starting_exterior_lights_power, 'exteriorLights' => starting_exterior_lights }
+    return result
+  end # end of OsLib_LightingAndEquipment.getExteriorLightsValue
+
+  # return min ans max from array
+  def self.removeAllExteriorLights(model, runner)
+    facility = model.getFacility
+    lightsRemoved = false
+    starting_exterior_lights = facility.exteriorLights
+    starting_exterior_lights.each do |starting_exterior_light|
+      runner.registerInfo("Removed exterior light named #{starting_exterior_light.name}.")
+      starting_exterior_light.remove
+      lightsRemoved = true
+    end
+
+    result = lightsRemoved
+    return result
+  end # end of OsLib_LightingAndEquipment.removeAllExteriorLights
+
+  # return min ans max from array
+  def self.addExteriorLights(model, runner, options = {})
+    # set defaults to use if user inputs not passed in
+    defaults = {
+      'name' => 'Exterior Light',
+      'power' => 0,
+      'subCategory' => 'Exterior Lighting',
+      'controlOption' => 'AstronomicalClock',
+      'setbackStartTime' => 0,
+      'setbackEndTime' => 0,
+      'setbackFraction' => 0.25
+    }
+
+    # merge user inputs with defaults
+    options = defaults.merge(options)
+
+    ext_lights_def = OpenStudio::Model::ExteriorLightsDefinition.new(model)
+    ext_lights_def.setName("#{options['name']} Definition")
+    runner.registerInfo("Setting #{ext_lights_def.name} to a design power of #{options['power']} Watts")
+    ext_lights_def.setDesignLevel(options['power'])
+
+    # creating schedule type limits for the exterior lights schedule
+    ext_lights_sch_type_limits = OpenStudio::Model::ScheduleTypeLimits.new(model)
+    ext_lights_sch_type_limits.setName("#{options['name']} Fractional")
+    ext_lights_sch_type_limits.setLowerLimitValue(0)
+    ext_lights_sch_type_limits.setUpperLimitValue(1)
+    ext_lights_sch_type_limits.setNumericType('Continuous')
+
+    # prepare values for profile
+    if options['setbackStartTime'] == 24
+      profile = { options['setbackEndTime'] => options['setbackFraction'], 24.0 => 1.0 }
+    elsif options['setbackStartTime'] == 0
+      profile = { options['setbackEndTime'] => options['setbackFraction'], 24.0 => 1.0 }
+    elsif options['setbackStartTime'] > options['setbackEndTime']
+      profile = { options['setbackEndTime'] => options['setbackFraction'], options['setbackStartTime'] => 1.0, 24.0 => options['setbackFraction'] }
+    else
+      profile = { options['setbackStartTime'] => 1.0, options['setbackEndTime'] => options['setbackFraction'] }
+    end
+
+    # inputs
+    createSimpleSchedule_inputs = {
+      'name' => options['name'],
+      'winterTimeValuePairs' => profile,
+      'summerTimeValuePairs' => profile,
+      'defaultTimeValuePairs' => profile
+    }
+
+    # create a ruleset schedule with a basic profile
+    ext_lights_sch = OsLib_Schedules.createSimpleSchedule(model, createSimpleSchedule_inputs)
+
+    # creating exterior lights object
+    ext_lights = OpenStudio::Model::ExteriorLights.new(ext_lights_def, ext_lights_sch)
+    ext_lights.setName("#{options['power']} w Exterior Light")
+    ext_lights.setControlOption(options['controlOption'])
+    ext_lights.setEndUseSubcategory(options['subCategory'])
+
+    result = ext_lights
+    return result
+  end # end of OsLib_LightingAndEquipment.addExteriorLights
+end

data/lib/measures/replace_hvac_with_gshp_and_doas/resources/OsLib_Schedules.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module OsLib_Schedules
+  # create a ruleset schedule with a basic profile
+  def self.createSimpleSchedule(model, options = {})
+    defaults = {
+      'name' => nil,
+      'winterTimeValuePairs' => { 24.0 => 0.0 },
+      'summerTimeValuePairs' => { 24.0 => 1.0 },
+      'defaultTimeValuePairs' => { 24.0 => 1.0 }
+    }
+
+    # merge user inputs with defaults
+    options = defaults.merge(options)
+
+    # ScheduleRuleset
+    sch_ruleset = OpenStudio::Model::ScheduleRuleset.new(model)
+    if name
+      sch_ruleset.setName(options['name'])
+    end
+
+    # Winter Design Day
+    winter_dsn_day = OpenStudio::Model::ScheduleDay.new(model)
+    sch_ruleset.setWinterDesignDaySchedule(winter_dsn_day)
+    winter_dsn_day = sch_ruleset.winterDesignDaySchedule
+    winter_dsn_day.setName("#{sch_ruleset.name} Winter Design Day")
+    options['winterTimeValuePairs'].each do |k, v|
+      hour = k.truncate
+      min = ((k - hour) * 60).to_i
+      winter_dsn_day.addValue(OpenStudio::Time.new(0, hour, min, 0), v)
+    end
+
+    # Summer Design Day
+    summer_dsn_day = OpenStudio::Model::ScheduleDay.new(model)
+    sch_ruleset.setSummerDesignDaySchedule(summer_dsn_day)
+    summer_dsn_day = sch_ruleset.summerDesignDaySchedule
+    summer_dsn_day.setName("#{sch_ruleset.name} Summer Design Day")
+    options['summerTimeValuePairs'].each do |k, v|
+      hour = k.truncate
+      min = ((k - hour) * 60).to_i
+      summer_dsn_day.addValue(OpenStudio::Time.new(0, hour, min, 0), v)
+    end
+
+    # All Days
+    week_day = sch_ruleset.defaultDaySchedule
+    week_day.setName("#{sch_ruleset.name} Schedule Week Day")
+    options['defaultTimeValuePairs'].each do |k, v|
+      hour = k.truncate
+      min = ((k - hour) * 60).to_i
+      week_day.addValue(OpenStudio::Time.new(0, hour, min, 0), v)
+    end
+
+    result = sch_ruleset
+    return result
+  end # end of OsLib_Schedules.createSimpleSchedule
+
+  # create a complex ruleset schedule
+  def self.createComplexSchedule(model, options = {})
+    defaults = {
+      'name' => nil,
+      'default_day' => ['always_on', [24.0, 1.0]]
+    }
+
+    # merge user inputs with defaults
+    options = defaults.merge(options)
+
+    # ScheduleRuleset
+    sch_ruleset = OpenStudio::Model::ScheduleRuleset.new(model)
+    if name
+      sch_ruleset.setName(options['name'])
+    end
+
+    # Winter Design Day
+    unless options['winter_design_day'].nil?
+      winter_dsn_day = OpenStudio::Model::ScheduleDay.new(model)
+      sch_ruleset.setWinterDesignDaySchedule(winter_dsn_day)
+      winter_dsn_day = sch_ruleset.winterDesignDaySchedule
+      winter_dsn_day.setName("#{sch_ruleset.name} Winter Design Day")
+      options['winter_design_day'].each do |data_pair|
+        hour = data_pair[0].truncate
+        min = ((data_pair[0] - hour) * 60).to_i
+        winter_dsn_day.addValue(OpenStudio::Time.new(0, hour, min, 0), data_pair[1])
+      end
+    end
+
+    # Summer Design Day
+    unless options['summer_design_day'].nil?
+      summer_dsn_day = OpenStudio::Model::ScheduleDay.new(model)
+      sch_ruleset.setSummerDesignDaySchedule(summer_dsn_day)
+      summer_dsn_day = sch_ruleset.summerDesignDaySchedule
+      summer_dsn_day.setName("#{sch_ruleset.name} Summer Design Day")
+      options['summer_design_day'].each do |data_pair|
+        hour = data_pair[0].truncate
+        min = ((data_pair[0] - hour) * 60).to_i
+        summer_dsn_day.addValue(OpenStudio::Time.new(0, hour, min, 0), data_pair[1])
+      end
+    end
+
+    # Default Day
+    default_day = sch_ruleset.defaultDaySchedule
+    default_day.setName("#{sch_ruleset.name} #{options['default_day'][0]}")
+    default_data_array = options['default_day']
+    default_data_array.delete_at(0)
+    default_data_array.each do |data_pair|
+      hour = data_pair[0].truncate
+      min = ((data_pair[0] - hour) * 60).to_i
+      default_day.addValue(OpenStudio::Time.new(0, hour, min, 0), data_pair[1])
+    end
+
+    # Rules
+    options['rules']&.each do |data_array|
+      rule = OpenStudio::Model::ScheduleRule.new(sch_ruleset)
+      rule.setName("#{sch_ruleset.name} #{data_array[0]} Rule")
+      date_range = data_array[1].split('-')
+      start_date = date_range[0].split('/')
+      end_date = date_range[1].split('/')
+      rule.setStartDate(model.getYearDescription.makeDate(start_date[0].to_i, start_date[1].to_i))
+      rule.setEndDate(model.getYearDescription.makeDate(end_date[0].to_i, end_date[1].to_i))
+      days = data_array[2].split('/')
+      rule.setApplySunday(true) if days.include? 'Sun'
+      rule.setApplyMonday(true) if days.include? 'Mon'
+      rule.setApplyTuesday(true) if days.include? 'Tue'
+      rule.setApplyWednesday(true) if days.include? 'Wed'
+      rule.setApplyThursday(true) if days.include? 'Thu'
+      rule.setApplyFriday(true) if days.include? 'Fri'
+      rule.setApplySaturday(true) if days.include? 'Sat'
+      day_schedule = rule.daySchedule
+      day_schedule.setName("#{sch_ruleset.name} #{data_array[0]}")
+      data_array.delete_at(0)
+      data_array.delete_at(0)
+      data_array.delete_at(0)
+      data_array.each do |data_pair|
+        hour = data_pair[0].truncate
+        min = ((data_pair[0] - hour) * 60).to_i
+        day_schedule.addValue(OpenStudio::Time.new(0, hour, min, 0), data_pair[1])
+      end
+    end
+
+    result = sch_ruleset
+    return result
+  end # end of OsLib_Schedules.createComplexSchedule
+end

data/lib/measures/replace_simple_glazing/measure.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+# see the URL below for information on how to write OpenStudio measures
+# http://nrel.github.io/OpenStudio-user-documentation/reference/measure_writing_guide/
+
+# start the measure
+class ReplaceSimpleGlazing < OpenStudio::Ruleset::ModelUserScript
+  # human readable name
+  def name
+    return 'replace_simple_glazing'
+  end
+
+  # define the arguments that the user will input
+  def arguments(model)
+    args = OpenStudio::Ruleset::OSArgumentVector.new
+
+    # glazing u_value
+    u_value = OpenStudio::Ruleset::OSArgument.makeDoubleArgument('u_value', true)
+    u_value.setDisplayName('U-value in W/(K-m2)')
+    u_value.setDefaultValue(1.65)
+    args << u_value
+
+    # glazing shgc
+    shgc = OpenStudio::Ruleset::OSArgument.makeDoubleArgument('shgc', true)
+    shgc.setDisplayName('shgc')
+    shgc.setDefaultValue(0.20)
+    args << shgc
+
+    # glazing visible transmittance
+    vt = OpenStudio::Ruleset::OSArgument.makeDoubleArgument('vt', true)
+    vt.setDisplayName('vt')
+    vt.setDefaultValue(0.81)
+    args << vt
+
+    return args
+  end
+
+  # define what happens when the measure is run
+  def run(model, runner, user_arguments)
+    super(model, runner, user_arguments)
+
+    # use the built-in error checking
+    if !runner.validateUserArguments(arguments(model), user_arguments)
+      return false
+    end
+
+    # assign the user inputs to variables
+    u_value = runner.getDoubleArgumentValue('u_value', user_arguments)
+    shgc = runner.getDoubleArgumentValue('shgc', user_arguments)
+    vt = runner.getDoubleArgumentValue('vt', user_arguments)
+
+    # replace simple glazing window parameters
+    materials = model.getMaterials
+    materials.each do |material|
+      if material.to_SimpleGlazing.is_initialized
+        material_type_glazingsimple = material.to_SimpleGlazing.get
+
+        # get the original value for reporting
+        u_value_old = nil
+        shgc_old = nil
+        vt_old = nil
+
+        u_value_old = material_type_glazingsimple.uFactor
+        shgc_old = material_type_glazingsimple.solarHeatGainCoefficient
+        vt_old = material_type_glazingsimple.visibleTransmittance
+
+        # set values with user inputs
+        material_type_glazingsimple.setUFactor(u_value)
+        material_type_glazingsimple.setSolarHeatGainCoefficient(shgc)
+        material_type_glazingsimple.setVisibleTransmittance(vt)
+
+        # report initial condition of model
+        runner.registerInitialCondition("The building started with #{u_value_old} U-value, #{shgc_old} SHGC, #{vt_old} Visible Transmittance.")
+
+        # report final condition of model
+        runner.registerFinalCondition("The building finished with #{u_value} U-value, #{shgc} SHGC, #{vt} Visible Transmittance.")
+
+      end
+    end
+
+    return true
+  end
+end
+
+# register the measure to be used by the application
+ReplaceSimpleGlazing.new.registerWithApplication

data/lib/measures/replace_simple_glazing/measure.xml

@@ -0,0 +1,78 @@
+<measure>
+  <schema_version>3.0</schema_version>
+  <name>replace_simple_glazing</name>
+  <uid>3be83df0-8db1-47a8-8b26-aa12f9f17116</uid>
+  <version_id>f181d8cb-18a9-4c8e-b287-a3293633d35e</version_id>
+  <version_modified>20180717T215712Z</version_modified>
+  <xml_checksum>9C8A26EB</xml_checksum>
+  <class_name>ReplaceSimpleGlazing</class_name>
+  <display_name>replace_simple_glazing</display_name>
+  <description></description>
+  <modeler_description></modeler_description>
+  <arguments>
+    <argument>
+      <name>u_value</name>
+      <display_name>U-value in W/(K-m2)</display_name>
+      <type>Double</type>
+      <required>true</required>
+      <model_dependent>false</model_dependent>
+      <default_value>1.65</default_value>
+    </argument>
+    <argument>
+      <name>shgc</name>
+      <display_name>shgc</display_name>
+      <type>Double</type>
+      <required>true</required>
+      <model_dependent>false</model_dependent>
+      <default_value>0.2</default_value>
+    </argument>
+    <argument>
+      <name>vt</name>
+      <display_name>vt</display_name>
+      <type>Double</type>
+      <required>true</required>
+      <model_dependent>false</model_dependent>
+      <default_value>0.81</default_value>
+    </argument>
+  </arguments>
+  <outputs/>
+  <provenances/>
+  <tags>
+    <tag>Envelope.Fenestration</tag>
+  </tags>
+  <attributes>
+    <attribute>
+      <name>Measure Type</name>
+      <value>ModelMeasure</value>
+      <datatype>string</datatype>
+    </attribute>
+    <attribute>
+      <name>Intended Software Tool</name>
+      <value>Apply Measure Now</value>
+      <datatype>string</datatype>
+    </attribute>
+    <attribute>
+      <name>Intended Software Tool</name>
+      <value>OpenStudio Application</value>
+      <datatype>string</datatype>
+    </attribute>
+    <attribute>
+      <name>Intended Software Tool</name>
+      <value>Parametric Analysis Tool</value>
+      <datatype>string</datatype>
+    </attribute>
+  </attributes>
+  <files>
+    <file>
+      <version>
+        <software_program>OpenStudio</software_program>
+        <identifier>2.1.0</identifier>
+        <min_compatible>2.1.0</min_compatible>
+      </version>
+      <filename>measure.rb</filename>
+      <filetype>rb</filetype>
+      <usage_type>script</usage_type>
+      <checksum>95A32DDE</checksum>
+    </file>
+  </files>
+</measure>