openstudio-ee 0.2.1 → 0.3.0

data/lib/measures/ReplaceFanTotalEfficiency/measure.xml

@@ -1,150 +0,0 @@
-<measure>
-  <schema_version>3.0</schema_version>
-  <name>replace_fan_total_efficiency</name>
-  <uid>ebeca0aa-a432-4283-a714-17116f7c8f8c</uid>
-  <version_id>348976a4-526f-4a56-b819-74c78f8a07e3</version_id>
-  <version_modified>20190212T002510Z</version_modified>
-  <xml_checksum>F78494F2</xml_checksum>
-  <class_name>ReplaceFanTotalEfficiency</class_name>
-  <display_name>Replace Fan Total Efficiency</display_name>
-  <description></description>
-  <modeler_description></modeler_description>
-  <arguments>
-    <argument>
-      <name>object</name>
-      <display_name>Choose an Air Loop to Alter.</display_name>
-      <type>Choice</type>
-      <required>true</required>
-      <model_dependent>false</model_dependent>
-      <default_value>*All Air Loops*</default_value>
-      <choices>
-        <choice>
-          <value>{7d3f0300-6b06-458a-ad5e-0d5d7ec180cc}</value>
-          <display_name>*All Air Loops*</display_name>
-        </choice>
-      </choices>
-    </argument>
-    <argument>
-      <name>motor_eff</name>
-      <display_name>Fan Total Efficiency Replacement in %</display_name>
-      <type>Double</type>
-      <required>true</required>
-      <model_dependent>false</model_dependent>
-      <default_value>70</default_value>
-    </argument>
-    <argument>
-      <name>remove_costs</name>
-      <display_name>Remove Baseline Costs From Effected Fans?</display_name>
-      <type>Boolean</type>
-      <required>true</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>material_cost</name>
-      <display_name>Material and Installation Costs per Motor ($).</display_name>
-      <type>Double</type>
-      <required>true</required>
-      <model_dependent>false</model_dependent>
-      <default_value>0</default_value>
-    </argument>
-    <argument>
-      <name>demolition_cost</name>
-      <display_name>Demolition Costs per Motor ($).</display_name>
-      <type>Double</type>
-      <required>true</required>
-      <model_dependent>false</model_dependent>
-      <default_value>0</default_value>
-    </argument>
-    <argument>
-      <name>years_until_costs_start</name>
-      <display_name>Years Until Costs Start (whole years).</display_name>
-      <type>Integer</type>
-      <required>true</required>
-      <model_dependent>false</model_dependent>
-      <default_value>0</default_value>
-    </argument>
-    <argument>
-      <name>demo_cost_initial_const</name>
-      <display_name>Demolition Costs Occur During Initial Construction?</display_name>
-      <type>Boolean</type>
-      <required>true</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>expected_life</name>
-      <display_name>Expected Life (whole years).</display_name>
-      <type>Integer</type>
-      <required>true</required>
-      <model_dependent>false</model_dependent>
-      <default_value>20</default_value>
-    </argument>
-    <argument>
-      <name>om_cost</name>
-      <display_name>O &amp; M Costs per Motor ($).</display_name>
-      <type>Double</type>
-      <required>true</required>
-      <model_dependent>false</model_dependent>
-      <default_value>0</default_value>
-    </argument>
-    <argument>
-      <name>om_frequency</name>
-      <display_name>O &amp; M Frequency (whole years).</display_name>
-      <type>Integer</type>
-      <required>true</required>
-      <model_dependent>false</model_dependent>
-      <default_value>1</default_value>
-    </argument>
-  </arguments>
-  <outputs/>
-  <provenances/>
-  <tags>
-    <tag>HVAC.Distribution</tag>
-  </tags>
-  <attributes>
-    <attribute>
-      <name>Measure Type</name>
-      <value>ModelMeasure</value>
-      <datatype>string</datatype>
-    </attribute>
-    <attribute>
-      <name>Uses SketchUp API</name>
-      <value>false</value>
-      <datatype>boolean</datatype>
-    </attribute>
-  </attributes>
-  <files>
-    <file>
-      <version>
-        <software_program>OpenStudio</software_program>
-        <identifier>1.0.3</identifier>
-        <min_compatible>1.0.3</min_compatible>
-      </version>
-      <filename>measure.rb</filename>
-      <filetype>rb</filetype>
-      <usage_type>script</usage_type>
-      <checksum>FCCFD3DA</checksum>
-    </file>
-  </files>
-</measure>

data/lib/measures/add_apszhp_to_each_zone/measure.rb

@@ -1,607 +0,0 @@
-# frozen_string_literal: true
-
-# Author: Julien Marrec
-# email: julien.marrec@gmail.com
-
-# start the measure
-class AddAPSZHPToEachZone < 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 'Add a PSZ-HP to each zone'
-  end
-
-  def description
-    return 'This will add a Rooftop Packaged Single Zone Heat Pump (RTU with DX cooling and DX heating coils) to each zone of the model.'
-  end
-
-  def modeler_description
-    return "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."
-  end
-
-  # define the arguments that the user will input
-  def arguments(model)
-    args = OpenStudio::Ruleset::OSArgumentVector.new
-
-    delete_existing = OpenStudio::Ruleset::OSArgument.makeBoolArgument('delete_existing', true)
-    delete_existing.setDisplayName('Delete any existing HVAC equipment?')
-    args << delete_existing
-
-    cop_cooling = OpenStudio::Ruleset::OSArgument.makeDoubleArgument('cop_cooling', true)
-    cop_cooling.setDisplayName('COP Cooling (SI)')
-    cop_cooling.setDefaultValue(3.1)
-    args << cop_cooling
-
-    cop_heating = OpenStudio::Ruleset::OSArgument.makeDoubleArgument('cop_heating', true)
-    cop_heating.setDisplayName('COP Heating (SI)')
-    cop_heating.setDefaultValue(3.1)
-    args << cop_heating
-
-    has_electric_coil = OpenStudio::Ruleset::OSArgument.makeBoolArgument('has_electric_coil', false)
-    has_electric_coil.setDisplayName('Include supplementary electric heating coils?')
-    has_electric_coil.setDefaultValue(true)
-    args << has_electric_coil
-
-    has_dcv = OpenStudio::Ruleset::OSArgument.makeBoolArgument('has_dcv', false)
-    has_dcv.setDisplayName('Enable Demand Controlled Ventilation?')
-    has_dcv.setDefaultValue(false)
-    args << has_dcv
-
-    chs = OpenStudio::StringVector.new
-    chs << 'Constant Volume (default)'
-    chs << 'Variable Volume (VFD)'
-    fan_type = OpenStudio::Ruleset::OSArgument.makeChoiceArgument('fan_type', chs, true)
-    fan_type.setDisplayName('Select fan type:')
-    args << fan_type
-
-    fan_pressure_rise = OpenStudio::Ruleset::OSArgument.makeDoubleArgument('fan_pressure_rise', false)
-    fan_pressure_rise.setDisplayName('Fan Pressure Rise (Pa)')
-    fan_pressure_rise.setDescription('Leave blank for default value')
-    # fan_pressure_rise.setDefaultValue(0)
-    args << fan_pressure_rise
-
-    chs = OpenStudio::StringVector.new
-    chs << 'By Space Type'
-    chs << "By Space Type's 'Standards Space Type'"
-    chs << 'By Zone Filter'
-    filter_type = OpenStudio::Ruleset::OSArgument.makeChoiceArgument('filter_type', chs, true)
-    filter_type.setDisplayName('How do you want to choose the affected zones?')
-    args << filter_type
-
-    # create an argument for a space type to be used in the model. Only return those that are used
-    spaceTypes = model.getSpaceTypes
-    usedSpaceTypes_handle = OpenStudio::StringVector.new
-    usedSpaceTypes_displayName = OpenStudio::StringVector.new
-
-    # Should normally be an OpenStudio::StringVector.new but it doesn't have a uniq! method and it works with a regular hash..
-    standardsSpaceType = []
-
-    spaceTypes.each do |spaceType|
-      if !spaceType.spaces.empty? # only show space types used in the building
-        usedSpaceTypes_handle << spaceType.handle.to_s
-        usedSpaceTypes_displayName << spaceType.name.to_s
-
-        if !spaceType.standardsSpaceType.empty?
-          standardsSpaceType << spaceType.standardsSpaceType.get
-        end
-      end
-    end
-
-    # make an argument for space type
-    space_type = OpenStudio::Ruleset::OSArgument.makeChoiceArgument('space_type', usedSpaceTypes_handle, usedSpaceTypes_displayName, false)
-    space_type.setDisplayName('a. Which Space Type?')
-    args << space_type
-
-    # Argument for Standards Space Type
-
-    # First, make it unique
-    standardsSpaceType.uniq!
-    standards_space_type = OpenStudio::Ruleset::OSArgument.makeChoiceArgument('standards_space_type', standardsSpaceType, false)
-    standards_space_type.setDisplayName('b. Which Standards Space Type')
-    args << standards_space_type
-
-    zone_filter = OpenStudio::Ruleset::OSArgument.makeStringArgument('zone_filter', false)
-    zone_filter.setDisplayName('c. Only Apply to Zones that contain the following string')
-    zone_filter.setDescription("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")
-    args << zone_filter
-
-    return args
-  end # end the arguments method
-
-  # 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
-
-    # Retrieve arguments' values
-    delete_existing = runner.getBoolArgumentValue('delete_existing', user_arguments)
-    cop_cooling = runner.getDoubleArgumentValue('cop_cooling', user_arguments)
-    cop_heating = runner.getDoubleArgumentValue('cop_heating', user_arguments)
-    has_electric_coil = runner.getBoolArgumentValue('has_electric_coil', user_arguments)
-    has_dcv = runner.getBoolArgumentValue('has_dcv', user_arguments)
-
-    # Get fan_pressure_rise: this is an OptionalDouble - we'll use '.get' later
-    fan_pressure_rise = runner.getOptionalDoubleArgumentValue('fan_pressure_rise', user_arguments)
-
-    # FanType
-    fan_type = runner.getStringArgumentValue('fan_type', user_arguments)
-    runner.registerInfo("Fan type: #{fan_type}")
-
-    if fan_type == 'Variable Volume (VFD)'
-      has_vfd = true
-    else
-      has_vfd = false
-    end
-
-    filter_type = runner.getStringArgumentValue('filter_type', user_arguments)
-
-    if filter_type == 'By Space Type'
-      space_type = runner.getOptionalWorkspaceObjectChoiceValue('space_type', user_arguments, model)
-      if !space_type.empty?
-        space_type = space_type.get
-        if !space_type.to_SpaceType.empty?
-          space_type = space_type.to_SpaceType.get
-          zones = []
-          space_type.spaces.each do |space|
-            if !space.thermalZone.empty?
-              z = space.thermalZone.get
-              zones << z
-            end
-          end
-        end
-      end
-
-    elsif filter_type == "By Space Type's 'Standards Space Type'"
-
-      standards_space_type = runner.getOptionalStringArgumentValue('standards_space_type', user_arguments)
-      puts standards_space_type.class
-
-      if !standards_space_type.empty?
-        standards_space_type = standards_space_type.get
-        puts standards_space_type
-        space_types = model.getSpaceTypes
-
-        zones = []
-
-        space_types.each do |space_type|
-          if space_type.standardsSpaceType.to_s.casecmp(standards_space_type).zero?
-            space_type.spaces.each do |space|
-              if !space.thermalZone.empty?
-                z = space.thermalZone.get
-                # We MUST check if zone isn't in there yet (or at the end do zones.uniq!) because several spaces can refer to the same thermal zone!
-                if !zones.include?(z)
-                  zones << z
-                end
-              end
-            end
-          end
-        end
-      end
-
-    else
-      # Zone filter
-      zone_filter = runner.getOptionalStringArgumentValue('zone_filter', user_arguments)
-
-      # Get all thermal zones
-      all_zones = model.getThermalZones
-
-      # Array to store the zones that match the filter
-      zones = []
-      all_zones.each do |z|
-        # Skip zone if name doesn't include zone_filter
-        # Putting everything in Upper Case to make it case insensitive
-        if !zone_filter.empty?
-          if z.name.to_s.upcase.include? zone_filter.to_s.upcase
-            zones << z
-          end
-        end
-      end
-
-      if zones.empty?
-        runner.registerError("Your zone filter #{zone_filter} did not match anything")
-        return false
-      end
-
-    end # End of if filter_type
-
-    # Output zone names to console
-    puts "\n\n================ ZONES THAT MATCHED THE FILTER ================\n"
-    zones.each do |z|
-      puts z.name
-    end
-
-    # info for initial condition
-    initial_num_air_loops_demand_control = 0
-    final_num_air_loops_demand_control = 0
-    initial_num_fan_VFD = 0
-    final_num_fan_VFD = 0
-    delete_existing_air_loops = 0
-    delete_existing_chiller_loops = 0
-    delete_existing_condenser_loops = 0
-    affected_loops = 0
-
-    # If we need to delete existing HVAC loops, we'll store the PRE-EXISTING Loops in the following variables,
-    # They will be used for clean up at the end
-    if delete_existing
-      air_loops = model.getAirLoopHVACs
-      runner.registerInfo("Number of initial AirLoopHVACs: #{air_loops.size}")
-      plant_loops = model.getPlantLoops
-      runner.registerInfo("Number of initial PlantLoops: #{plant_loops.size}")
-    end
-
-    # For each thermal zones (zones is initialized above, depending on which filter you chose)
-    zones.each do |z|
-      # Create a system 4 (PSZ-HP)
-      air_handler = OpenStudio::Model.addSystemType4(model).to_AirLoopHVAC.get
-
-      # Set name of Air Loop to be thermal_zone + 'Airloop'
-      # Local variable name convention for a non-constant (dynamic) value is 'snake_case'
-      base_name = z.name.to_s
-      air_handler.setName(base_name + ' AirLoop')
-
-      # Get existing fan, created with System 4, constant volume by default
-      old_fan = air_handler.supplyComponents(OpenStudio::Model::FanConstantVolume.iddObjectType).first
-      old_fan = old_fan.to_FanConstantVolume.get
-
-      # If you want a VFD, we replace it with a Variable Volume one
-      if has_vfd
-
-        # Get the outlet node after the existing fan on the loop
-        next_node = old_fan.outletModelObject.get.to_Node.get
-
-        # Create the new Variable speed fan
-        fan = OpenStudio::Model::FanVariableVolume.new(model)
-
-        # Add the new fan to the oulet node of the existing fan
-        # before deleting the existing one
-        fan.addToNode(next_node)
-
-        # Remove the existing fan.  When this happens, either the pump's
-        # inlet or outlet node will be deleted and the other will remain
-        old_fan.remove
-
-        # Rename the fan clearly
-        fan.setName(base_name + ' Variable Volume Fan')
-
-        # If fan_pressure_rise has a non zero null value, assign it.
-        if !fan_pressure_rise.empty?
-          # We need the .get because this is an OptionalDouble. the .get will return a Double (float)
-          fan.setPressureRise(fan_pressure_rise.get)
-          runner.registerInfo("Fan '#{fan.name}' was assigned pressure rise of '#{fan_pressure_rise.get}' Pa")
-        end
-
-        final_num_fan_VFD += 1
-
-      else
-        # If VFD isn't wanted, we just rename the constant volume fan
-        old_fan.setName(base_name + ' Constant Volume Fan')
-
-        # If fan_pressure_rise has a non zero null value, assign it.
-        if !fan_pressure_rise.empty?
-          # We need the .get because this is an OptionalDouble. the .get will return a Double (float)
-          old_fan.setPressureRise(fan_pressure_rise.get)
-          puts "Fan '#{old_fan.name}' was assigned pressure rise of '#{fan_pressure_rise.get}' Pa"
-        end
-
-      end
-
-      # The Cooling coil expects an OptionalDouble
-      coil = air_handler.supplyComponents(OpenStudio::Model::CoilCoolingDXSingleSpeed.iddObjectType).first
-      coil = coil.to_CoilCoolingDXSingleSpeed.get
-      # Set CoolingCoil COP
-      coil.setRatedCOP(OpenStudio::OptionalDouble.new(cop_cooling))
-      # Set CoolingCoil Name
-      coil.setName(base_name + ' Coil Cooling DX Single Speed')
-
-      # The Heating coil expects a Double
-      coilheating = air_handler.supplyComponents(OpenStudio::Model::CoilHeatingDXSingleSpeed.iddObjectType).first
-      coilheating = coilheating.to_CoilHeatingDXSingleSpeed.get
-      # Set HeatingCoil COP
-      coilheating.setRatedCOP(cop_heating)
-      # Set HeatingCoil Name
-      coilheating.setName(base_name + ' Coil Heating DX Single Speed')
-
-      # Delete the electric heating coil if unwanted
-      if !has_electric_coil
-        coilheatingelec = air_handler.supplyComponents(OpenStudio::Model::CoilHeatingElectric.iddObjectType).first
-        coilheatingelec.remove
-      end
-
-      # Enable DCV (dunno if working)
-      if has_dcv
-
-        # get air_handler supply components
-        supply_components = air_handler.supplyComponents
-
-        # find AirLoopHVACOutdoorAirSystem on loop
-        supply_components.each do |supply_component|
-          hVACComponent = supply_component.to_AirLoopHVACOutdoorAirSystem
-          if !hVACComponent.empty?
-            hVACComponent = hVACComponent.get
-
-            # get ControllerOutdoorAir
-            controller_oa = hVACComponent.getControllerOutdoorAir
-            controller_oa.setName(base_name + ' Controller Outdoor Air')
-
-            # get ControllerMechanicalVentilation
-            controller_mv = controller_oa.controllerMechanicalVentilation
-
-            # check if demand control is enabled, if not, then enable it
-            if controller_mv.demandControlledVentilation == true
-              initial_num_air_loops_demand_control += 1
-            else
-              controller_mv.setDemandControlledVentilation(true)
-              puts "Enabling demand control ventilation for #{air_handler.name}"
-            end # End of if
-            final_num_air_loops_demand_control += 1
-
-          end # End of HVACComponent.empty?
-        end # end of supply component do loop
-
-      end # End of has_dcv loop
-
-      # Add a branch for the zone in question
-      air_handler.addBranchForZone(z)
-
-      # Counter
-      affected_loops += 1
-    end # end of do loop on each thermal zone
-
-    # CLEAN-UP SECTION
-    # Idea: loop on PRE-EXISTING AirLoops, delete all that don't have any zones anymore
-    # Then loop on chiller loop, delete all that don't have a coil connected to an air loop
-    # then loop on condenser water, delette all that don't have a chiller anymore
-
-    # If we need to delete existing HVAC loops, we'll loop on the PRE-EXISTING Loops we stored earlier
-    if delete_existing
-
-      # Arrays to store the affected loops
-      chiller_plant_loops = []
-      boiler_plant_loops = []
-      condenser_plant_loops = []
-
-      # Display separator for clarity
-      runner.registerInfo('')
-      runner.registerInfo('========================== CLEAN-UP: AIR LOOPS ==========================')
-
-      # Loop on the pre-existing air loops (not the ones that were created above)
-      air_loops.each do |air_loop|
-        # Check if it's got a thermal zone attached left or not..
-        # We assume we'll delete it unless...
-        delete_flag = true
-
-        air_loop.demandComponents.each do |comp|
-          # If there is at least a single zone left, we can't delete it
-          if comp.to_ThermalZone.is_initialized
-            delete_flag = false
-          end # end of if
-        end # end of do loop on comp
-
-        # If deletion is warranted
-        if delete_flag
-          # before deletion, let's get the potential associated plant loop.
-          if air_loop.supplyComponents(OpenStudio::Model::CoilCoolingWater.iddObjectType).empty?
-            puts "Air loop '#{air_loop.name}' DOES NOT HAVE a CoilHeatingWater"
-          else
-            cooling_coil = air_loop.supplyComponents(OpenStudio::Model::CoilCoolingWater.iddObjectType).first.to_CoilCoolingWater.get
-            chiller_plant_loop = cooling_coil.plantLoop.get
-            # Store handle in array
-            chiller_plant_loops << chiller_plant_loop
-            runner.registerInfo("Air loop '#{air_loop.name}' has a CoilCoolingWater, connected to CHILLER plant loop '#{chiller_plant_loop.name}'")
-          end
-          if air_loop.supplyComponents(OpenStudio::Model::CoilHeatingWater.iddObjectType).empty?
-            puts "Air loop '#{air_loop.name}' DOES NOT HAVE a CoilHeatingWater"
-          else
-            heating_coil = air_loop.supplyComponents(OpenStudio::Model::CoilCoolingWater.iddObjectType).first.to_CoilCoolingWater.get
-            boiler_plant_loop = heating_coil.plantLoop.get
-            # Store handle in array
-            boiler_plant_loops << boiler_plant_loop
-            runner.registerInfo("Air loop '#{air_loop.name}' has a CoilHeatinggWater, connected to BOILER plant loop '#{boiler_plant_loop.name}'")
-          end
-
-          # Now we can delete and report.
-          air_loop.remove
-          runner.registerInfo("DELETED: Air loop '#{air_loop.name}' doesn't have Thermal zones attached and was removed")
-          delete_existing_air_loops += 1
-        else
-          runner.registerInfo("Air Loop '#{air_loop.name}' has thermal zones and was not deleted")
-        end # end if delete_flag
-      end # end air_loops.each do
-
-      # Display separator for clarity
-      runner.registerInfo('')
-      runner.registerInfo('====================== CLEAN-UP: CHILLER PLANT LOOPS ======================')
-
-      # First pass on plant loops: chilled water loops.
-      chiller_plant_loops.each do |chiller_plant_loop|
-        puts "Chiller plant loop name: #{chiller_plant_loop.name}"
-
-        # Check if the chiller plant loop has remaining demand components
-
-        # Delete flag: first assumption is that yes... unless!
-        delete_flag = true
-
-        if chiller_plant_loop.demandComponents(OpenStudio::Model::CoilCoolingWater.iddObjectType).empty?
-          puts "Chiller Plant loop '#{chiller_plant_loop.name}' DOES NOT HAVE a CoilCoolingWater"
-        else
-          puts "Chiller Plant loop '#{chiller_plant_loop.name}' has a CoilCoolingWater"
-          cooling_coil = chiller_plant_loop.demandComponents(OpenStudio::Model::CoilCoolingWater.iddObjectType).first.to_CoilCoolingWater.get
-          if cooling_coil.airLoopHVAC.empty?
-            puts "But Cooling coil '#{cooling_coil.name}' is not connected to any airloopHVAC"
-          else
-            runner.registerInfo("And Cooling coil '#{cooling_coil.name}' is connected to airloopHVAC '#{cooling_coil.airLoopHVAC.get.name}' and therefore can't be deleted")
-            # In this case, we can't delete the chiller plant loop
-            delete_flag = false
-          end # end cooling_coil.airLoopHVAC.empty?
-
-        end # end of chiller_plant_loop.demandComponents CoilCoolingWater
-
-        # We know it's a chiller plant so this is likely unnecessary, but better safe than sorry
-        if chiller_plant_loop.demandComponents(OpenStudio::Model::WaterUseConnections.iddObjectType).empty?
-          puts "Chiller Plant loop '#{chiller_plant_loop.name}' DOES NOT HAVE WaterUseConnections"
-        else
-          runner.registerInfo("Chiller Plant loop '#{chiller_plant_loop.name}' has WaterUseConnections and therefore can't be deleted")
-          delete_flag = false
-        end
-
-        # If deletion is warranted
-        if delete_flag
-
-          # This section below is actually optional (but it's nice to only delete affected ones
-          # before deletion, let's get the potential associated condenser water plant loop.
-          if chiller_plant_loop.supplyComponents(OpenStudio::Model::ChillerElectricEIR.iddObjectType).empty?
-            puts "Chiller Plant loop '#{chiller_plant_loop.name}' DOES NOT HAVE an electric chiller"
-          else
-            chiller = chiller_plant_loop.supplyComponents(OpenStudio::Model::ChillerElectricEIR.iddObjectType).first.to_ChillerElectricEIR.get
-            puts "Chiller Plant loop '#{chiller_plant_loop.name}' has an electric chiller '#{chiller.name}' with condenser type '#{chiller.condenserType}'"
-            # Check directly if chiller has a secondaryPlantLoop (no need to check if chiller.condenserType == 'WaterCooled' first)
-            if chiller.secondaryPlantLoop.is_initialized
-              # Chiller is WaterCooled therefore should be connected to a condenser water loop
-              condenser_plant_loop = chiller.secondaryPlantLoop.get
-              condenser_plant_loops << condenser_plant_loop
-              runner.registerInfo("Chiller PlantLoop '#{chiller_plant_loop.name}' has a Water Cooled chiller connected to Condenser Plant Loop '#{condenser_plant_loop.name}'")
-            end
-          end
-
-          # Now we can delete and report.
-          chiller_plant_loop.remove
-          delete_existing_chiller_loops += 1
-          # Should I delete the chiller as well? It remains...
-
-          runner.registerInfo("DELETED: Chiller PlantLoop '#{chiller_plant_loop.name}' wasn't connected to any AirLoopHVAC nor WaterUseConnections and therefore was removed")
-
-        end # end of delete_flag
-      end # end of chiller_plant_loops.each do
-
-      # Display separator for clarity
-      runner.registerInfo('')
-      runner.registerInfo('===================== CLEAN-UP: CONDENSER PLANT LOOPS ====================')
-      # Second pass on plant loops: condenser water loops.
-      condenser_plant_loops.each do |condenser_plant_loop|
-        delete_flag = true
-
-        # If it has got a chiller as a demand component, it could still be empty
-        if !condenser_plant_loop.demandComponents(OpenStudio::Model::ChillerElectricEIR.iddObjectType).empty?
-
-          chiller = condenser_plant_loop.demandComponents(OpenStudio::Model::ChillerElectricEIR.iddObjectType).first.to_ChillerElectricEIR.get
-
-          # If chiller is actually connected to a chilled water node, then we shall not delete it
-          if !chiller.chilledWaterInletNodeName.empty?
-            runner.registerInfo("On Condenser PlantLoop '#{condenser_plant_loop.name}, there is a demand component of type Chiller '#{chiller.name}'" \
-                                    ' that is connected to a chilled water loop and therefore cannot be deleted')
-            delete_flag = false
-          else
-            puts "Plant loop '#{condenser_plant_loop.name}, Chiller '#{chiller.name}' isn't connected to a chilled water loop"
-          end # end of if chiller.chilledWaterInletNodeName
-        end # end of plant_loop.demandComponents
-
-        # if deletion is warranted
-        if delete_flag
-          condenser_plant_loop.remove
-          delete_existing_condenser_loops += 1
-          runner.registerInfo("DELETED: Plant loop '#{condenser_plant_loop.name}' isn't connected to any chilled water loop")
-        end
-      end
-
-      runner.registerInfo('')
-      runner.registerInfo("For more information, go to 'Advanced Output'")
-
-      # This is the generic way of looping on all loops, checking if it's a condenser plant loop, and to delete it unless it's got a chiller that is connected to chilled water plant loop
-      #       plant_loops.each do |plant_loop|
-      #         # Skip the chiller_plant_loops
-      #         #next if chiller_plant_loops.include? plant_loop
-      #         if chiller_plant_loops.include? plant_loop
-      #           runner.registerInfo("Skipping Plant loop '#{plant_loop.name}' because it is a chiller plant")
-      #           next
-      #         end
-      #         runner.registerInfo("Plant loop '#{plant_loop.name}'")
-      #
-      #         # Until we know that it is a condenser loop for sure, we assume we can't delete it
-      #         delete_flag = false
-      #
-      #         # If it has got a chiller as a demand component, it's a condenser water loop
-      #         if not plant_loop.demandComponents(OpenStudio::Model::ChillerElectricEIR::iddObjectType).empty?
-      #           # Now, we assume we'll delete the loop unless it's actually connected and therefore usefull
-      #           delete_flag = true
-      #           chiller = plant_loop.demandComponents(OpenStudio::Model::ChillerElectricEIR::iddObjectType).first.to_ChillerElectricEIR.get
-      #           # If chiller is actually connected to a chilled water node, then we shall not delete it
-      #           if not chiller.chilledWaterInletNodeName.empty?
-      #             runner.registerInfo("On Condenser PlantLoop '#{plant_loop.name}, there is a demand component of type Chiller '#{chiller.name}'" +
-      #                                   " that is connected to a chilled water loop and therefore cannot be deleted")
-      #             delete_flag = false
-      #           else
-      #             runner.registerInfo("Plant loop '#{plant_loop.name}, Chiller '#{chiller.name}' isn't connected to a chilled water loop")
-      #           end #end of if chiller.chilledWaterInletNodeName
-      #         end #end of plant_loop.demandComponents
-      #
-      #         # if deletion is warranted
-      #         if delete_flag
-      #           plant_loop.remove
-      #           delete_existing_condenser_loops += 1
-      #           runner.registerInfo("DELETED: Plant loop '#{plant_loop.name}'")
-      #         end
-      #
-      #       end #end of plant_loops.each do
-
-      # Third pass on plant loops: boiler water loops.
-      # TO WRITE
-
-    end # end of if delete_existing
-
-    # Report Initial Condition
-    if delete_existing
-      air_loop_str = "\n #{delete_existing_air_loops} existing AirLoopHVACs have been deleted"
-      chiller_plant_loop_str = "\n #{delete_existing_chiller_loops} existing Chiller PlantLoops have been deleted"
-      condenser_plant_loop_str = "\n #{delete_existing_condenser_loops} existing Condenser PlantLoops have been deleted"
-    else
-      air_loop_str = ''
-      chiller_plant_loop_str = ''
-      condenser_plant_loop_str = ''
-    end # end of delete_existing
-
-    runner.registerInitialCondition("Initially #{initial_num_air_loops_demand_control} air loops had demand controlled ventilation enabled" +
-                                          air_loop_str + chiller_plant_loop_str + condenser_plant_loop_str + "\n")
-
-    # Report final condition
-    base_str = "There are #{OpenStudio.toNeatString(affected_loops, 0, true)} zones for which a PSZ-HP system was " \
-               "created with a Cooling COP (SI) of #{OpenStudio.toNeatString(cop_cooling, 2, true)} " \
-               "and a Heating COP (SI) of #{OpenStudio.toNeatString(cop_heating, 2, true)}."
-
-    if has_electric_coil
-      elec_str = 'Supplementary electric heating coils were added.'
-    else
-      elec_str = 'Supplementary electrical heating coils were NOT included.'
-    end # end of has_electric_coil
-
-    if has_vfd
-      fan_str = "Fan type was changed to be Variable Volume (VFD) for #{final_num_fan_VFD} fans."
-    else
-      fan_str = 'Fan type was chosen to be Constant Volume.'
-    end # end of has_vfd
-
-    if final_num_air_loops_demand_control == 0
-      dcv_str = "Demand Controlled Ventilation wasn't enabled for the new air loops"
-    else
-      dcv_str = "#{final_num_air_loops_demand_control} air loops now have demand controlled ventilation enabled"
-    end
-
-    runner.registerFinalCondition(base_str + "\n" + elec_str + "\n" + fan_str + "\n" + dcv_str + "\n \n")
-
-    return true
-  end # end the run method
-end # end the measure
-
-# this allows the measure to be used by the application
-AddAPSZHPToEachZone.new.registerWithApplication