openstudio-standards 0.6.3 → 0.7.0.rc1

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

@@ -92,22 +92,16 @@ class ASHRAE901PRM < Standard
   end
 
   # Splits the single chiller used for the initial sizing run
-  # into multiple separate chillers based on Appendix G.
-  #
+  # into multiple separate chillers based on Appendix G. Also applies
+  # EMS to stage chillers properly
   # @param plant_loop [OpenStudio::Model::PlantLoop] chilled water loop
-  # @param sizing_run_dir [String] sizing run directory
   # @return [Boolean] returns true if successful, false if not
-  def plant_loop_apply_prm_number_of_chillers(plant_loop, sizing_run_dir = nil)
+  def plant_loop_apply_prm_number_of_chillers(plant_loop)
     # 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')
@@ -115,9 +109,55 @@ class ASHRAE901PRM < Standard
       plant_loop.setLoadDistributionScheme('SequentialLoad')
     end
 
+    model = plant_loop.model
+
+    # Get all existing chillers and pumps. Copy chiller properties needed when duplicating existing settings
+    chillers = []
+    pumps = []
+    default_cop = nil
+    condenser_water_loop = nil
+    dsgn_sup_wtr_temp_c = nil
+
+    plant_loop.supplyComponents.each do |sc|
+      if sc.to_ChillerElectricEIR.is_initialized
+        chiller = sc.to_ChillerElectricEIR.get
+
+        # Copy the last chillers COP, leaving chilled water temperature, and reference cooling tower. These will be the
+        # default for any extra chillers.
+        default_cop = chiller.referenceCOP
+        dsgn_sup_wtr_temp_c = chiller.referenceLeavingChilledWaterTemperature
+        condenser_water_loop = chiller.condenserWaterLoop
+        chillers << chiller
+
+      elsif sc.to_PumpConstantSpeed.is_initialized
+        pumps << sc.to_PumpConstantSpeed.get
+      elsif sc.to_PumpVariableSpeed.is_initialized
+        pumps << sc.to_PumpVariableSpeed.get
+      end
+    end
+
+    # Get existing plant loop pump. We'll copy this pumps parameters before removing it. Throw exception for multiple pumps on supply side
+    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
+      original_pump = pumps[0]
+    end
+
+    return true if chillers.empty?
+
     # Determine the capacity of the loop
     cap_w = plant_loop_total_cooling_capacity(plant_loop)
     cap_tons = OpenStudio.convert(cap_w, 'W', 'ton').get
+
+    # Throw exception for > 2,400 tons as this breaks our staging strategy cap of 3 chillers
+    if cap_tons > 2400
+      OpenStudio.logFree(OpenStudio::Error, 'prm.log', "For #{plant_loop.name}, the total capacity (#{cap_w}) exceeded 2400 tons and would require more than 3 chillers. The existing code base cannot accommodate the staging required for this")
+    end
+
     if cap_tons <= 300
       num_chillers = 1
       chiller_cooling_type = 'WaterCooled'
@@ -136,114 +176,352 @@ class ASHRAE901PRM < Standard
       chiller_compressor_type = 'Centrifugal'
     end
 
-    # Get all existing chillers and pumps
-    chillers = []
-    pumps = []
-    plant_loop.supplyComponents.each do |sc|
+    if chillers.length > num_chillers
+      OpenStudio.logFree(OpenStudio::Error, 'prm.log', "For #{plant_loop.name}, the existing number of chillers exceeds the recommended amount. We have not accounted for this in the codebase yet.")
+    end
+
+    # Determine the per-chiller capacity and sizing factor
+    per_chiller_sizing_factor = (1.0 / num_chillers).round(2)
+    per_chiller_cap_w = cap_w / num_chillers
+
+    # Set the sizing factor and the chiller types
+    # chillers.each_with_index do |chiller, i|
+    for i in 0..num_chillers - 1
+      # if not enough chillers exist, create a new one. Else reference the i'th chiller
+      if i <= chillers.length - 1
+        chiller = chillers[i]
+      else
+        chiller = OpenStudio::Model::ChillerElectricEIR.new(model)
+        plant_loop.addSupplyBranchForComponent(chiller)
+        chiller.setReferenceLeavingChilledWaterTemperature(dsgn_sup_wtr_temp_c)
+        chiller.setLeavingChilledWaterLowerTemperatureLimit(OpenStudio.convert(36.0, 'F', 'C').get)
+        chiller.setReferenceEnteringCondenserFluidTemperature(OpenStudio.convert(95.0, 'F', 'C').get)
+        chiller.setMinimumPartLoadRatio(0.15)
+        chiller.setMaximumPartLoadRatio(1.0)
+        chiller.setOptimumPartLoadRatio(1.0)
+        chiller.setMinimumUnloadingRatio(0.25)
+        chiller.setChillerFlowMode('ConstantFlow')
+        chiller.setReferenceCOP(default_cop)
+
+        condenser_water_loop.get.addDemandBranchForComponent(chiller) if condenser_water_loop.is_initialized
+
+      end
+
+      chiller.setName("#{template} #{chiller_cooling_type} #{chiller_compressor_type} Chiller #{i + 1} of #{num_chillers}")
+      chiller.setSizingFactor(per_chiller_sizing_factor)
+      chiller.setReferenceCapacity(per_chiller_cap_w)
+      chiller.setCondenserType(chiller_cooling_type)
+      chiller.additionalProperties.setFeature('compressor_type', chiller_compressor_type)
+
+      # Add inlet pump
+      new_pump = OpenStudio::Model::PumpVariableSpeed.new(plant_loop.model)
+      new_pump.setName("#{chiller.name} Inlet Pump")
+      new_pump.setRatedPumpHead(original_pump.ratedPumpHead / num_chillers)
+
+      pump_variable_speed_set_control_type(new_pump, control_type = 'Riding Curve')
+      chiller_inlet_node = chiller.connectedObject(chiller.supplyInletPort).get.to_Node.get
+      new_pump.addToNode(chiller_inlet_node)
+
+    end
+
+    # Remove original pump, dedicated chiller pumps have all been added
+    original_pump.remove
+
+    OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.PlantLoop', "For #{plant_loop.name}, there are #{chillers.size} #{chiller_cooling_type} #{chiller_compressor_type} chillers.")
+
+    # Check for a heat exchanger fluid to fluid-- that lets you know if this is a primary loop
+    has_secondary_plant_loop = !plant_loop.demandComponents(OpenStudio::Model::HeatExchangerFluidToFluid.iddObjectType).empty?
+
+    if has_secondary_plant_loop
+      # Add EMS to stage chillers if there's a primary/secondary configuration
+      if num_chillers > 3
+        OpenStudio.logFree(OpenStudio::Error, 'prm.log', "For #{plant_loop.name} has more than 3 chillers. We do not have an EMS strategy for that yet.")
+      elsif num_chillers > 1
+        add_ems_for_multiple_chiller_pumps_w_secondary_plant(model, plant_loop)
+      end
+    end
+
+    return true
+  end
+
+  # Adds EMS program for pumps serving 3 chillers on primary + secondary loop. This was due to an issue when modeling two
+  # dedicated loops. The headered pumps or dedicated constant speed pumps operate at full flow as long as there's a
+  # load on the loop unless this EMS is in place.
+  # @param model [OpenStudio::Model] OpenStudio model with plant loops
+  # @param primary_plant [OpenStudio::Model::PlantLoop] Primary chilled water loop with chillers
+  def add_ems_for_multiple_chiller_pumps_w_secondary_plant(model, primary_plant)
+    # Aggregate array of chillers on primary plant supply side
+    chiller_list = []
+
+    primary_plant.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
+        chiller_list << sc.to_ChillerElectricEIR.get
       end
     end
 
-    # Ensure there is only 1 chiller to start
-    first_chiller = nil
-    return true if chillers.empty?
+    num_of_chillers = chiller_list.length # Either 2 or 3
 
-    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]
+    return if num_of_chillers <= 1
+
+    plant_name = primary_plant.name.to_s
+
+    # Make a variable to track the chilled water demand
+    chw_sensor = OpenStudio::Model::EnergyManagementSystemSensor.new(model, 'Plant Supply Side Cooling Demand Rate')
+    chw_sensor.setKeyName(plant_name)
+    chw_sensor.setName("#{plant_name.gsub(/[-\s]+/, '_')}_CHW_DEMAND")
+
+    # Sort chillers by their reference capacity
+    sorted_chiller_list = chiller_list.sort_by { |chiller| chiller.referenceCapacity.get.to_f}
+
+    # Make pump specific parameters for EMS. Use counter
+    sorted_chiller_list.each_with_index do |chiller, i|
+      # Get chiller pump
+      pump_name = "#{chiller.name} Inlet Pump"
+      pump = model.getPumpVariableSpeedByName(pump_name).get
+
+      # Set EMS names
+      ems_pump_flow_name   =      "CHILLER_PUMP_#{i + 1}_FLOW"
+      ems_pump_status_name =      "CHILLER_PUMP_#{i + 1}_STATUS"
+      ems_pump_design_flow_name = "CHILLER_PUMP_#{i + 1}_DES_FLOW"
+
+      # ---- Actuators ----
+
+      # Pump Flow Actuator
+      actuator_pump_flow = OpenStudio::Model::EnergyManagementSystemActuator.new(pump, 'Pump', 'Pump Mass Flow Rate')
+      actuator_pump_flow.setName(ems_pump_flow_name)
+
+      # Pump Status Actuator
+      actuator_pump_status = OpenStudio::Model::EnergyManagementSystemActuator.new(pump,
+                                                                                   'Plant Component Pump:VariableSpeed',
+                                                                                   'On/Off Supervisory')
+      actuator_pump_status.setName(ems_pump_status_name)
+
+      # ---- Internal Variable ----
+
+      internal_variable = OpenStudio::Model::EnergyManagementSystemInternalVariable.new(model, 'Pump Maximum Mass Flow Rate')
+      internal_variable.setInternalDataIndexKeyName(pump_name)
+      internal_variable.setName(ems_pump_design_flow_name)
     end
 
-    # Ensure there is only 1 pump to start
-    orig_pump = nil
-    if pumps.empty?
-      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]
+    # Write EMS program
+    if num_of_chillers > 3
+      OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.PlantLoop', "EMS Code for multiple chiller pump has not been written for greater than 2 chillers. This has #{num_of_chillers} chillers")
+    elsif num_of_chillers == 3
+      add_ems_program_for_3_pump_chiller_plant(model, sorted_chiller_list, primary_plant)
+    elsif num_of_chillers == 2
+      add_ems_program_for_2_pump_chiller_plant(model, sorted_chiller_list, primary_plant)
     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
+    # Update chilled water loop operation scheme to work with updated EMS ranges
+    stage_chilled_water_loop_operation_schemes(model, primary_plant)
+  end
 
-    # 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
+  # Updates a chilled water plant's operation scheme to match the EMS written by either
+  # add_ems_program_for_3_pump_chiller_plant or add_ems_program_for_2_pump_chiller_plant
+  # @param model [OpenStudio::Model] OpenStudio model with plant loops
+  # @param chilled_water_loop [OpenStudio::Model::PlantLoop] chilled water loop
+  def stage_chilled_water_loop_operation_schemes(model, chilled_water_loop)
+    # Initialize array of cooling plant systems
+    chillers = []
 
-    # 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
+    # Gets all associated chillers from the supply side and adds them to the chillers list
+    chilled_water_loop.supplyComponents(OpenStudio::Model::ChillerElectricEIR.iddObjectType).each do |chiller|
+      chillers << chiller.to_ChillerElectricEIR.get
+    end
 
-      final_chillers << new_chiller
+    # Skip those without chillers or only 1 (i.e., nothing to stage)
+    return if chillers.empty?
+    return if chillers.length == 1
+
+    # Sort chillers by capacity
+    sorted_chillers = chillers.sort_by { |chiller| chiller.referenceCapacity.get }
+
+    primary_chiller = sorted_chillers[0]
+    secondary_1_chiller = sorted_chillers[1]
+    secondary_2_chiller = sorted_chillers[2] if chillers.length == 3
+
+    equip_operation_cool_load = OpenStudio::Model::PlantEquipmentOperationCoolingLoad.new(model)
+
+    # Calculate load ranges into the PlantEquipmentOperation:CoolingLoad
+    loading_factor = 0.8
+    # # when the capacity of primary chiller is larger than the capacity of secondary chiller - the loading factor
+    # # will need to be adjusted to avoid load range intersect.
+    # if secondary_1_chiller.referenceCapacity.get <= primary_chiller.referenceCapacity.get * loading_factor
+    #   # Adjustment_factor can creates a bandwidth for step 2 staging strategy.
+    #   # set adjustment_factor = 1.0 means the step 2 staging strategy is skipped
+    #   adjustment_factor = 1.0
+    #   loading_factor = secondary_1_chiller.referenceCapacity.get / primary_chiller.referenceCapacity.get * adjustment_factor
+    # end
+
+    if chillers.length == 3
+
+      # Add four ranges for small, medium, and large chiller capacities
+      # 1: 0 W -> 80% of smallest chiller capacity
+      # 2: 80% of primary chiller -> medium size chiller capacity
+      # 3: medium chiller capacity -> medium + large chiller capacity
+      # 4: medium + large chiller capacity -> infinity
+      # Control strategy first stage
+      equipment_list = [primary_chiller]
+      range = primary_chiller.referenceCapacity.get * loading_factor
+      equip_operation_cool_load.addLoadRange(range, equipment_list)
+
+      # Control strategy second stage
+      equipment_list = [secondary_1_chiller]
+      range = secondary_1_chiller.referenceCapacity.get
+      equip_operation_cool_load.addLoadRange(range, equipment_list)
+
+      # Control strategy third stage
+      equipment_list = [secondary_1_chiller, secondary_2_chiller]
+      range = secondary_1_chiller.referenceCapacity.get + secondary_2_chiller.referenceCapacity.get
+      equip_operation_cool_load.addLoadRange(range, equipment_list)
+
+      equipment_list = [primary_chiller, secondary_1_chiller, secondary_2_chiller]
+      range = 999999999
+      equip_operation_cool_load.addLoadRange(range, equipment_list)
+
+    elsif chillers.length == 2
+
+      # Add three ranges for primary and secondary chiller capacities
+      # 1: 0 W -> 80% of smallest chiller capacity
+      # 2: 80% of primary chiller -> secondary chiller capacity
+      # 3: secondary chiller capacity -> infinity
+      # Control strategy first stage
+      equipment_list = [primary_chiller]
+      range = primary_chiller.referenceCapacity.get * loading_factor
+      equip_operation_cool_load.addLoadRange(range, equipment_list)
+
+      # Control strategy second stage
+      equipment_list = [secondary_1_chiller]
+      range = secondary_1_chiller.referenceCapacity.get
+      equip_operation_cool_load.addLoadRange(range, equipment_list)
+
+      # Control strategy third stage
+      equipment_list = [primary_chiller, secondary_1_chiller]
+      range = 999999999
+      equip_operation_cool_load.addLoadRange(range, equipment_list)
+
+    else
+      raise "Failed to stage chillers, #{chillers.length} chillers found in the loop.Logic for staging chillers has only been done for either 2 or 3 chillers"
     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
+    chilled_water_loop.setPlantEquipmentOperationCoolingLoad(equip_operation_cool_load)
+  end
+
+  # Adds EMS program for pumps serving 2 chillers on primary + secondary loop. This was due to an issue when modeling two
+  # dedicated loops. The headered pumps or dedicated constant speed pumps operate at full flow as long as there's a
+  # load on the loop unless this EMS is in place.
+  # @param model [OpenStudio::Model] OpenStudio model with plant loops
+  # @param sorted_chiller_list [Array] Array of chillers in primary_plant sorted by capacity
+  # @param primary_plant [OpenStudio::Model::PlantLoop] Primary chilled water loop with chillers
+  def add_ems_program_for_2_pump_chiller_plant(model, sorted_chiller_list, primary_plant)
+    plant_name = primary_plant.name.to_s
+
+    # Break out sorted chillers and get their respective capacities
+    small_chiller = sorted_chiller_list[0]
+    large_chiller = sorted_chiller_list[1]
+
+    capacity_small_chiller = small_chiller.referenceCapacity.get
+    capacity_large_chiller = large_chiller.referenceCapacity.get
+
+    chw_demand = "#{primary_plant.name.to_s.gsub(/[-\s]+/, '_')}_CHW_DEMAND"
+
+    ems_pump_program = OpenStudio::Model::EnergyManagementSystemProgram.new(model)
+    ems_pump_program.setName("#{plant_name.gsub(/[-\s]+/, '_')}_Pump_EMS")
+    ems_pump_program.addLine('SET CHILLER_PUMP_1_STATUS = NULL,  !- Program Line 1')
+    ems_pump_program.addLine('SET CHILLER_PUMP_2_STATUS = NULL,  !- Program Line 2')
+    ems_pump_program.addLine('SET CHILLER_PUMP_1_FLOW = NULL,  !- A3')
+    ems_pump_program.addLine('SET CHILLER_PUMP_2_FLOW = NULL,  !- A4')
+    ems_pump_program.addLine("IF #{chw_demand} <= #{0.8 * capacity_small_chiller},  !- A5")
+    ems_pump_program.addLine('SET CHILLER_PUMP_2_STATUS = 0,  !- A6')
+    ems_pump_program.addLine('SET CHILLER_PUMP_2_FLOW = 0,  !- A7')
+    ems_pump_program.addLine("ELSEIF #{chw_demand} <= #{capacity_large_chiller},  !- A8")
+    ems_pump_program.addLine('SET CHILLER_PUMP_1_STATUS = 0,  !- A9')
+    ems_pump_program.addLine('SET CHILLER_PUMP_2_STATUS = 1,  !- A10')
+    ems_pump_program.addLine('SET CHILLER_PUMP_1_FLOW = 0,  !- A11')
+    ems_pump_program.addLine('SET CHILLER_PUMP_2_FLOW = CHILLER_PUMP_2_DES_FLOW,  !- A12')
+    ems_pump_program.addLine("ELSEIF #{chw_demand} > #{capacity_large_chiller},  !- A13")
+    ems_pump_program.addLine('SET CHILLER_PUMP_1_STATUS = 1,  !- A14')
+    ems_pump_program.addLine('SET CHILLER_PUMP_2_STATUS = 1,  !- A15')
+    ems_pump_program.addLine('SET CHILLER_PUMP_1_FLOW = CHILLER_PUMP_1_DES_FLOW,  !- A16')
+    ems_pump_program.addLine('SET CHILLER_PUMP_2_FLOW = CHILLER_PUMP_2_DES_FLOW,  !- A17')
+    ems_pump_program.addLine('ENDIF  !- A18')
+
+    ems_pump_program_manager = OpenStudio::Model::EnergyManagementSystemProgramCallingManager.new(model)
+    ems_pump_program_manager.setName("#{plant_name.gsub(/[-\s]+/, '_')}_Pump_Program_Manager")
+    ems_pump_program_manager.setCallingPoint('InsideHVACSystemIterationLoop')
+    ems_pump_program_manager.addProgram(ems_pump_program)
+  end
+
+  # Adds EMS program for pumps serving 3 chillers on primary + secondary loop. This was due to an issue when modeling two
+  # dedicated loops. The headered pumps or dedicated constant speed pumps operate at full flow as long as there's a
+  # load on the loop unless this EMS is in place.
+  # @param model [OpenStudio::Model] OpenStudio model with plant loops
+  # @param sorted_chiller_list [Array] Array of chillers in primary_plant sorted by capacity
+  # @param primary_plant [OpenStudio::Model::PlantLoop] Primary chilled water loop with chillers
+  def add_ems_program_for_3_pump_chiller_plant(model, sorted_chiller_list, primary_plant)
+    plant_name = primary_plant.name.to_s
+
+    # Break out sorted chillers and get their respective capacities
+    primary_chiller = sorted_chiller_list[0]
+    medium_chiller = sorted_chiller_list[1]
+    large_chiller = sorted_chiller_list[2]
+
+    capacity_80_pct_small = 0.8 * primary_chiller.referenceCapacity.get
+    capacity_medium_chiller = medium_chiller.referenceCapacity.get
+    capacity_large_chiller = large_chiller.referenceCapacity.get
+
+    if capacity_80_pct_small >= capacity_medium_chiller
+      first_stage_capacity = capacity_medium_chiller
+    else
+      first_stage_capacity = capacity_80_pct_small
     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)
+    chw_demand = "#{primary_plant.name.to_s.gsub(/[-\s]+/, '_')}_CHW_DEMAND"
+
+    ems_pump_program = OpenStudio::Model::EnergyManagementSystemProgram.new(model)
+    ems_pump_program.setName("#{plant_name.gsub(/[-\s]+/, '_')}_Pump_EMS")
+    ems_pump_program.addLine('SET CHILLER_PUMP_1_STATUS = NULL,  !- Program Line 1')
+    ems_pump_program.addLine('SET CHILLER_PUMP_2_STATUS = NULL,  !- Program Line 2')
+    ems_pump_program.addLine('SET CHILLER_PUMP_3_STATUS = NULL,  !- A4')
+    ems_pump_program.addLine('SET CHILLER_PUMP_1_FLOW = NULL,  !- A5')
+    ems_pump_program.addLine('SET CHILLER_PUMP_2_FLOW = NULL,  !- A6')
+    ems_pump_program.addLine('SET CHILLER_PUMP_3_FLOW = NULL,  !- A7')
+    ems_pump_program.addLine("IF #{chw_demand} <= #{first_stage_capacity},  !- A8")
+    ems_pump_program.addLine('SET CHILLER_PUMP_2_STATUS = 0,  !- A9')
+    ems_pump_program.addLine('SET CHILLER_PUMP_3_STATUS = 0,  !- A10')
+    ems_pump_program.addLine('SET CHILLER_PUMP_2_FLOW = 0,  !- A11')
+    ems_pump_program.addLine('SET CHILLER_PUMP_3_FLOW = 0,  !- A12')
+
+    if capacity_80_pct_small < capacity_medium_chiller
+      ems_pump_program.addLine("ELSEIF #{chw_demand} <= #{capacity_medium_chiller},  !- A13")
+      ems_pump_program.addLine('SET CHILLER_PUMP_1_STATUS = 0,  !- A14')
+      ems_pump_program.addLine('SET CHILLER_PUMP_2_STATUS = 1,  !- A15')
+      ems_pump_program.addLine('SET CHILLER_PUMP_3_STATUS = 0,  !- A16')
+      ems_pump_program.addLine('SET CHILLER_PUMP_1_FLOW = 0,  !- A17')
+      ems_pump_program.addLine('SET CHILLER_PUMP_2_FLOW = CHILLER_PUMP_2_DES_FLOW,  !- A18')
+      ems_pump_program.addLine('SET CHILLER_PUMP_3_FLOW = 0,  !- A19')
     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
+    ems_pump_program.addLine("ELSEIF #{chw_demand} <= #{capacity_medium_chiller + capacity_large_chiller},  !- A20")
+    ems_pump_program.addLine('SET CHILLER_PUMP_1_STATUS = 0,  !- A21')
+    ems_pump_program.addLine('SET CHILLER_PUMP_2_STATUS = 1,  !- A22')
+    ems_pump_program.addLine('SET CHILLER_PUMP_3_STATUS = 1,  !- A23')
+    ems_pump_program.addLine('SET CHILLER_PUMP_1_FLOW = 0,  !- A24')
+    ems_pump_program.addLine('SET CHILLER_PUMP_2_FLOW = CHILLER_PUMP_2_DES_FLOW,  !- A25')
+    ems_pump_program.addLine('SET CHILLER_PUMP_3_FLOW = CHILLER_PUMP_3_DES_FLOW,  !- A26')
+    ems_pump_program.addLine("ELSEIF #{chw_demand} > #{capacity_medium_chiller + capacity_large_chiller},  !- A27")
+    ems_pump_program.addLine('SET CHILLER_PUMP_1_STATUS = 1,  !- A28')
+    ems_pump_program.addLine('SET CHILLER_PUMP_2_STATUS = 1,  !- A29')
+    ems_pump_program.addLine('SET CHILLER_PUMP_3_STATUS = 1,  !- A30')
+    ems_pump_program.addLine('SET CHILLER_PUMP_1_FLOW = CHILLER_PUMP_1_DES_FLOW,  !- A31')
+    ems_pump_program.addLine('SET CHILLER_PUMP_2_FLOW = CHILLER_PUMP_2_DES_FLOW,  !- A32')
+    ems_pump_program.addLine('SET CHILLER_PUMP_3_FLOW = CHILLER_PUMP_3_DES_FLOW,  !- A33')
+    ems_pump_program.addLine('ENDIF  !- A34')
+
+    ems_pump_program_manager = OpenStudio::Model::EnergyManagementSystemProgramCallingManager.new(model)
+    ems_pump_program_manager.setName("#{plant_name.gsub(/[-\s]+/, '_')}_Pump_Program_Manager")
+    ems_pump_program_manager.setCallingPoint('InsideHVACSystemIterationLoop')
+    ems_pump_program_manager.addProgram(ems_pump_program)
   end
 
   # Apply prm baseline pump power

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

@@ -552,7 +552,7 @@ class ASHRAE901PRM < Standard
       space_area = space.floorArea
       space_height = OpenStudio.convert(space_volume / space_area, 'm', 'ft').get
       # calculate the new lpd values
-      space_lighting_per_area = (lighting_per_length * space_height) + lighting_per_area
+      space_lighting_per_area = ((lighting_per_length * space_height) / space_area) + lighting_per_area
 
       # Adjust the occupancy control sensor reduction factor from dataset
       if manon_or_partauto == 1
@@ -652,7 +652,7 @@ class ASHRAE901PRM < Standard
         space_area = space.floorArea
         space_height = OpenStudio.convert(space_volume / space_area, 'm', 'ft').get
         # calculate and add new lpd values
-        user_space_type_lighting_per_area = ((lighting_per_length * space_height) + lighting_per_area) * sub_space_type_frac
+        user_space_type_lighting_per_area = (((lighting_per_length * space_height) / space_area) + lighting_per_area) * sub_space_type_frac
         space_lighting_per_area += user_space_type_lighting_per_area
 
         # Adjust the occupancy control sensor reduction factor from dataset

data/lib/openstudio-standards/standards/ashrae_90_1_prm/ashrae_90_1_prm_2019/ashrae_90_1_prm_2019.Model.rb

@@ -37,13 +37,13 @@ class ASHRAE901PRM2019 < ASHRAE901PRM
           wwr_range['minimum_percent_of_surface'] = 0
           wwr_range['maximum_percent_of_surface'] = 10
         elsif wwr_info[wwr_building_type] <= 20
-          wwr_range['minimum_percent_of_surface'] = 10.1
+          wwr_range['minimum_percent_of_surface'] = 10.001
           wwr_range['maximum_percent_of_surface'] = 20
         elsif wwr_info[wwr_building_type] <= 30
-          wwr_range['minimum_percent_of_surface'] = 20.1
+          wwr_range['minimum_percent_of_surface'] = 20.001
           wwr_range['maximum_percent_of_surface'] = 30
         elsif wwr_info[wwr_building_type] <= 40
-          wwr_range['minimum_percent_of_surface'] = 30.1
+          wwr_range['minimum_percent_of_surface'] = 30.001
           wwr_range['maximum_percent_of_surface'] = 40
         else
           wwr_range['minimum_percent_of_surface'] = nil