openstudio-ee 0.2.0 → 0.2.1

data/lib/measures/add_apszhp_to_each_zone/measure.xml

@@ -0,0 +1,184 @@
+<measure>
+  <schema_version>3.0</schema_version>
+  <name>add_apszhp_to_each_zone</name>
+  <uid>2d81d612-3235-429f-ba0a-46b8bf3b4e92</uid>
+  <version_id>10d37243-c94f-4542-934f-3953c44f75f3</version_id>
+  <version_modified>20180223T005547Z</version_modified>
+  <xml_checksum>87BA8B1E</xml_checksum>
+  <class_name>AddAPSZHPToEachZone</class_name>
+  <display_name>Add a PSZ-HP to each zone</display_name>
+  <description>This will add a Rooftop Packaged Single Zone Heat Pump (RTU with DX cooling and DX heating coils) to each zone of the model.</description>
+  <modeler_description>Add a System 4 - PSZ-HP - unit for each zone. This is a single zone system.
+Parameters:
+- Double: COP cooling and COP heating (Double)
+- Boolean: supplementary electric heating coil (Boolean)
+- Pressure rise (Optional Double)
+- Deletion of existing HVAC equipment (Boolean)
+- DCV enabled or not (Boolean)
+- Fan type: Variable Volume Fan (VFD) or not (Constant Volume) (Choice)
+- Filter for the zone name (String): only zones that contains the string you input in filter will receive this system.</modeler_description>
+  <arguments>
+    <argument>
+      <name>delete_existing</name>
+      <display_name>Delete any existing HVAC equipment?</display_name>
+      <type>Boolean</type>
+      <required>true</required>
+      <model_dependent>false</model_dependent>
+      <choices>
+        <choice>
+          <value>true</value>
+          <display_name>true</display_name>
+        </choice>
+        <choice>
+          <value>false</value>
+          <display_name>false</display_name>
+        </choice>
+      </choices>
+    </argument>
+    <argument>
+      <name>cop_cooling</name>
+      <display_name>COP Cooling (SI)</display_name>
+      <type>Double</type>
+      <required>true</required>
+      <model_dependent>false</model_dependent>
+      <default_value>3.1</default_value>
+    </argument>
+    <argument>
+      <name>cop_heating</name>
+      <display_name>COP Heating (SI)</display_name>
+      <type>Double</type>
+      <required>true</required>
+      <model_dependent>false</model_dependent>
+      <default_value>3.1</default_value>
+    </argument>
+    <argument>
+      <name>has_electric_coil</name>
+      <display_name>Include supplementary electric heating coils?</display_name>
+      <type>Boolean</type>
+      <required>false</required>
+      <model_dependent>false</model_dependent>
+      <default_value>true</default_value>
+      <choices>
+        <choice>
+          <value>true</value>
+          <display_name>true</display_name>
+        </choice>
+        <choice>
+          <value>false</value>
+          <display_name>false</display_name>
+        </choice>
+      </choices>
+    </argument>
+    <argument>
+      <name>has_dcv</name>
+      <display_name>Enable Demand Controlled Ventilation?</display_name>
+      <type>Boolean</type>
+      <required>false</required>
+      <model_dependent>false</model_dependent>
+      <default_value>false</default_value>
+      <choices>
+        <choice>
+          <value>true</value>
+          <display_name>true</display_name>
+        </choice>
+        <choice>
+          <value>false</value>
+          <display_name>false</display_name>
+        </choice>
+      </choices>
+    </argument>
+    <argument>
+      <name>fan_type</name>
+      <display_name>Select fan type:</display_name>
+      <type>Choice</type>
+      <required>true</required>
+      <model_dependent>false</model_dependent>
+      <choices>
+        <choice>
+          <value>Constant Volume (default)</value>
+          <display_name>Constant Volume (default)</display_name>
+        </choice>
+        <choice>
+          <value>Variable Volume (VFD)</value>
+          <display_name>Variable Volume (VFD)</display_name>
+        </choice>
+      </choices>
+    </argument>
+    <argument>
+      <name>fan_pressure_rise</name>
+      <display_name>Fan Pressure Rise (Pa)</display_name>
+      <description>Leave blank for default value</description>
+      <type>Double</type>
+      <required>false</required>
+      <model_dependent>false</model_dependent>
+    </argument>
+    <argument>
+      <name>filter_type</name>
+      <display_name>How do you want to choose the affected zones?</display_name>
+      <type>Choice</type>
+      <required>true</required>
+      <model_dependent>false</model_dependent>
+      <choices>
+        <choice>
+          <value>By Space Type</value>
+          <display_name>By Space Type</display_name>
+        </choice>
+        <choice>
+          <value>By Space Type's 'Standards Space Type'</value>
+          <display_name>By Space Type's 'Standards Space Type'</display_name>
+        </choice>
+        <choice>
+          <value>By Zone Filter</value>
+          <display_name>By Zone Filter</display_name>
+        </choice>
+      </choices>
+    </argument>
+    <argument>
+      <name>space_type</name>
+      <display_name>a. Which Space Type?</display_name>
+      <type>Choice</type>
+      <required>false</required>
+      <model_dependent>false</model_dependent>
+    </argument>
+    <argument>
+      <name>standards_space_type</name>
+      <display_name>b. Which Standards Space Type</display_name>
+      <type>Choice</type>
+      <required>false</required>
+      <model_dependent>false</model_dependent>
+    </argument>
+    <argument>
+      <name>zone_filter</name>
+      <display_name>c. Only Apply to Zones that contain the following string</display_name>
+      <description>Case insensitive. For example, type 'retail' to apply to zones that have the word 'retail' or 'REtaiL' in their name. Leave blank to apply to all zones</description>
+      <type>String</type>
+      <required>false</required>
+      <model_dependent>false</model_dependent>
+    </argument>
+  </arguments>
+  <outputs/>
+  <provenances/>
+  <tags>
+    <tag>HVAC.Whole System</tag>
+  </tags>
+  <attributes>
+    <attribute>
+      <name>Uses SketchUp API</name>
+      <value>false</value>
+      <datatype>boolean</datatype>
+    </attribute>
+    <attribute>
+      <name>Measure Type</name>
+      <value>ModelMeasure</value>
+      <datatype>string</datatype>
+    </attribute>
+  </attributes>
+  <files>
+    <file>
+      <filename>measure.rb</filename>
+      <filetype>rb</filetype>
+      <usage_type></usage_type>
+      <checksum>E46EE4C8</checksum>
+    </file>
+  </files>
+</measure>

data/lib/measures/add_energy_recovery_ventilator/measure.rb

@@ -0,0 +1,354 @@
+# frozen_string_literal: true
+
+# see the URL below for information on how to write OpenStudio measures
+# http://openstudio.nrel.gov/openstudio-measure-writing-guide
+
+# see the URL below for access to C++ documentation on model objects (click on "model" in the main window to view model objects)
+# http://openstudio.nrel.gov/sites/openstudio.nrel.gov/files/nv_data/cpp_documentation_it/model/html/namespaces.html
+
+# start the measure
+class AddEnergyRecoveryVentilator < OpenStudio::Ruleset::ModelUserScript
+  # define the name that a user will see, this method may be deprecated as
+  # the display name in PAT comes from the name field in measure.xml
+  def name
+    return 'AddEnergyRecoveryVentilator'
+  end
+
+  # define the arguments that the user will input
+  # define the arguments that the user will input
+  # define the arguments that the user will input
+  def arguments(model)
+    args = OpenStudio::Ruleset::OSArgumentVector.new
+
+    # Determine how many air loops in model
+    air_loop_handles = OpenStudio::StringVector.new
+    air_loop_display_names = OpenStudio::StringVector.new
+
+    # Get/show all unitary air conditioners from current loaded model.
+    air_loop_handles << '0'
+    air_loop_display_names << '*All air loops*'
+
+    i_air_loop = 1
+    model.getAirLoopHVACs.each do |air_loop|
+      air_loop_handles << i_air_loop.to_s
+      air_loop_display_names << air_loop.name.to_s
+
+      i_air_loop += 1
+    end
+
+    if i_air_loop == 1
+      info_widget = OpenStudio::Ruleset::OSArgument.makeBoolArgument('info_widget', true)
+      info_widget.setDisplayName('!!!!*** This Measure is not Applicable to loaded Model. Read the description and choose an appropriate baseline model. ***!!!!')
+      info_widget.setDefaultValue(true)
+      args << info_widget
+      return args
+    end
+
+    air_loop_widget = OpenStudio::Ruleset::OSArgument.makeChoiceArgument('air_loop_widget', air_loop_handles, air_loop_display_names, true)
+    air_loop_widget.setDisplayName('Apply the measure to ')
+    air_loop_widget.setDefaultValue(air_loop_display_names[0])
+    args << air_loop_widget
+
+    # Sensible Effectiveness at 100% Heating Air Flow (default of 0.76)
+    sensible_eff_at_100_heating = OpenStudio::Ruleset::OSArgument.makeDoubleArgument('sensible_eff_at_100_heating', false)
+    sensible_eff_at_100_heating.setDisplayName('Sensible Effectiveness at 100% Heating Air Flow')
+    sensible_eff_at_100_heating.setDefaultValue(0.76)
+    args << sensible_eff_at_100_heating
+
+    # Latent Effectiveness at 100% Heating Air Flow (default of 0.76)
+    latent_eff_at_100_heating = OpenStudio::Ruleset::OSArgument.makeDoubleArgument('latent_eff_at_100_heating', false)
+    latent_eff_at_100_heating.setDisplayName('Latent Effectiveness at 100% Heating Air Flow')
+    latent_eff_at_100_heating.setDefaultValue(0.68)
+    args << latent_eff_at_100_heating
+
+    # Sensible Effectiveness at 75% Heating Air Flow (default of 0.76)
+    sensible_eff_at_75_heating = OpenStudio::Ruleset::OSArgument.makeDoubleArgument('sensible_eff_at_75_heating', false)
+    sensible_eff_at_75_heating.setDisplayName('Sensible Effectiveness at 75% Heating Air Flow')
+    sensible_eff_at_75_heating.setDefaultValue(0.81)
+    args << sensible_eff_at_75_heating
+
+    # Latent Effectiveness at 100% Heating Air Flow (default of 0.76)
+    latent_eff_at_75_heating = OpenStudio::Ruleset::OSArgument.makeDoubleArgument('latent_eff_at_75_heating', false)
+    latent_eff_at_75_heating.setDisplayName('Latent Effectiveness at 75% Heating Air Flow')
+    latent_eff_at_75_heating.setDefaultValue(0.73)
+    args << latent_eff_at_75_heating
+
+    # Sensible Effectiveness at 100% Cooling Air Flow (default of 0.76)
+    sensible_eff_at_100_cooling = OpenStudio::Ruleset::OSArgument.makeDoubleArgument('sensible_eff_at_100_cooling', false)
+    sensible_eff_at_100_cooling.setDisplayName('Sensible Effectiveness at 100% Cooling Air Flow')
+    sensible_eff_at_100_cooling.setDefaultValue(0.76)
+    args << sensible_eff_at_100_cooling
+
+    # Latent Effectiveness at 100% Cooling Air Flow (default of 0.76)
+    latent_eff_at_100_cooling = OpenStudio::Ruleset::OSArgument.makeDoubleArgument('latent_eff_at_100_cooling', false)
+    latent_eff_at_100_cooling.setDisplayName('Latent Effectiveness at 100% Cooling Air Flow')
+    latent_eff_at_100_cooling.setDefaultValue(0.68)
+    args << latent_eff_at_100_cooling
+
+    # Sensible Effectiveness at 75% Cooling Air Flow (default of 0.76)
+    sensible_eff_at_75_cooling = OpenStudio::Ruleset::OSArgument.makeDoubleArgument('sensible_eff_at_75_cooling', false)
+    sensible_eff_at_75_cooling.setDisplayName('Sensible Effectiveness at 75% Cooling Air Flow')
+    sensible_eff_at_75_cooling.setDefaultValue(0.81)
+    args << sensible_eff_at_75_cooling
+
+    # Latent Effectiveness at 100% Cooling Air Flow (default of 0.76)
+    latent_eff_at_75_cooling = OpenStudio::Ruleset::OSArgument.makeDoubleArgument('latent_eff_at_75_cooling', false)
+    latent_eff_at_75_cooling.setDisplayName('Latent Effectiveness at 75% Cooling Air Flow')
+    latent_eff_at_75_cooling.setDefaultValue(0.73)
+    args << latent_eff_at_75_cooling
+
+    # Show ASHRAE standards
+    heat_exchanger_type_handles = OpenStudio::StringVector.new
+    heat_exchanger_type_display_names = OpenStudio::StringVector.new
+
+    heat_exchanger_type_handles << '0'
+    heat_exchanger_type_display_names << 'Rotary'
+
+    heat_exchanger_type_widget = OpenStudio::Ruleset::OSArgument.makeChoiceArgument('heat_exchanger_type_widget', heat_exchanger_type_handles, heat_exchanger_type_display_names, true)
+    heat_exchanger_type_widget.setDisplayName('Heat Exchanger Type.')
+    heat_exchanger_type_widget.setDefaultValue(heat_exchanger_type_display_names[0])
+    args << heat_exchanger_type_widget
+
+    # Nominal electric power [W] (Note: this is optional. If no value is entered, do nothing)
+    nominal_electric_power = OpenStudio::Ruleset::OSArgument.makeDoubleArgument('nominal_electric_power', false)
+    nominal_electric_power.setDisplayName('Nominal electric power [W]')
+    args << nominal_electric_power
+
+    return args
+  end # end the arguments method
+
+  def reportValueChangeInfo(value_old, value_new, value_name, airloop_name, runner)
+    if value_old.nil?
+      runner.registerInfo("Initial: The #{value_name} on #{airloop_name} was not set.")
+    else
+      runner.registerInfo("Initial: The #{value_name} on #{airloop_name} was #{value_old}.")
+    end
+    runner.registerInfo("Final: The #{value_name} on #{airloop_name} was set to be #{value_new}.")
+    return
+  end
+
+  def setSensibleEffectiveness100Cooling(erv, value_new, airloop_name, runner)
+    value_old = erv.getSensibleEffectivenessat100CoolingAirFlow
+    erv.setSensibleEffectivenessat100CoolingAirFlow(value_new)
+    reportValueChangeInfo(value_old, value_new, 'Sensible Effectiveness at 100% Cooling Air Flow', airloop_name, runner)
+    return
+  end
+
+  def setSensibleEffectiveness75Cooling(erv, value_new, airloop_name, runner)
+    value_old = erv.getSensibleEffectivenessat75CoolingAirFlow
+    erv.setSensibleEffectivenessat75CoolingAirFlow(value_new)
+    reportValueChangeInfo(value_old, value_new, 'Sensible Effectiveness at 75% Cooling Air Flow', airloop_name, runner)
+    return
+  end
+
+  def setLatentEffectiveness100Cooling(erv, value_new, airloop_name, runner)
+    value_old = erv.getLatentEffectivenessat100CoolingAirFlow
+    erv.setLatentEffectivenessat100CoolingAirFlow(value_new)
+    reportValueChangeInfo(value_old, value_new, 'Latent Effectiveness at 100% Cooling Air Flow', airloop_name, runner)
+    return
+  end
+
+  def setLatentEffectiveness75Cooling(erv, value_new, airloop_name, runner)
+    value_old = erv.getLatentEffectivenessat75CoolingAirFlow
+    erv.setLatentEffectivenessat75CoolingAirFlow(value_new)
+    reportValueChangeInfo(value_old, value_new, 'Latent Effectiveness at 75% Cooling Air Flow', airloop_name, runner)
+    return
+  end
+
+  def setSensibleEffectiveness100Heating(erv, value_new, airloop_name, runner)
+    value_old = erv.getSensibleEffectivenessat100HeatingAirFlow
+    erv.setSensibleEffectivenessat100HeatingAirFlow(value_new)
+    reportValueChangeInfo(value_old, value_new, 'Sensible Effectiveness at 100% Heating Air Flow', airloop_name, runner)
+    return
+  end
+
+  def setSensibleEffectiveness75Heating(erv, value_new, airloop_name, runner)
+    value_old = erv.getSensibleEffectivenessat75HeatingAirFlow
+    erv.setSensibleEffectivenessat75HeatingAirFlow(value_new)
+    reportValueChangeInfo(value_old, value_new, 'Sensible Effectiveness at 75% Heating Air Flow', airloop_name, runner)
+    return
+  end
+
+  def setLatentEffectiveness100Heating(erv, value_new, airloop_name, runner)
+    value_old = erv.getLatentEffectivenessat100HeatingAirFlow
+    erv.setLatentEffectivenessat100HeatingAirFlow(value_new)
+    reportValueChangeInfo(value_old, value_new, 'Latent Effectiveness at 100% Heating Air Flow', airloop_name, runner)
+    return
+  end
+
+  def setLatentEffectiveness75Heating(erv, value_new, airloop_name, runner)
+    value_old = erv.getLatentEffectivenessat75HeatingAirFlow
+    erv.setLatentEffectivenessat75HeatingAirFlow(value_new)
+    reportValueChangeInfo(value_old, value_new, 'Latent Effectiveness at 75% Heating Air Flow', airloop_name, runner)
+    return
+  end
+
+  def setNominalElectricPower(erv, value_new, airloop_name, runner)
+    value_old = erv.getNominalElectricPower
+    erv.setNominalElectricPower(value_new)
+    reportValueChangeInfo(value_old, value_new, 'Nominal electric power', airloop_name, runner)
+    return
+  end
+
+  def isOutOfRange(value_new, value_name, runner)
+    if (value_new < 0) || (value_new > 1)
+      runner.registerError("OutOfBound! The #{value_name} must be between 0 and 1. Reset the value.")
+      return true
+    end
+    return false
+  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
+
+    # Determine if the measure is applicable to the model, if not just return and no changes are made.
+    info_widget = runner.getOptionalWorkspaceObjectChoiceValue('info_widget', user_arguments, model)
+    if !(info_widget.nil? || info_widget.empty?)
+      runner.registerInfo('This measure is not applicable.')
+      return true
+    end
+
+    air_loop_widget = runner.getOptionalWorkspaceObjectChoiceValue('air_loop_widget', user_arguments, model)
+    handle = runner.getStringArgumentValue('air_loop_widget', user_arguments)
+    air_loop_index = handle.to_i
+
+    sensible_eff_at_100_heating = runner.getDoubleArgumentValue('sensible_eff_at_100_heating', user_arguments)
+    latent_eff_at_100_heating = runner.getDoubleArgumentValue('latent_eff_at_100_heating', user_arguments)
+    sensible_eff_at_75_heating = runner.getDoubleArgumentValue('sensible_eff_at_75_heating', user_arguments)
+    latent_eff_at_75_heating = runner.getDoubleArgumentValue('latent_eff_at_75_heating', user_arguments)
+
+    sensible_eff_at_100_cooling = runner.getDoubleArgumentValue('sensible_eff_at_100_cooling', user_arguments)
+    latent_eff_at_100_cooling = runner.getDoubleArgumentValue('latent_eff_at_100_cooling', user_arguments)
+    sensible_eff_at_75_cooling = runner.getDoubleArgumentValue('sensible_eff_at_75_cooling', user_arguments)
+    latent_eff_at_75_cooling = runner.getDoubleArgumentValue('latent_eff_at_75_cooling', user_arguments)
+
+    if isOutOfRange(sensible_eff_at_100_heating, 'sensible_eff_at_100_heating', runner)
+      return false
+    end
+    if isOutOfRange(latent_eff_at_100_heating, 'latent_eff_at_100_heating', runner)
+      return false
+    end
+    if isOutOfRange(sensible_eff_at_75_heating, 'sensible_eff_at_75_heating', runner)
+      return false
+    end
+    if isOutOfRange(latent_eff_at_75_heating, 'latent_eff_at_75_heating', runner)
+      return false
+    end
+    if isOutOfRange(sensible_eff_at_100_cooling, 'sensible_eff_at_100_cooling', runner)
+      return false
+    end
+    if isOutOfRange(latent_eff_at_100_cooling, 'latent_eff_at_100_cooling', runner)
+      return false
+    end
+    if isOutOfRange(sensible_eff_at_75_cooling, 'sensible_eff_at_75_cooling', runner)
+      return false
+    end
+    if isOutOfRange(latent_eff_at_75_cooling, 'latent_eff_at_75_cooling', runner)
+      return false
+    end
+
+    heat_exchanger_type_widget = runner.getOptionalWorkspaceObjectChoiceValue('heat_exchanger_type_widget', user_arguments, model)
+    handle = runner.getStringArgumentValue('heat_exchanger_type_widget', user_arguments)
+    heat_exchanger_type_index = handle.to_i
+
+    heat_exchanger_type_list = ['Rotary']
+    heat_type = heat_exchanger_type_list[heat_exchanger_type_index]
+
+    nominal_electric_power = runner.getOptionalDoubleArgumentValue('nominal_electric_power', user_arguments)
+    if nominal_electric_power.empty?
+      nominal_electric_power = nil
+    else
+      nominal_electric_power = runner.getDoubleArgumentValue('nominal_electric_power', user_arguments)
+    end
+
+    # loop through all air loops
+    i_air_loop = 0
+    model.getAirLoopHVACs.each do |air_loop|
+      # check if the airloop already has an ERV either on a specified air loop or all air loops
+      i_air_loop += 1
+      if (air_loop_index != 0) && (air_loop_index != i_air_loop)
+        next
+      end
+
+      has_ERV = false
+      air_loop.supplyComponents.each do |supply_component|
+        # check if the supply component is an ERV
+        if !supply_component.to_HeatExchangerAirToAirSensibleAndLatent.empty?
+          has_ERV = true
+          erv = supply_component.to_HeatExchangerAirToAirSensibleAndLatent.get
+          erv.setHeatExchangerType(heat_type)
+          setSensibleEffectiveness100Cooling(erv, sensible_eff_at_100_cooling, air_loop.name, runner)
+          setSensibleEffectiveness75Cooling(erv, sensible_eff_at_75_cooling, air_loop.name, runner)
+          setLatentEffectiveness100Cooling(erv, latent_eff_at_100_cooling, air_loop.name, runner)
+          setLatentEffectiveness75Cooling(erv, latent_eff_at_75_cooling, air_loop.name, runner)
+
+          setSensibleEffectiveness100Heating(erv, sensible_eff_at_100_heating, air_loop.name, runner)
+          setSensibleEffectiveness75Heating(erv, sensible_eff_at_75_heating, air_loop.name, runner)
+          setLatentEffectiveness100Heating(erv, latent_eff_at_100_heating, air_loop.name, runner)
+          setLatentEffectiveness75Heating(erv, latent_eff_at_75_heating, air_loop.name, runner)
+
+          # erv.setEconomizerLockout('Yes')
+          # erv.setEconomizerLockout(true)
+          erv.setString(23, 'Yes')
+
+          # erv.setSupplyAirOutletTemperatureControl ('No')
+          # erv.setSupplyAirOutletTemperatureControl (false)
+          erv.setString(17, 'No')
+          if !nominal_electric_power.nil?
+            setNominalElectricPower(erv, nominal_electric_power, air_loop.name, runner)
+          end
+         end
+      end
+      air_loop.supplyComponents.each do |supply_component|
+        # if no ERV was found, see if the air loop has an outdoor air system
+        if has_ERV == false
+          if !supply_component.to_AirLoopHVACOutdoorAirSystem.empty?
+            # get the outdoor air system
+            oa_system = supply_component.to_AirLoopHVACOutdoorAirSystem.get
+            # create a new heat exchanger and add it to the outdoor air system
+            erv = OpenStudio::Model::HeatExchangerAirToAirSensibleAndLatent.new(model)
+            oa_node = oa_system.outboardOANode
+            if !oa_node.empty?
+              # set node connection
+              erv.addToNode(oa_node.get)
+              # set required fields to a single default value
+              erv.setHeatExchangerType(heat_type)
+              setSensibleEffectiveness100Cooling(erv, sensible_eff_at_100_cooling, air_loop.name, runner)
+              setSensibleEffectiveness75Cooling(erv, sensible_eff_at_75_cooling, air_loop.name, runner)
+              setLatentEffectiveness100Cooling(erv, latent_eff_at_100_cooling, air_loop.name, runner)
+              setLatentEffectiveness75Cooling(erv, latent_eff_at_75_cooling, air_loop.name, runner)
+
+              setSensibleEffectiveness100Heating(erv, sensible_eff_at_100_heating, air_loop.name, runner)
+              setSensibleEffectiveness75Heating(erv, sensible_eff_at_75_heating, air_loop.name, runner)
+              setLatentEffectiveness100Heating(erv, latent_eff_at_100_heating, air_loop.name, runner)
+              setLatentEffectiveness75Heating(erv, latent_eff_at_75_heating, air_loop.name, runner)
+
+              # Temporary solution, may need to fix later. 12/22/2013 Da
+              # erv.setEconomizerLockout('Yes')
+              # erv.setEconomizerLockout(true)
+              erv.setString(23, 'Yes')
+
+              # erv.setSupplyAirOutletTemperatureControl ('No')
+              # erv.setSupplyAirOutletTemperatureControl (false)
+              erv.setString(17, 'No')
+
+              if !nominal_electric_power.nil?
+                setNominalElectricPower(erv, nominal_electric_power, air_loop.name, runner)
+              end
+            end
+          end
+         end
+      end
+    end
+    return true
+  end # end the run method
+end # end the measure
+
+# this allows the measure to be use by the application
+AddEnergyRecoveryVentilator.new.registerWithApplication