openstudio-standards 0.2.16 → 0.2.17.rc1

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

@@ -0,0 +1,187 @@
+class ASHRAE901PRM < Standard
+  # @!group PlanarSurface
+
+  # If construction properties can be found based on the template,
+  # the standards intended surface type, the standards construction type,
+  # the climate zone, and the occupancy type,
+  # create a construction that meets those properties and assign it to this surface.
+  # 90.1-PRM-2019
+  #
+  # @param planar_surface [Openstudio::Model:PlanarSurface] surface object
+  # @param climate_zone [String] ASHRAE climate zone, e.g. 'ASHRAE 169-2013-4A'
+  # @param previous_construction_map [Hash] a hash where the keys are an array of inputs
+  #   [template, climate_zone, intended_surface_type, standards_construction_type, occ_type]
+  #   and the values are the constructions.  If supplied, constructions will be pulled
+  #   from this hash if already created to avoid creating duplicate constructions.
+  # @return [Hash] returns a hash where the key is an array of inputs
+  #   [template, climate_zone, intended_surface_type, standards_construction_type, occ_type]
+  #   and the value is the newly created construction.
+  #   This can be used to avoid creating duplicate constructions.
+  # @todo Align the standard construction enumerations in the
+  # spreadsheet with the enumerations in OpenStudio (follow CBECC-Com).
+  def planar_surface_apply_standard_construction(planar_surface, climate_zone, previous_construction_map = {}, wwr_building_type = nil, wwr_info = {}, surface_category)
+    # Skip surfaces not in a space
+    return previous_construction_map if planar_surface.space.empty?
+
+    space = planar_surface.space.get
+    if surface_category == 'ExteriorSubSurface'
+      surface_type = planar_surface.subSurfaceType
+    else
+      surface_type = planar_surface.surfaceType
+    end
+
+    # Skip surfaces that don't have a construction
+    # return previous_construction_map if planar_surface.construction.empty?
+    if !planar_surface.construction.empty?
+      construction = planar_surface.construction.get
+    else
+      # Get appropriate default construction if not defined inside surface object
+      construction = nil
+      space_type = space.spaceType.get
+      if space.defaultConstructionSet.is_initialized
+        cons_set = space.defaultConstructionSet.get
+        construction = get_default_surface_cons_from_surface_type(surface_category, surface_type, cons_set)
+      end
+      if construction.nil? && space_type.defaultConstructionSet.is_initialized
+        cons_set = space_type.defaultConstructionSet.get
+        construction = get_default_surface_cons_from_surface_type(surface_category, surface_type, cons_set)
+      end
+      if construction.nil? && space.buildingStory.get.defaultConstructionSet.is_initialized
+        cons_set = space.buildingStory.get.defaultConstructionSet.get
+        construction = get_default_surface_cons_from_surface_type(surface_category, surface_type, cons_set)
+      end
+      if construction.nil? && space.model.building.get.defaultConstructionSet.is_initialized
+        cons_set = space.model.building.get.defaultConstructionSet.get
+        construction = get_default_surface_cons_from_surface_type(surface_category, surface_type, cons_set)
+      end
+
+      return previous_construction_map if construction.nil?
+    end
+
+    # Determine if residential or nonresidential
+    # based on the space type.
+    occ_type = 'Nonresidential'
+    if space_residential?(space)
+      occ_type = 'Residential'
+    end
+
+    # Get the climate zone set
+    climate_zone_set = model_find_climate_zone_set(planar_surface.model, climate_zone)
+
+    # Get the intended surface type
+    standards_info = construction.standardsInformation
+    surf_type = standards_info.intendedSurfaceType
+
+    if surf_type.empty?
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.PlanarSurface', "Could not determine the intended surface type for #{planar_surface.name} from #{construction.name}.  This surface will not have the standard applied.")
+      return previous_construction_map
+    end
+    surf_type = surf_type.get
+
+    # Get the standards type, which is based on different fields
+    # if is intended for a window, a skylight, or something else.
+    # Mapping is between standards-defined enumerations and the
+    # enumerations available in OpenStudio.
+    stds_type = nil
+    # Windows and Glass Doors
+    if surf_type == 'ExteriorWindow' || surf_type == 'GlassDoor'
+      stds_type = standards_info.fenestrationFrameType
+      if stds_type.is_initialized
+        stds_type = stds_type.get
+        if !wwr_building_type.nil?
+          stds_type = 'Any Vertical Glazing'
+        end
+        case stds_type
+        when 'Metal Framing', 'Metal Framing with Thermal Break'
+          stds_type = 'Metal framing (all other)'
+        when 'Non-Metal Framing'
+          stds_type = 'Nonmetal framing (all)'
+        when 'Any Vertical Glazing'
+          stds_type = 'Any Vertical Glazing'
+        else
+          OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.PlanarSurface', "The standards fenestration frame type #{stds_type} cannot be used on #{surf_type} in #{planar_surface.name}.  This surface will not have the standard applied.")
+          return previous_construction_map
+        end
+      else
+        if !wwr_building_type.nil?
+          stds_type = 'Any Vertical Glazing'
+        else
+          OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.PlanarSurface', "Could not determine the standards fenestration frame type for #{planar_surface.name} from #{construction.name}.  This surface will not have the standard applied.")
+          return previous_construction_map
+        end
+      end
+    # Exterior Doors
+    elsif surf_type == 'ExteriorDoor'
+      stds_type = standards_info.standardsConstructionType
+      if stds_type.is_initialized
+        stds_type = stds_type.get
+        case stds_type
+        when 'RollUp'
+          stds_type = 'NonSwinging'
+        end
+      else
+        stds_type = 'Swinging'
+      end
+    # Skylights
+    elsif surf_type == 'Skylight'
+      # There is only one type for AppendixG stable baseline
+      stds_type = 'Any Skylight'
+    # All other surface types
+    else
+      stds_type = standards_info.standardsConstructionType
+      if stds_type.is_initialized
+        stds_type = stds_type.get
+      else
+        if planar_surface.outsideBoundaryCondition == 'Surface' && surface_category == 'NA'
+          OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.PlanarSurface', "Standards construction is not needed and not applied for interior wall: #{planar_surface.name}.")
+        else
+          OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.PlanarSurface', "Could not determine the standards construction type for #{planar_surface.name}.  This surface will not have the standard applied.")
+        end
+        return previous_construction_map
+      end
+    end
+
+    # Check if the construction type was already created.
+    # If yes, use that construction.  If no, make a new one.
+
+    # for multi-building type - search for the surface wwr type
+    surface_std_wwr_type = wwr_building_type
+    new_construction = nil
+    type = [template, climate_zone, surf_type, stds_type, occ_type]
+    # Only apply the surface_std_wwr_type update when wwr_building_type has Truthy values
+    if !wwr_building_type.nil? && (surf_type == 'ExteriorWindow' || surf_type == 'GlassDoor')
+      space = planar_surface.space.get
+      if space.hasAdditionalProperties && space.additionalProperties.hasFeature('building_type_for_wwr')
+        surface_std_wwr_type = space.additionalProperties.getFeatureAsString('building_type_for_wwr').get
+      end
+      type.push(surface_std_wwr_type)
+    end
+
+    if previous_construction_map[type] && !previous_construction_map[type].iddObjectType.valueName.to_s.include?('factorGround')
+      new_construction = previous_construction_map[type]
+    else
+      new_construction = model_find_and_add_construction(planar_surface.model,
+                                                         climate_zone_set,
+                                                         surf_type,
+                                                         stds_type,
+                                                         occ_type,
+                                                         wwr_building_type: surface_std_wwr_type,
+                                                         wwr_info: wwr_info,
+                                                         surface: planar_surface)
+      if !new_construction == false
+        previous_construction_map[type] = new_construction
+      end
+    end
+
+    # Assign the new construction to the surface
+    if new_construction
+      planar_surface.setConstruction(new_construction)
+      OpenStudio.logFree(OpenStudio::Debug, 'openstudio.standards.PlanarSurface', "Set the construction for #{planar_surface.name} to #{new_construction.name}.")
+    else
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.PlanarSurface', "Could not generate a standard construction for #{planar_surface.name}.")
+      return previous_construction_map
+    end
+
+    return previous_construction_map
+  end
+end

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

@@ -0,0 +1,450 @@
+class ASHRAE901PRM < Standard
+  # Keep only one cooling tower, but use one condenser pump per chiller
+
+  # @param plant_loop [OpenStudio::Model::PlantLoop] plant loop
+  # @return [Bool] returns true if successful, false if not
+  def plant_loop_apply_prm_number_of_cooling_towers(plant_loop)
+    # Skip non-cooling plants
+    return true unless plant_loop.sizingPlant.loopType == 'Condenser'
+
+    # Determine the number of chillers
+    # already in the model
+    num_chillers = plant_loop.model.getChillerElectricEIRs.size
+
+    # Get all existing cooling towers and pumps
+    clg_twrs = []
+    pumps = []
+    plant_loop.supplyComponents.each do |sc|
+      if sc.to_CoolingTowerSingleSpeed.is_initialized
+        clg_twrs << sc.to_CoolingTowerSingleSpeed.get
+      elsif sc.to_CoolingTowerTwoSpeed.is_initialized
+        clg_twrs << sc.to_CoolingTowerTwoSpeed.get
+      elsif sc.to_CoolingTowerVariableSpeed.is_initialized
+        clg_twrs << sc.to_CoolingTowerVariableSpeed.get
+      elsif sc.to_PumpConstantSpeed.is_initialized
+        pumps << sc.to_PumpConstantSpeed.get
+      elsif sc.to_PumpVariableSpeed.is_initialized
+        pumps << sc.to_PumpVariableSpeed.get
+      end
+    end
+
+    # Ensure there is only 1 cooling tower to start
+    orig_twr = nil
+    if clg_twrs.size.zero?
+      return true
+    elsif clg_twrs.size > 1
+      OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.PlantLoop', "For #{plant_loop.name}, found #{clg_twrs.size} cooling towers, cannot split up per performance rating method baseline requirements.")
+      return false
+    else
+      orig_twr = clg_twrs[0]
+    end
+
+    # Ensure there is only 1 pump to start
+    orig_pump = nil
+    if pumps.size.zero?
+      OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.PlantLoop', "For #{plant_loop.name}, found #{pumps.size} pumps.  A loop must have at least one pump.")
+      return false
+    elsif pumps.size > 1
+      OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.PlantLoop', "For #{plant_loop.name}, found #{pumps.size} pumps, cannot split up per performance rating method baseline requirements.")
+      return false
+    else
+      orig_pump = pumps[0]
+    end
+
+    # Determine the per-cooling_tower sizing factor
+    clg_twr_sizing_factor = (1.0 / num_chillers).round(2)
+
+    final_twrs = [orig_twr]
+
+    # If there is more than one chiller,
+    # replace the original pump with a headered pump
+    # of the same type and properties.
+    if num_chillers > 1
+      num_pumps = num_chillers
+      new_pump = nil
+      if orig_pump.to_PumpConstantSpeed.is_initialized
+        new_pump = OpenStudio::Model::HeaderedPumpsConstantSpeed.new(plant_loop.model)
+        new_pump.setNumberofPumpsinBank(num_pumps)
+        new_pump.setName("#{orig_pump.name} Bank of #{num_pumps}")
+        new_pump.setRatedPumpHead(orig_pump.ratedPumpHead)
+        new_pump.setMotorEfficiency(orig_pump.motorEfficiency)
+        new_pump.setFractionofMotorInefficienciestoFluidStream(orig_pump.fractionofMotorInefficienciestoFluidStream)
+        new_pump.setPumpControlType(orig_pump.pumpControlType)
+      elsif orig_pump.to_PumpVariableSpeed.is_initialized
+        new_pump = OpenStudio::Model::HeaderedPumpsVariableSpeed.new(plant_loop.model)
+        new_pump.setNumberofPumpsinBank(num_pumps)
+        new_pump.setName("#{orig_pump.name} Bank of #{num_pumps}")
+        new_pump.setRatedPumpHead(orig_pump.ratedPumpHead)
+        new_pump.setMotorEfficiency(orig_pump.motorEfficiency)
+        new_pump.setFractionofMotorInefficienciestoFluidStream(orig_pump.fractionofMotorInefficienciestoFluidStream)
+        new_pump.setPumpControlType(orig_pump.pumpControlType)
+        new_pump.setCoefficient1ofthePartLoadPerformanceCurve(orig_pump.coefficient1ofthePartLoadPerformanceCurve)
+        new_pump.setCoefficient2ofthePartLoadPerformanceCurve(orig_pump.coefficient2ofthePartLoadPerformanceCurve)
+        new_pump.setCoefficient3ofthePartLoadPerformanceCurve(orig_pump.coefficient3ofthePartLoadPerformanceCurve)
+        new_pump.setCoefficient4ofthePartLoadPerformanceCurve(orig_pump.coefficient4ofthePartLoadPerformanceCurve)
+      end
+      # Remove the old pump
+      orig_pump.remove
+      # Attach the new headered pumps
+      new_pump.addToNode(plant_loop.supplyInletNode)
+    end
+  end
+
+  # Get the total cooling capacity for the plant loop
+  #
+  # @param plant_loop [OpenStudio::Model::PlantLoop] plant loop
+  # @param [String] sizing_run_dir
+  # @return [Double] total cooling capacity in watts
+  def plant_loop_total_cooling_capacity(plant_loop, sizing_run_dir = Dir.pwd)
+    # Sum the cooling capacity for all cooling components
+    # on the plant loop.
+    total_cooling_capacity_w = 0
+    sizing_run_ran = false
+
+    plant_loop.supplyComponents.each do |sc|
+      # ChillerElectricEIR
+      if sc.to_ChillerElectricEIR.is_initialized
+        chiller = sc.to_ChillerElectricEIR.get
+
+        # If chiller is autosized, check sizing run results. If sizing run not ran, run it first
+        if chiller.isReferenceCapacityAutosized
+          model = chiller.model
+          sizing_run_ran = model_run_sizing_run(model, "#{sizing_run_dir}/SR_cooling_plant") if !sizing_run_ran
+
+          if sizing_run_ran
+            sizing_run_capacity = model.getAutosizedValueFromEquipmentSummary(chiller, 'Central Plant', 'Nominal Capacity', 'W').get
+            chiller.setReferenceCapacity(sizing_run_capacity)
+            total_cooling_capacity_w += sizing_run_capacity
+          else
+            OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.PlantLoop', "For #{plant_loop.name} capacity of #{chiller.name} is not available due to a sizing run failure, total cooling capacity of plant loop will be incorrect when applying standard.")
+          end
+
+        elsif chiller.referenceCapacity.is_initialized
+          total_cooling_capacity_w += chiller.referenceCapacity.get
+        elsif chiller.autosizedReferenceCapacity.is_initialized
+          total_cooling_capacity_w += chiller.autosizedReferenceCapacity.get
+        else
+          OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.PlantLoop', "For #{plant_loop.name} capacity of #{chiller.name} is not available, total cooling capacity of plant loop will be incorrect when applying standard.")
+        end
+        # DistrictCooling
+      elsif sc.to_DistrictCooling.is_initialized
+        dist_clg = sc.to_DistrictCooling.get
+        if dist_clg.nominalCapacity.is_initialized
+          total_cooling_capacity_w += dist_clg.nominalCapacity.get
+        elsif dist_clg.autosizedNominalCapacity.is_initialized
+          total_cooling_capacity_w += dist_clg.autosizedNominalCapacity.get
+        else
+          OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.PlantLoop', "For #{plant_loop.name} capacity of DistrictCooling #{dist_clg.name} is not available, total heating capacity of plant loop will be incorrect when applying standard.")
+        end
+      end
+    end
+
+    total_cooling_capacity_tons = OpenStudio.convert(total_cooling_capacity_w, 'W', 'ton').get
+    OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.PlantLoop', "For #{plant_loop.name}, cooling capacity is #{total_cooling_capacity_tons.round} tons of refrigeration.")
+
+    return total_cooling_capacity_w
+  end
+
+  # Splits the single chiller used for the initial sizing run
+  # into multiple separate chillers based on Appendix G.
+  #
+  # @param plant_loop_args [Array] chilled water loop (OpenStudio::Model::PlantLoop), sizing run directory
+  # @return [Bool] returns true if successful, false if not
+  def plant_loop_apply_prm_number_of_chillers(plant_loop, sizing_run_dir = nil)
+    # Skip non-cooling plants & secondary cooling loop
+    return true unless plant_loop.sizingPlant.loopType == 'Cooling'
+    # If the loop is cooling but it is a secondary loop, then skip.
+    return true if plant_loop.additionalProperties.hasFeature('is_secondary_loop')
+
+    # Determine the number and type of chillers
+    num_chillers = nil
+    chiller_cooling_type = nil
+    chiller_compressor_type = nil
+
+    # Set the equipment to stage sequentially or uniformload if there is secondary loop
+    if plant_loop.additionalProperties.hasFeature('is_primary_loop')
+      plant_loop.setLoadDistributionScheme('UniformLoad')
+    else
+      plant_loop.setLoadDistributionScheme('SequentialLoad')
+    end
+
+    # Determine the capacity of the loop
+    cap_w = plant_loop_total_cooling_capacity(plant_loop, sizing_run_dir)
+    cap_tons = OpenStudio.convert(cap_w, 'W', 'ton').get
+    if cap_tons <= 300
+      num_chillers = 1
+      chiller_cooling_type = 'WaterCooled'
+      chiller_compressor_type = 'Rotary Screw and Scroll'
+    elsif cap_tons > 300 && cap_tons < 600
+      num_chillers = 2
+      chiller_cooling_type = 'WaterCooled'
+      chiller_compressor_type = 'Rotary Screw and Scroll'
+    else
+      # Max capacity of a single chiller
+      max_cap_ton = 800.0
+      num_chillers = (cap_tons / max_cap_ton).floor + 1
+      # Must be at least 2 chillers
+      num_chillers += 1 if num_chillers == 1
+      chiller_cooling_type = 'WaterCooled'
+      chiller_compressor_type = 'Centrifugal'
+    end
+
+    # Get all existing chillers and pumps
+    chillers = []
+    pumps = []
+    plant_loop.supplyComponents.each do |sc|
+      if sc.to_ChillerElectricEIR.is_initialized
+        chillers << sc.to_ChillerElectricEIR.get
+      elsif sc.to_PumpConstantSpeed.is_initialized
+        pumps << sc.to_PumpConstantSpeed.get
+      elsif sc.to_PumpVariableSpeed.is_initialized
+        pumps << sc.to_PumpVariableSpeed.get
+      end
+    end
+
+    # Ensure there is only 1 chiller to start
+    first_chiller = nil
+    return true if chillers.size.zero?
+
+    if chillers.size > 1
+      OpenStudio.logFree(OpenStudio::Error, 'prm.log', "For #{plant_loop.name}, found #{chillers.size} chillers, cannot split up per performance rating method baseline requirements.")
+    else
+      first_chiller = chillers[0]
+    end
+
+    # Ensure there is only 1 pump to start
+    orig_pump = nil
+    if pumps.size.zero?
+      OpenStudio.logFree(OpenStudio::Error, 'prm.log', "For #{plant_loop.name}, found #{pumps.size} pumps. A loop must have at least one pump.")
+      return false
+    elsif pumps.size > 1
+      OpenStudio.logFree(OpenStudio::Error, 'prm.log', "For #{plant_loop.name}, found #{pumps.size} pumps, cannot split up per performance rating method baseline requirements.")
+      return false
+    else
+      orig_pump = pumps[0]
+    end
+
+    # Determine the per-chiller capacity
+    # and sizing factor
+    per_chiller_sizing_factor = (1.0 / num_chillers).round(2)
+    # This is unused
+    per_chiller_cap_tons = cap_tons / num_chillers
+    per_chiller_cap_w = cap_w / num_chillers
+
+    # Set the sizing factor and the chiller type: could do it on the first chiller before cloning it, but renaming warrants looping on chillers anyways
+
+    # Add any new chillers
+    final_chillers = [first_chiller]
+    (num_chillers - 1).times do
+      new_chiller = first_chiller.clone(plant_loop.model)
+      if new_chiller.to_ChillerElectricEIR.is_initialized
+        new_chiller = new_chiller.to_ChillerElectricEIR.get
+      else
+        OpenStudio.logFree(OpenStudio::Error, 'prm.log', "For #{plant_loop.name}, could not clone chiller #{first_chiller.name}, cannot apply the performance rating method number of chillers.")
+        return false
+      end
+      # Connect the new chiller to the same CHW loop
+      # as the old chiller.
+      plant_loop.addSupplyBranchForComponent(new_chiller)
+      # Connect the new chiller to the same CW loop
+      # as the old chiller, if it was water-cooled.
+      cw_loop = first_chiller.secondaryPlantLoop
+      if cw_loop.is_initialized
+        cw_loop.get.addDemandBranchForComponent(new_chiller)
+      end
+
+      final_chillers << new_chiller
+    end
+
+    # If there is more than one cooling tower,
+    # add one pump to each chiller, assume chillers are equally sized
+    if final_chillers.size > 1
+      num_pumps = final_chillers.size
+      final_chillers.each do |chiller|
+        if orig_pump.to_PumpConstantSpeed.is_initialized
+          new_pump = OpenStudio::Model::PumpConstantSpeed.new(plant_loop.model)
+          new_pump.setName("#{chiller.name} Primary Pump")
+          # Will need to adjust the pump power after a sizing run
+          new_pump.setRatedPumpHead(orig_pump.ratedPumpHead / num_pumps)
+          new_pump.setMotorEfficiency(0.9)
+          new_pump.setPumpControlType('Intermittent')
+          chiller_inlet_node = chiller.connectedObject(chiller.supplyInletPort).get.to_Node.get
+          new_pump.addToNode(chiller_inlet_node)
+        elsif orig_pump.to_PumpVariableSpeed.is_initialized
+          new_pump = OpenStudio::Model::PumpVariableSpeed.new(plant_loop.model)
+          new_pump.setName("#{chiller.name} Primary Pump")
+          new_pump.setRatedPumpHead(orig_pump.ratedPumpHead / num_pumps)
+          new_pump.setCoefficient1ofthePartLoadPerformanceCurve(orig_pump.coefficient1ofthePartLoadPerformanceCurve)
+          new_pump.setCoefficient2ofthePartLoadPerformanceCurve(orig_pump.coefficient2ofthePartLoadPerformanceCurve)
+          new_pump.setCoefficient3ofthePartLoadPerformanceCurve(orig_pump.coefficient3ofthePartLoadPerformanceCurve)
+          new_pump.setCoefficient4ofthePartLoadPerformanceCurve(orig_pump.coefficient4ofthePartLoadPerformanceCurve)
+          chiller_inlet_node = chiller.connectedObject(chiller.supplyInletPort).get.to_Node.get
+          new_pump.addToNode(chiller_inlet_node)
+        end
+      end
+      # Remove the old pump
+      orig_pump.remove
+    end
+
+    # Set the sizing factor and the chiller types
+    final_chillers.each_with_index do |final_chiller, i|
+      final_chiller.setName("#{template} #{chiller_cooling_type} #{chiller_compressor_type} Chiller #{i + 1} of #{final_chillers.size}")
+      final_chiller.setSizingFactor(per_chiller_sizing_factor)
+      final_chiller.setReferenceCapacity(per_chiller_cap_w)
+      final_chiller.setCondenserType(chiller_cooling_type)
+      final_chiller.additionalProperties.setFeature('compressor_type', chiller_compressor_type)
+    end
+    OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.PlantLoop', "For #{plant_loop.name}, there are #{final_chillers.size} #{chiller_cooling_type} #{chiller_compressor_type} chillers.")
+
+    return true
+  end
+
+  # Apply prm baseline pump power
+  # @note I think it makes more sense to sense the motor efficiency right there...
+  #   But actually it's completely irrelevant...
+  #   you could set at 0.9 and just calculate the pressure rise to have your 19 W/GPM or whatever
+  #
+  # @param plant_loop [OpenStudio::Model::PlantLoop] plant loop
+  # @return [Bool] returns true if successful, false if not
+  def plant_loop_apply_prm_baseline_pump_power(plant_loop)
+    hot_water_pump_power = 19 # W/gpm
+    hot_water_district_pump_power = 14 # W/gpm
+    chilled_water_primary_pump_power = 9 # W/gpm
+    chilled_water_secondary_pump_power = 13 # W/gpm
+    chilled_water_district_pump_power = 16 # W/gpm
+    condenser_water_pump_power = 19 # W/gpm
+    # Determine the pumping power per
+    # flow based on loop type.
+    w_per_gpm = nil
+    chiller_counter = 0
+
+    sizing_plant = plant_loop.sizingPlant
+    loop_type = sizing_plant.loopType
+
+    case loop_type
+    when 'Heating'
+
+      has_district_heating = false
+      plant_loop.supplyComponents.each do |sc|
+        if sc.to_DistrictHeating.is_initialized
+          has_district_heating = true
+        end
+      end
+
+      w_per_gpm = if has_district_heating # District HW
+                    hot_water_district_pump_power
+                  else # HW
+                    hot_water_pump_power
+                  end
+
+    when 'Cooling'
+      has_district_cooling = false
+      plant_loop.supplyComponents.each do |sc|
+        if sc.to_DistrictCooling.is_initialized
+          has_district_cooling = true
+        elsif sc.to_ChillerElectricEIR.is_initialized
+          chiller_counter += 1
+        end
+      end
+
+      if has_district_cooling # District CHW
+        w_per_gpm = chilled_water_district_pump_power
+      elsif plant_loop.additionalProperties.hasFeature('is_primary_loop') # The primary loop of the primary/secondary CHW
+        w_per_gpm = chilled_water_primary_pump_power
+      elsif plant_loop.additionalProperties.hasFeature('is_secondary_loop') # The secondary loop of the primary/secondary CHW
+        w_per_gpm = chilled_water_secondary_pump_power
+      else # Primary only CHW combine 9W/gpm + 13W/gpm
+        w_per_gpm = chilled_water_primary_pump_power + chilled_water_secondary_pump_power
+      end
+
+    when 'Condenser'
+      # @todo prm condenser loop pump power
+      w_per_gpm = condenser_water_pump_power
+    end
+
+    # Modify all the primary pumps
+    plant_loop.supplyComponents.each do |sc|
+      if sc.to_PumpConstantSpeed.is_initialized
+        pump = sc.to_PumpConstantSpeed.get
+        if chiller_counter > 0
+          w_per_gpm /= chiller_counter
+        end
+        pump_apply_prm_pressure_rise_and_motor_efficiency(pump, w_per_gpm)
+      elsif sc.to_PumpVariableSpeed.is_initialized
+        pump = sc.to_PumpVariableSpeed.get
+        pump_apply_prm_pressure_rise_and_motor_efficiency(pump, w_per_gpm)
+      elsif sc.to_HeaderedPumpsConstantSpeed.is_initialized
+        pump = sc.to_HeaderedPumpsConstantSpeed.get
+        pump_apply_prm_pressure_rise_and_motor_efficiency(pump, w_per_gpm)
+      elsif sc.to_HeaderedPumpsVariableSpeed.is_initialized
+        pump = sc.to_HeaderedPumpsVariableSpeed.get
+        pump_apply_prm_pressure_rise_and_motor_efficiency(pump, w_per_gpm)
+      end
+    end
+    return true
+  end
+
+  # Apply sizing and controls to chilled water loop
+  #
+  # @param model [OpenStudio::Model::Model] OpenStudio model object
+  # @param chilled_water_loop [OpenStudio::Model::PlantLoop] chilled water loop
+  # @param dsgn_sup_wtr_temp [Double] design chilled water supply T
+  # @param dsgn_sup_wtr_temp_delt [Double] design chilled water supply delta T
+  # @return [Bool] returns true if successful, false if not
+  def chw_sizing_control(model, chilled_water_loop, dsgn_sup_wtr_temp, dsgn_sup_wtr_temp_delt)
+
+    design_chilled_water_temperature = 44 # Loop design chilled water temperature (F)
+    design_chilled_water_temperature_delta = 10.1 # Loop design chilled water temperature  (deltaF)
+    chw_outdoor_temperature_high = 80 # Chilled water temperature reset at high outdoor air temperature (F)
+    chw_outdoor_temperature_low = 60 # Chilled water temperature reset at low outdoor air temperature (F)
+    chw_outdoor_high_setpoint = 44 # Chilled water setpoint temperature at high outdoor air temperature (F)
+    chw_outdoor_low_setpoint = 54 # Chilled water setpoint temperature at low outdoor air temperature (F)
+    chiller_chw_low_temp_limit = 36 # Chiller leaving chilled water lower temperature limit (F)
+    chiller_chw_cond_temp = 95 # Chiller entering condenser fluid temperature (F)
+    primary_pump_power = 9 # primary pump power (W/gpm)
+ 
+    if dsgn_sup_wtr_temp.nil?
+      dsgn_sup_wtr_temp_c = OpenStudio.convert(design_chilled_water_temperature, 'F', 'C').get
+    else
+      dsgn_sup_wtr_temp_c = OpenStudio.convert(dsgn_sup_wtr_temp, 'F', 'C').get
+    end
+    if dsgn_sup_wtr_temp_delt.nil?
+      dsgn_sup_wtr_temp_delt_k = OpenStudio.convert(design_chilled_water_temperature_delta, 'R', 'K').get
+    else
+      dsgn_sup_wtr_temp_delt_k = OpenStudio.convert(dsgn_sup_wtr_temp_delt, 'R', 'K').get
+    end
+    chilled_water_loop.setMinimumLoopTemperature(1.0)
+    chilled_water_loop.setMaximumLoopTemperature(40.0)
+
+    sizing_plant = chilled_water_loop.sizingPlant
+    sizing_plant.setLoopType('Cooling')
+    sizing_plant.setDesignLoopExitTemperature(dsgn_sup_wtr_temp_c)
+    sizing_plant.setLoopDesignTemperatureDifference(dsgn_sup_wtr_temp_delt_k)
+    # Use OA reset setpoint manager
+    outdoor_low_temperature_C = OpenStudio.convert(chw_outdoor_temperature_low, 'F', 'C').get.round(1)
+    outdoor_high_temperature_C = OpenStudio.convert(chw_outdoor_temperature_high, 'F', 'C').get.round(1)
+    setpoint_temperature_outdoor_high_C = OpenStudio.convert(chw_outdoor_high_setpoint, 'F', 'C').get.round(1)
+    setpoint_temperature_outdoor_low_C = OpenStudio.convert(chw_outdoor_low_setpoint, 'F', 'C').get.round(1)
+
+    chw_stpt_manager = OpenStudio::Model::SetpointManagerOutdoorAirReset.new(model)
+    chw_stpt_manager.setName("#{chilled_water_loop.name} Setpoint Manager")
+    chw_stpt_manager.setOutdoorHighTemperature(outdoor_high_temperature_C) # Degrees Celsius
+    chw_stpt_manager.setSetpointatOutdoorHighTemperature(setpoint_temperature_outdoor_high_C) # Degrees Celsius
+    chw_stpt_manager.setOutdoorLowTemperature(outdoor_low_temperature_C) # Degrees Celsius
+    chw_stpt_manager.setSetpointatOutdoorLowTemperature(setpoint_temperature_outdoor_low_C) # Degrees Celsius
+    chw_stpt_manager.addToNode(chilled_water_loop.supplyOutletNode)
+
+    return true
+  end
+
+  # Set configuration in model for chilled water primary/secondary loop interface
+  # Use heat_exchanger for stable baseline
+  #
+  # @param model [OpenStudio::Model::Model] OpenStudio model object
+  # @return [String] common_pipe or heat_exchanger
+  def plant_loop_set_chw_pri_sec_configuration(model)
+    pri_sec_config = 'heat_exchanger'
+    return pri_sec_config
+  end
+
+end