openstudio-standards 0.1.4 → 0.1.5

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

@@ -1,8 +1,7 @@
 # Reopen the OpenStudio class to add methods to apply standards to this object
 class OpenStudio::Model::PlanarSurface
-
-  # If construction properties can be found 
-  # based on the template, 
+  # 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,
@@ -20,67 +19,116 @@ class OpenStudio::Model::PlanarSurface
   # [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 apply_standard_construction(template, climate_zone, previous_construction_map = {})
-
     # Skip surfaces not in a space
-    return previous_construction_map if self.space.empty?
+    return previous_construction_map if space.empty?
     space = self.space.get
-   
+
     # Skip surfaces that don't have a construction
-    return previous_construction_map if self.construction.empty?
+    return previous_construction_map if construction.empty?
     construction = self.construction.get
-    
+
     # Determine if residential or nonresidential
     # based on the space type.
     occ_type = 'Nonresidential'
-    if space.spaceType.is_initialized
-      space_type = space.spaceType.get
-      space_type_props = space_type.get_standards_data(template)
-      if space_type_props['is_residential']
-        occ_type = 'Residential'
-      end
+    if space.residential?(template)
+      occ_type = 'Residential'
     end
-    
+
     # Get the climate zone set
-    climate_zone_set = self.model.find_climate_zone_set(climate_zone, template)
-    
+    climate_zone_set = model.find_climate_zone_set(climate_zone, template)
+
     # Get the intended surface type
     standards_info = construction.standardsInformation
-    intended_surface_type = standards_info.intendedSurfaceType
-    standards_construction_type = standards_info.standardsConstructionType
-    if intended_surface_type.empty? || standards_construction_type.empty?
-      OpenStudio::logFree(OpenStudio::Warn, "openstudio.model.PlanarSurface", "Could not determine one or more of the intended surface type or the standards construction type for #{self.name}.  This surface will not have the standard applied.")
+    surf_type = standards_info.intendedSurfaceType
+    if surf_type.empty?
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.model.PlanarSurface', "Could not determine the intended surface type for #{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
+    if surf_type == 'ExteriorWindow'
+      stds_type = standards_info.fenestrationFrameType
+      if stds_type.is_initialized
+        stds_type = stds_type.get
+        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)'
+        else
+          OpenStudio.logFree(OpenStudio::Warn, 'openstudio.model.PlanarSurface', "The standards fenestration frame type #{stds_type} cannot be used on #{surf_type} in #{name}.  This surface will not have the standard applied.")
+          return previous_construction_map
+        end
+      else
+        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.model.PlanarSurface', "Could not determine the standards fenestration frame type for #{name} from #{construction.name}.  This surface will not have the standard applied.")
+        return previous_construction_map
+      end
+    # Skylights
+    elsif surf_type == 'Skylight'
+      stds_type = standards_info.fenestrationType
+      if stds_type.is_initialized
+        stds_type = stds_type.get
+        case stds_type
+        when 'Glass Skylight with Curb'
+          stds_type = 'Glass with Curb'
+        when 'Plastic Skylight with Curb'
+          stds_type = 'Plastic with Curb'
+        when 'Plastic Skylight without Curb', 'Glass Skylight without Curb'
+          stds_type = 'Without Curb'
+        else
+          OpenStudio.logFree(OpenStudio::Warn, 'openstudio.model.PlanarSurface', "The standards fenestration type #{stds_type} cannot be used on #{surf_type} in #{name}.  This surface will not have the standard applied.")
+          return previous_construction_map
+        end
+      else
+        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.model.PlanarSurface', "Could not determine the standards fenestration type for #{name} from #{construction.name}.  This surface will not have the standard applied.")
+        return previous_construction_map
+      end
+    # All other surface types
+    else
+      stds_type = standards_info.standardsConstructionType
+      if stds_type.is_initialized
+        stds_type = stds_type.get
+      else
+        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.model.PlanarSurface', "Could not determine the standards construction type for #{name}.  This surface will not have the standard applied.")
+        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.
     new_construction = nil
-    type = [template, climate_zone, intended_surface_type.get, standards_construction_type.get, occ_type]
+    type = [template, climate_zone, surf_type, stds_type, occ_type]
     if previous_construction_map[type]
       new_construction = previous_construction_map[type]
     else
-      new_construction = self.model.find_and_add_construction(template,
-                                                  climate_zone_set,
-                                                  intended_surface_type.get,
-                                                  standards_construction_type.get,
-                                                  occ_type)
+      new_construction = model.find_and_add_construction(template,
+                                                         climate_zone_set,
+                                                         surf_type,
+                                                         stds_type,
+                                                         occ_type)
       if !new_construction == false
         previous_construction_map[type] = new_construction
       end
     end
-    
+
     # Assign the new construction to the surface
     if new_construction
-      self.setConstruction(new_construction)
-      OpenStudio::logFree(OpenStudio::Debug, "openstudio.model.PlanarSurface", "Set the construction for #{self.name} to #{new_construction.name}.")
+      setConstruction(new_construction)
+      OpenStudio.logFree(OpenStudio::Debug, 'openstudio.model.PlanarSurface', "Set the construction for #{name} to #{new_construction.name}.")
     else
-      OpenStudio::logFree(OpenStudio::Warn, "openstudio.model.PlanarSurface", "Could not generate a standard construction for #{self.name}.")
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.model.PlanarSurface', "Could not generate a standard construction for #{name}.")
       return previous_construction_map
     end
-    
-    return previous_construction_map 
- 
-  end
 
+    return previous_construction_map
+  end
 end

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

@@ -1,95 +1,83 @@
 
 # Reopen the OpenStudio class to add methods to apply standards to this object
 class OpenStudio::Model::PlantLoop
-
   # Apply all standard required controls to the plantloop
   #
-  # @param (see #is_economizer_required)
+  # @param (see #economizer_required?)
   # @return [Bool] returns true if successful, false if not
   def apply_standard_controls(template, climate_zone)
-    
     # Variable flow system
-    if self.is_variable_flow_required(template)
-      self.enable_variable_flow(template)
-    end
-    
-    # Supply water temperature reset
-    if self.is_supply_water_temperature_reset_required(template)
-      self.enable_supply_water_temperature_reset
-    end
+    enable_variable_flow(template) if is_variable_flow_required(template)
 
-  end  
+    # Supply water temperature reset
+    enable_supply_water_temperature_reset if supply_water_temperature_reset_required?(template)
+  end
 
   def enable_variable_flow(template)
-  
   end
-  
-  def is_variable_flow_system
-    
+
+  def variable_flow_system?
     variable_flow = false
-    
+
     # Modify all the primary pumps
-    self.supplyComponents.each do |sc|
+    supplyComponents.each do |sc|
       if sc.to_PumpVariableSpeed.is_initialized
         variable_flow = true
       end
     end
-    
+
     # Modify all the secondary pumps
-    self.demandComponents.each do |sc|
+    demandComponents.each do |sc|
       if sc.to_PumpVariableSpeed.is_initialized
         variable_flow = true
       end
     end
-    
+
     return variable_flow
-  
   end
 
-
-  # Todo: I think it makes more sense to sense the motor efficiency right there...
+  # TODO: 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 pressurise rise to have your 19 W/GPM or whatever
-  def apply_performance_rating_method_baseline_pump_power(template)
-    
+  def apply_prm_baseline_pump_power(template)
     # Determine the pumping power per
     # flow based on loop type.
     pri_w_per_gpm = nil
     sec_w_per_gpm = nil
 
-    sizing_plant = self.sizingPlant
-    loop_type = sizing_plant.loopType    
-    
+    sizing_plant = sizingPlant
+    loop_type = sizing_plant.loopType
+
     case loop_type
     when 'Heating'
-    
+
       has_district_heating = false
-      self.supplyComponents.each do |sc|
+      supplyComponents.each do |sc|
         if sc.to_DistrictHeating.is_initialized
           has_district_heating = true
         end
       end
 
-      if has_district_heating # District HW
-        pri_w_per_gpm = 14.0
-      else # HW 
-        pri_w_per_gpm = 19.0
-      end
+      pri_w_per_gpm = if has_district_heating # District HW
+                        14.0
+                      else # HW
+                        19.0
+                      end
 
     when 'Cooling'
-  
+
       has_district_cooling = false
-      self.supplyComponents.each do |sc|
+      supplyComponents.each do |sc|
         if sc.to_DistrictCooling.is_initialized
           has_district_cooling = true
         end
       end
-  
+
       has_secondary_pump = false
-      self.demandComponents.each do |sc|
+      demandComponents.each do |sc|
         if sc.to_PumpConstantSpeed.is_initialized || sc.to_PumpVariableSpeed.is_initialized
           has_secondary_pump = true
         end
-      end  
+      end
 
       if has_district_cooling # District CHW
         pri_w_per_gpm = 16.0
@@ -101,73 +89,83 @@ class OpenStudio::Model::PlantLoop
       end
 
     when 'Condenser'
-    
-      # TODO prm condenser loop pump power
+
+      # TODO: prm condenser loop pump power
       pri_w_per_gpm = 19.0
 
     end
-  
+
     # Modify all the primary pumps
-    self.supplyComponents.each do |sc|
+    supplyComponents.each do |sc|
       if sc.to_PumpConstantSpeed.is_initialized
         pump = sc.to_PumpConstantSpeed.get
-        pump.set_performance_rating_method_pressure_rise_and_motor_efficiency(pri_w_per_gpm, template)
+        pump.apply_prm_pressure_rise_and_motor_efficiency(pri_w_per_gpm, template)
       elsif sc.to_PumpVariableSpeed.is_initialized
         pump = sc.to_PumpVariableSpeed.get
-        pump.set_performance_rating_method_pressure_rise_and_motor_efficiency(pri_w_per_gpm, template)
+        pump.apply_prm_pressure_rise_and_motor_efficiency(pri_w_per_gpm, template)
+      elsif sc.to_HeaderedPumpsConstantSpeed.is_initialized
+        pump = sc.to_HeaderedPumpsConstantSpeed.get
+        pump.apply_prm_pressure_rise_and_motor_efficiency(pri_w_per_gpm, template)
+      elsif sc.to_HeaderedPumpsVariableSpeed.is_initialized
+        pump = sc.to_HeaderedPumpsVariableSpeed.get
+        pump.apply_prm_pressure_rise_and_motor_efficiency(pri_w_per_gpm, template)
       end
     end
-    
+
     # Modify all the secondary pumps
-    self.demandComponents.each do |sc|
+    demandComponents.each do |sc|
       if sc.to_PumpConstantSpeed.is_initialized
         pump = sc.to_PumpConstantSpeed.get
-        pump.set_performance_rating_method_pressure_rise_and_motor_efficiency(sec_w_per_gpm, template)
+        pump.apply_prm_pressure_rise_and_motor_efficiency(sec_w_per_gpm, template)
       elsif sc.to_PumpVariableSpeed.is_initialized
         pump = sc.to_PumpVariableSpeed.get
-        pump.set_performance_rating_method_pressure_rise_and_motor_efficiency(sec_w_per_gpm, template)
+        pump.apply_prm_pressure_rise_and_motor_efficiency(sec_w_per_gpm, template)
+      elsif sc.to_HeaderedPumpsConstantSpeed.is_initialized
+        pump = sc.to_HeaderedPumpsConstantSpeed.get
+        pump.apply_prm_pressure_rise_and_motor_efficiency(pri_w_per_gpm, template)
+      elsif sc.to_HeaderedPumpsVariableSpeed.is_initialized
+        pump = sc.to_HeaderedPumpsVariableSpeed.get
+        pump.apply_prm_pressure_rise_and_motor_efficiency(pri_w_per_gpm, template)
       end
     end
-  
+
     return true
-  
   end
-  
-  def apply_performance_rating_method_baseline_temperatures(template)
-  
-    sizing_plant = self.sizingPlant
+
+  def apply_prm_baseline_temperatures(template)
+    sizing_plant = sizingPlant
     loop_type = sizing_plant.loopType
     case loop_type
     when 'Heating'
 
       # Loop properties
-      # G3.1.3.3 - HW Supply at 180°F, return at 130°F
+      # G3.1.3.3 - HW Supply at 180F, return at 130F
       hw_temp_f = 180
       hw_delta_t_r = 50
       min_temp_f = 50
-      
-      hw_temp_c = OpenStudio.convert(hw_temp_f,'F','C').get
-      hw_delta_t_k = OpenStudio.convert(hw_delta_t_r,'R','K').get
-      min_temp_c = OpenStudio.convert(min_temp_f,'F','C').get
+
+      hw_temp_c = OpenStudio.convert(hw_temp_f, 'F', 'C').get
+      hw_delta_t_k = OpenStudio.convert(hw_delta_t_r, 'R', 'K').get
+      min_temp_c = OpenStudio.convert(min_temp_f, 'F', 'C').get
 
       sizing_plant.setDesignLoopExitTemperature(hw_temp_c)
       sizing_plant.setLoopDesignTemperatureDifference(hw_delta_t_k)
-      self.setMinimumLoopTemperature(min_temp_c)
+      setMinimumLoopTemperature(min_temp_c)
 
       # ASHRAE Appendix G - G3.1.3.4 (for ASHRAE 90.1-2004, 2007 and 2010)
-      # HW reset: 180°F at 20°F and below, 150°F at 50°F and above
-      self.enable_supply_water_temperature_reset
+      # HW reset: 180F at 20F and below, 150F at 50F and above
+      enable_supply_water_temperature_reset
 
       # Boiler properties
-      self.supplyComponents.each do |sc|
+      supplyComponents.each do |sc|
         if sc.to_BoilerHotWater.is_initialized
           boiler = sc.to_BoilerHotWater.get
           boiler.setDesignWaterOutletTemperature(hw_temp_c)
         end
-      end   
-  
+      end
+
     when 'Cooling'
-    
+
       # Loop properties
       # G3.1.3.8 - LWT 44 / EWT 56
       chw_temp_f = 44
@@ -177,231 +175,288 @@ class OpenStudio::Model::PlantLoop
       # For water-cooled chillers this is the water temperature entering the condenser (e.g., leaving the cooling tower).
       ref_cond_wtr_temp_f = 85
 
-      chw_temp_c = OpenStudio.convert(chw_temp_f,'F','C').get
-      chw_delta_t_k = OpenStudio.convert(chw_delta_t_r,'R','K').get
-      min_temp_c = OpenStudio.convert(min_temp_f,'F','C').get
-      max_temp_c = OpenStudio.convert(max_temp_f,'F','C').get
-      ref_cond_wtr_temp_c = OpenStudio.convert(ref_cond_wtr_temp_f,'F','C').get
+      chw_temp_c = OpenStudio.convert(chw_temp_f, 'F', 'C').get
+      chw_delta_t_k = OpenStudio.convert(chw_delta_t_r, 'R', 'K').get
+      min_temp_c = OpenStudio.convert(min_temp_f, 'F', 'C').get
+      max_temp_c = OpenStudio.convert(max_temp_f, 'F', 'C').get
+      ref_cond_wtr_temp_c = OpenStudio.convert(ref_cond_wtr_temp_f, 'F', 'C').get
 
       sizing_plant.setDesignLoopExitTemperature(chw_temp_c)
       sizing_plant.setLoopDesignTemperatureDifference(chw_delta_t_k)
-      self.setMinimumLoopTemperature(min_temp_c)
-      self.setMaximumLoopTemperature(max_temp_c)
+      setMinimumLoopTemperature(min_temp_c)
+      setMaximumLoopTemperature(max_temp_c)
 
       # ASHRAE Appendix G - G3.1.3.9 (for ASHRAE 90.1-2004, 2007 and 2010)
-      # ChW reset: 44°F at 80°F and above, 54°F at 60°F and below
-      self.enable_supply_water_temperature_reset
-      
+      # ChW reset: 44F at 80F and above, 54F at 60F and below
+      enable_supply_water_temperature_reset
+
       # Chiller properties
-      self.supplyComponents.each do |sc|
+      supplyComponents.each do |sc|
         if sc.to_ChillerElectricEIR.is_initialized
           chiller = sc.to_ChillerElectricEIR.get
           chiller.setReferenceLeavingChilledWaterTemperature(chw_temp_c)
           chiller.setReferenceEnteringCondenserFluidTemperature(ref_cond_wtr_temp_c)
         end
       end
-      
+
     when 'Condenser'
-    
-      # G3.1.3.11 - LCnWT 85°F or 10°F approaching design wet bulb temperature, whichever is lower
-      # Design Temperature rise of 10°F => Range: 10°F
-      lcnwt_f = 85   # See notes and proposed alternative below, if we want to actually check the design days...
-      range_t_r = 10
-      lcnwt_c = OpenStudio.convert(lcnwt_f,'F','C').get
-      range_t_k = OpenStudio.convert(range_t_r,'R','K').get
-
-      # Typical design of min temp is really around 40°F (that's what basin heaters, when used, are sized for usually)
-      min_temp_f = 34
-      max_temp_f = 200
-      min_temp_c = OpenStudio.convert(min_temp_f,'F','C').get
-      max_temp_c = OpenStudio.convert(max_temp_f,'F','C').get
 
-      sizing_plant.setDesignLoopExitTemperature(lcnwt_c)
-      sizing_plant.setLoopDesignTemperatureDifference(range_t_k)
-      self.setMinimumLoopTemperature(min_temp_c)
-      self.setMaximumLoopTemperature(max_temp_c)
+      # Much of the thought in this section
+      # came from @jmarrec
+
+      # Determine the design OATwb from the design days.
+      # Per https://unmethours.com/question/16698/which-cooling-design-day-is-most-common-for-sizing-rooftop-units/
+      # the WB=>MDB day is used to size cooling towers.
+      summer_oat_wbs_f = []
+      model.getDesignDays.each do |dd|
+        next unless dd.dayType == 'SummerDesignDay'
+        next unless dd.name.get.to_s.include?('WB=>MDB')
+        if dd.humidityIndicatingType == 'Wetbulb'
+          summer_oat_wb_c = dd.humidityIndicatingConditionsAtMaximumDryBulb
+          summer_oat_wbs_f << OpenStudio.convert(summer_oat_wb_c, 'C', 'F').get
+        else
+          OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.PlantLoop', "For #{dd.name}, humidity is specified as #{dd.humidityIndicatingType}; cannot determine Twb.")
+        end
+      end
 
-      # G3.1.3.11 - Tower shall be controlled to maintain a 70°F LCnWT where weather permits
-      # Use a SetpointManager:FollowOutdoorAirTemperature
-      float_down_to_f = 70
-      float_down_to_c = OpenStudio.convert(float_down_to_f,'F','C').get
-
-      # Todo: Problem is what to set for Offset Temperature Difference (=approach):
-      # * if unreasonably low approach, fan runs full blast and energy consumption is penalized
-      # * if too high, you don't get as much energy savings...
-      # "LCnWT 85°F or 10°F approaching design wet bulb temperature, whichever is lower" ==> approach is maximum 10, could be less depending on design conditions
-      # In most cases in the US a tower will be sized on CTI conditions, 78°F WB, so usually 7°F approach.
-      # Could also check the design days, but begs the question of finding the right one to begin with if you have several...
-      # You'll need to deal with potentially different 'Humidity Indicating Type'
-      #
-      # See https://unmethours.com/question/12530/appendix-g-condenser-water-temperature-reset-in-energyplus/
-      # See http://www.comnet.org/mgp/content/cooling-towers?purpose=0#footnote1_do6jpuh
+      # Use the value from the design days or
+      # 78F, the CTI rating condition, if no
+      # design day information is available.
+      design_oat_wb_f = nil
+      if summer_oat_wbs_f.size.zero?
+        design_oat_wb_f = 78
+        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.PlantLoop', "For #{name}, no design day OATwb conditions were found.  CTI rating condition of 78F OATwb will be used for sizing cooling towers.")
+      else
+        # Take worst case condition
+        design_oat_wb_f = summer_oat_wbs_f.max
+      end
 
-      # This is an example of how jmarrec would implement checking the design days
-=begin
-summer_dday_wbs = []
-model.getDesignDays.each do |dd|
-  model.getDesignDays.each do |dd|
-    if dd.dayType == 'SummerDesignDay' && dd.humidityIndicatingType == 'Wetbulb'
-      summer_dday_wbs << dd.humidityIndicatingConditionsAtMaximumDryBulb
-    end
-  end
-end
+      # There is an EnergyPlus model limitation
+      # that the design_oat_wb_f < 80F
+      # for cooling towers
+      ep_max_design_oat_wb_f = 80
+      if design_oat_wb_f > ep_max_design_oat_wb_f
+        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.PlantLoop', "For #{name}, reduced design OATwb from #{design_oat_wb_f} F to E+ model max input of #{ep_max_design_oat_wb_f} F.")
+        design_oat_wb_f = ep_max_design_oat_wb_f
+      end
+
+      # Determine the design CW temperature, approach, and range
+      leaving_cw_t_f = nil
+      approach_r = nil
+      range_r = nil
+      case template
+      when 'DOE Ref Pre-1980', 'DOE Ref 1980-2004', '90.1-2004', '90.1-2007', '90.1-2010'
+        # G3.1.3.11 - CW supply temp = 85F or 10F approaching design wet bulb temperature,
+        # whichever is lower.  Design range = 10F
+        # Design Temperature rise of 10F => Range: 10F
+        range_r = 10
+
+        # Determine the leaving CW temp
+        max_leaving_cw_t_f = 85
+        leaving_cw_t_10f_approach_f = design_oat_wb_f + 10
+        leaving_cw_t_f = [max_leaving_cw_t_f, leaving_cw_t_10f_approach_f].max
+
+        # Calculate the approach
+        approach_r = leaving_cw_t_f - design_oat_wb_f
+
+      when '90.1-2013'
+        # G3.1.3.11 - CW supply temp shall be evaluated at 0.4% evaporative design OATwb
+        # per the formulat approach_F = 25.72 - (0.24 * OATwb_F)
+        # 55F <= OATwb <= 90F
+        # Design range = 10F.
+        range_r = 10
+
+        # Limit the OATwb
+        if design_oat_wb_f < 55
+          design_oat_wb_f = 55
+          OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.PlantLoop', "For #{name}, a design OATwb of 55F will be used for sizing the cooling towers because the actual design value is below the limit in G3.1.3.11.")
+        elsif design_oat_wb_f > 90
+          design_oat_wb_f = 90
+          OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.PlantLoop', "For #{name}, a design OATwb of 90F will be used for sizing the cooling towers because the actual design value is above the limit in G3.1.3.11.")
+        end
 
-# Then take worst case condition (max), or the average?
-design_inlet_wb_c = summer_dday_wbs.max
-design_inlet_wb_f = OpenStudio.convert(design_inlet_wb_c,'C','F').get
-lcnwt_f = 85
-lcnwt_10f_approach = design_inlet_wb_f+10
-lcnwt_f = lcnwt_10f_approach if lcnwt_10f_approach < 85
+        # Calculate the approach
+        approach_r = 25.72 - (0.24 * design_oat_wb_f)
 
+        # Calculate the leaving CW temp
+        leaving_cw_t_f = design_oat_wb_f + approach_r
 
+      end
 
-=end
+      # Report out design conditions
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.PlantLoop', "For #{name}, design OATwb = #{design_oat_wb_f.round(1)} F, approach = #{approach_r.round(1)} deltaF, range = #{range_r.round(1)} deltaF, leaving condenser water temperature = #{leaving_cw_t_f.round(1)} F.")
 
-      design_inlet_wb_f = 78
-      design_approach_r = 7
-      design_inlet_wb_c = OpenStudio.convert(design_inlet_wb_f,'F','C').get
-      design_approach_k = OpenStudio.convert(design_approach_r,'R','K').get
+      # Convert to SI units
+      leaving_cw_t_c = OpenStudio.convert(leaving_cw_t_f, 'F', 'C').get
+      approach_k = OpenStudio.convert(approach_r, 'R', 'K').get
+      range_k = OpenStudio.convert(range_r, 'R', 'K').get
+      design_oat_wb_c = OpenStudio.convert(design_oat_wb_f, 'F', 'C').get
 
-      cw_t_stpt_manager = OpenStudio::Model::SetpointManagerFollowOutdoorAirTemperature.new(self.model)
-      cw_t_stpt_manager.setReferenceTemperatureType('OutdoorAirWetBulb')
-      cw_t_stpt_manager.setMaximumSetpointTemperature(lcnwt_c)
-      cw_t_stpt_manager.setMinimumSetpointTemperature(float_down_to_c)
-      cw_t_stpt_manager.setOffsetTemperatureDifference(design_approach_k)
-      cw_t_stpt_manager.addToNode(self.supplyOutletNode)
-
-      # Cooling Tower properties
-      self.supplyComponents.each do |sc|
-        if sc.to_CoolingTowerSingleSpeed.is_initialized
-          ct = sc.to_CoolingTowerSingleSpeed.get
-          ct.setDesignInletAirWetBulbTemperature(design_inlet_wb_c)
-          ct.setDesignApproachTemperature(design_approach_k)
-          ct.setDesignRangeTemperature(range_t_k)
-        elsif sc.to_CoolingTowerTwoSpeed.is_initialized
-          ct = sc.to_CoolingTowerTwoSpeed.get
-          ct.setDesignInletAirWetBulbTemperature(design_inlet_wb_c)
-          ct.setDesignApproachTemperature(design_approach_k)
-          ct.setDesignRangeTemperature(range_t_k)
-        elsif sc.to_CoolingTowerVariableSpeed.is_initialized
+      # Set the CW sizing parameters
+      sizing_plant.setDesignLoopExitTemperature(leaving_cw_t_c)
+      sizing_plant.setLoopDesignTemperatureDifference(range_k)
+
+      # Set Cooling Tower sizing parameters.
+      # Only the variable speed cooling tower
+      # in E+ allows you to set the design temperatures.
+      #
+      # Per the documentation
+      # http://bigladdersoftware.com/epx/docs/8-4/input-output-reference/group-condenser-equipment.html#field-design-u-factor-times-area-value
+      # for CoolingTowerSingleSpeed and CoolingTowerTwoSpeed
+      # E+ uses the following values during sizing:
+      # 95F entering water temp
+      # 95F OATdb
+      # 78F OATwb
+      # range = loop design delta-T aka range (specified above)
+      supplyComponents.each do |sc|
+        if sc.to_CoolingTowerVariableSpeed.is_initialized
           ct = sc.to_CoolingTowerVariableSpeed.get
-          ct.setDesignInletAirWetBulbTemperature(design_inlet_wb_c)
-          ct.setDesignApproachTemperature(design_approach_k)
-          ct.setDesignRangeTemperature(range_t_k)
-        elsif sc.to_CoolingTowerPerformanceYorkCalc.is_initialized
-          ct = sc.to_CoolingTowerPerformanceYorkCalc.get
-          ct.setDesignInletAirWetBulbTemperature(design_inlet_wb_c)
-          ct.setDesignApproachTemperature(design_approach_k)
-          ct.setDesignRangeTemperature(range_t_k)
-        elsif sc.to_CoolingTowerPerformanceCoolTools.is_initialized
-          ct = sc.to_CoolingTowerPerformanceCoolTools.get
-          ct.setDesignInletAirWetBulbTemperature(design_inlet_wb_c)
-          ct.setDesignApproachTemperature(design_approach_k)
-          ct.setDesignRangeTemperature(range_t_k)
+          # E+ has a minimum limit of 68F (20C) for this field.
+          # Check against limit before attempting to set value.
+          eplus_design_oat_wb_c_lim = 20
+          if design_oat_wb_c < eplus_design_oat_wb_c_lim
+            OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.PlantLoop', "For #{name}, a design OATwb of 68F will be used for sizing the cooling towers because the actual design value is below the limit EnergyPlus accepts for this input.")
+            design_oat_wb_c = eplus_design_oat_wb_c_lim
+          end
+          ct.setDesignInletAirWetBulbTemperature(design_oat_wb_c)
+          ct.setDesignApproachTemperature(approach_k)
+          ct.setDesignRangeTemperature(range_k)
         end
+      end
 
+      # Set the min and max CW temps
+      # Typical design of min temp is really around 40F
+      # (that's what basin heaters, when used, are sized for usually)
+      min_temp_f = 34
+      max_temp_f = 200
+      min_temp_c = OpenStudio.convert(min_temp_f, 'F', 'C').get
+      max_temp_c = OpenStudio.convert(max_temp_f, 'F', 'C').get
+      setMinimumLoopTemperature(min_temp_c)
+      setMaximumLoopTemperature(max_temp_c)
+
+      # Cooling Tower operational controls
+      # G3.1.3.11 - Tower shall be controlled to maintain a 70F
+      # LCnWT where weather permits,
+      # floating up to leaving water at design conditions.
+      float_down_to_f = 70
+      float_down_to_c = OpenStudio.convert(float_down_to_f, 'F', 'C').get
+      cw_t_stpt_manager = OpenStudio::Model::SetpointManagerFollowOutdoorAirTemperature.new(model)
+      cw_t_stpt_manager.setName("CW Temp Follows OATwb w/ #{approach_r} deltaF approach min #{float_down_to_f.round(1)} F to max #{leaving_cw_t_f.round(1)}")
+      cw_t_stpt_manager.setReferenceTemperatureType('OutdoorAirWetBulb')
+      # At low design OATwb, it is possible to calculate
+      # a maximum temperature below the minimum.  In this case,
+      # make the maximum and minimum the same.
+      if leaving_cw_t_c < float_down_to_c
+        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.PlantLoop', "For #{name}, the maximum leaving temperature of #{leaving_cw_t_f.round(1)} F is below the minimum of #{float_down_to_f.round(1)} F.  The maximum will be set to the same value as the minimum.")
+        leaving_cw_t_c = float_down_to_c
       end
+      cw_t_stpt_manager.setMaximumSetpointTemperature(leaving_cw_t_c)
+      cw_t_stpt_manager.setMinimumSetpointTemperature(float_down_to_c)
+      cw_t_stpt_manager.setOffsetTemperatureDifference(approach_k)
+      cw_t_stpt_manager.addToNode(supplyOutletNode)
 
     end
-  
+
     return true
-  
   end
-   
-  def is_supply_water_temperature_reset_required(template)
 
+  def supply_water_temperature_reset_required?(template)
     reset_required = false
 
     case template
     when 'DOE Ref Pre-1980', 'DOE Ref 1980-2004'
-      
+
       # Not required before 90.1-2004
       return reset_required
-      
+
     when '90.1-2004', '90.1-2007', '90.1-2010', '90.1-2013'
-      
+
+      # Not required for service water heating systems
+      if swh_loop?
+        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.PlantLoop', "For #{name}: supply water temperature reset not required for service water heating systems.")
+        return reset_required
+      end
+
       # Not required for variable flow systems
-      if is_variable_flow_system
-        OpenStudio::logFree(OpenStudio::Info, 'openstudio.standards.PlantLoop', "For #{self.name}: supply water temperature reset not required for variable flow systems per 6.5.4.3 Exception b.")
+      if variable_flow_system?
+        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.PlantLoop', "For #{name}: supply water temperature reset not required for variable flow systems per 6.5.4.3 Exception b.")
         return reset_required
       end
-      
+
       # Determine the capacity of the system
-      heating_capacity_w = self.total_heating_capacity
-      cooling_capacity_w = self.total_cooling_capacity
-      
-      heating_capacity_btu_per_hr = OpenStudio.convert(heating_capacity_w,'W','Btu/hr').get
-      cooling_capacity_btu_per_hr = OpenStudio.convert(cooling_capacity_w,'W','Btu/hr').get
-     
+      heating_capacity_w = total_heating_capacity
+      cooling_capacity_w = total_cooling_capacity
+
+      heating_capacity_btu_per_hr = OpenStudio.convert(heating_capacity_w, 'W', 'Btu/hr').get
+      cooling_capacity_btu_per_hr = OpenStudio.convert(cooling_capacity_w, 'W', 'Btu/hr').get
+
       # Compare against capacity minimum requirement
-      min_cap_btu_per_hr = 300000
-      if heating_capacity_btu_per_hr > min_cap_btu_per_hr 
-        OpenStudio::logFree(OpenStudio::Info, 'openstudio.standards.PlantLoop', "For #{self.name}: supply water temperature reset is required because heating capacity of #{heating_capacity_btu_per_hr.round} Btu/hr exceeds the minimum threshold of #{min_cap_btu_per_hr.round} Btu/hr.")
+      min_cap_btu_per_hr = 300_000
+      if heating_capacity_btu_per_hr > min_cap_btu_per_hr
+        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.PlantLoop', "For #{name}: supply water temperature reset is required because heating capacity of #{heating_capacity_btu_per_hr.round} Btu/hr exceeds the minimum threshold of #{min_cap_btu_per_hr.round} Btu/hr.")
         reset_required = true
       elsif cooling_capacity_btu_per_hr > min_cap_btu_per_hr
-        OpenStudio::logFree(OpenStudio::Info, 'openstudio.standards.PlantLoop', "For #{self.name}: supply water temperature reset is required because cooling capacity of #{cooling_capacity_btu_per_hr.round} Btu/hr exceeds the minimum threshold of #{min_cap_btu_per_hr.round} Btu/hr.")
+        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.PlantLoop', "For #{name}: supply water temperature reset is required because cooling capacity of #{cooling_capacity_btu_per_hr.round} Btu/hr exceeds the minimum threshold of #{min_cap_btu_per_hr.round} Btu/hr.")
         reset_required = true
       else
-        OpenStudio::logFree(OpenStudio::Info, 'openstudio.standards.PlantLoop', "For #{self.name}: supply water temperature reset is not required because capacity is less than minimum of #{min_cap_btu_per_hr.round} Btu/hr.")
+        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.PlantLoop', "For #{name}: supply water temperature reset is not required because capacity is less than minimum of #{min_cap_btu_per_hr.round} Btu/hr.")
       end
-    
+
     end
 
     return reset_required
-  
   end
-  
+
   def enable_supply_water_temperature_reset
-  
     # Get the current setpoint manager on the outlet node
     # and determine if already has temperature reset
-    spms = self.supplyOutletNode.setpointManagers
+    spms = supplyOutletNode.setpointManagers
     spms.each do |spm|
-      if spm.to_SetpointManagerOutdoorAirReset
-        OpenStudio::logFree(OpenStudio::Info, 'openstudio.standards.PlantLoop', "For #{self.name}: supply water temperature reset is already enabled.")
+      if spm.to_SetpointManagerOutdoorAirReset.is_initialized
+        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.PlantLoop', "For #{name}: supply water temperature reset is already enabled.")
         return false
       end
     end
 
     # Get the design water temperature
-    sizing_plant = self.sizingPlant
-    design_temp_c = sizing_plant.loopDesignExitTemperature
-    design_temp_f = OpenStudio.convert(design_temp_c,'C','F').get
-    loop_type = self.loopType
-    
+    sizing_plant = sizingPlant
+    design_temp_c = sizing_plant.designLoopExitTemperature
+    design_temp_f = OpenStudio.convert(design_temp_c, 'C', 'F').get
+    loop_type = sizing_plant.loopType
+
     # Apply the reset, depending on the type of loop.
     case loop_type
     when 'Heating'
-   
+
       # Hot water as-designed when cold outside
       hwt_at_lo_oat_f = design_temp_f
       hwt_at_lo_oat_c = OpenStudio.convert(hwt_at_lo_oat_f, 'F', 'C').get
       # 30F decrease when it's hot outside,
       # and therefore less heating capacity is likely required.
       decrease_f = 30.0
-      hwt_at_hi_oat_f = hwt_at_lo_oat_f - decrease_f 
-      hwt_at_hi_oat_c = OpenStudio.convert(hwt_at_hi_oat_f, 'C', 'F').get
+      hwt_at_hi_oat_f = hwt_at_lo_oat_f - decrease_f
+      hwt_at_hi_oat_c = OpenStudio.convert(hwt_at_hi_oat_f, 'F', 'C').get
 
       # Define the high and low outdoor air temperatures
       lo_oat_f = 20
       lo_oat_c = OpenStudio.convert(lo_oat_f, 'F', 'C').get
       hi_oat_f = 50
       hi_oat_c = OpenStudio.convert(hi_oat_f, 'F', 'C').get
-      
+
       # Create a setpoint manager
-      hwt_oa_reset = OpenStudio::Model::SetpointManagerOutdoorAirReset.new(self.model)
-      hwt_oa_reset.setName("#{self.name} HW Temp Reset")
+      hwt_oa_reset = OpenStudio::Model::SetpointManagerOutdoorAirReset.new(model)
+      hwt_oa_reset.setName("#{name} HW Temp Reset")
       hwt_oa_reset.setControlVariable('Temperature')
       hwt_oa_reset.setSetpointatOutdoorLowTemperature(hwt_at_lo_oat_c)
       hwt_oa_reset.setOutdoorLowTemperature(lo_oat_c)
       hwt_oa_reset.setSetpointatOutdoorHighTemperature(hwt_at_hi_oat_c)
       hwt_oa_reset.setOutdoorHighTemperature(hi_oat_c)
-      hwt_oa_reset.addToNode(self.supplyOutletNode)
-    
-      OpenStudio::logFree(OpenStudio::Info, 'openstudio.standards.PlantLoop', "For #{self.name}: hot water temperature reset from #{hwt_at_lo_oat_f.round}F to #{hwt_at_hi_oat_f}F between outdoor air temps of #{lo_oat_f.round}F and #{hi_oat_f}F.")
-    
+      hwt_oa_reset.addToNode(supplyOutletNode)
+
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.PlantLoop', "For #{name}: hot water temperature reset from #{hwt_at_lo_oat_f.round}F to #{hwt_at_hi_oat_f.round}F between outdoor air temps of #{lo_oat_f.round}F and #{hi_oat_f.round}F.")
+
     when 'Cooling'
-      
+
       # Chilled water as-designed when hot outside
       chwt_at_hi_oat_f = design_temp_f
       chwt_at_hi_oat_c = OpenStudio.convert(chwt_at_hi_oat_f, 'F', 'C').get
@@ -410,46 +465,44 @@ lcnwt_f = lcnwt_10f_approach if lcnwt_10f_approach < 85
       increase_f = 10.0
       chwt_at_lo_oat_f = chwt_at_hi_oat_f + increase_f
       chwt_at_lo_oat_c = OpenStudio.convert(chwt_at_lo_oat_f, 'F', 'C').get
-      
+
       # Define the high and low outdoor air temperatures
-      lo_oat_f = 50
+      lo_oat_f = 60
       lo_oat_c = OpenStudio.convert(lo_oat_f, 'F', 'C').get
-      hi_oat_f = 70
+      hi_oat_f = 80
       hi_oat_c = OpenStudio.convert(hi_oat_f, 'F', 'C').get
-      
+
       # Create a setpoint manager
-      chwt_oa_reset = OpenStudio::Model::SetpointManagerOutdoorAirReset.new(self.model)
-      chwt_oa_reset.setName("#{self.name} CHW Temp Reset")
+      chwt_oa_reset = OpenStudio::Model::SetpointManagerOutdoorAirReset.new(model)
+      chwt_oa_reset.setName("#{name} CHW Temp Reset")
       chwt_oa_reset.setControlVariable('Temperature')
       chwt_oa_reset.setSetpointatOutdoorLowTemperature(chwt_at_lo_oat_c)
       chwt_oa_reset.setOutdoorLowTemperature(lo_oat_c)
       chwt_oa_reset.setSetpointatOutdoorHighTemperature(chwt_at_hi_oat_c)
       chwt_oa_reset.setOutdoorHighTemperature(hi_oat_c)
-      chwt_oa_reset.addToNode(self.supplyOutletNode)
+      chwt_oa_reset.addToNode(supplyOutletNode)
+
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.PlantLoop', "For #{name}: chilled water temperature reset from #{chwt_at_hi_oat_f.round}F to #{chwt_at_lo_oat_f.round}F between outdoor air temps of #{hi_oat_f.round}F and #{lo_oat_f.round}F.")
 
-      OpenStudio::logFree(OpenStudio::Info, 'openstudio.standards.PlantLoop', "For #{self.name}: chilled water temperature reset from #{chwt_at_hi_oat_f}F to #{chwt_at_lo_oat_f.round}F between outdoor air temps of #{hi_oat_f}F and #{lo_oat_f.round}F.")      
-      
     else
-      
-      OpenStudio::logFree(OpenStudio::Error, 'openstudio.standards.PlantLoop', "For #{self.name}: cannot enable supply water temperature reset for a #{loop_type} loop.")
+
+      OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.PlantLoop', "For #{name}: cannot enable supply water temperature reset for a #{loop_type} loop.")
       return false
-    
+
     end
-  
+
     return true
-  
   end
-  
+
   # Get the total cooling capacity for the plant loop
   #
   # @return [Double] total cooling capacity
   #   units = Watts (W)
   def total_cooling_capacity
-  
     # Sum the cooling capacity for all cooling components
     # on the plant loop.
     total_cooling_capacity_w = 0
-    self.supplyComponents.each do |sc|
+    supplyComponents.each do |sc|
       # ChillerElectricEIR
       if sc.to_ChillerElectricEIR.is_initialized
         chiller = sc.to_ChillerElectricEIR.get
@@ -458,28 +511,37 @@ lcnwt_f = lcnwt_10f_approach if lcnwt_10f_approach < 85
         elsif chiller.autosizedReferenceCapacity.is_initialized
           total_cooling_capacity_w += chiller.autosizedReferenceCapacity.get
         else
-          OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.AirLoopHVAC', "For #{self.name} capacity of #{chiller.name} is not available, total cooling capacity of plant loop will be incorrect when applying standard.")
+          OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.AirLoopHVAC', "For #{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 #{self.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.AirLoopHVAC', "For #{self.name}, cooling capacity is #{total_cooling_capacity_tons.round} tons of refrigeration.")    
-    
+    total_cooling_capacity_tons = OpenStudio.convert(total_cooling_capacity_w, 'W', 'ton').get
+    OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.AirLoopHVAC', "For #{name}, cooling capacity is #{total_cooling_capacity_tons.round} tons of refrigeration.")
+
     return total_cooling_capacity_w
-  
   end
-  
+
   # Get the total heating capacity for the plant loop
   #
   # @return [Double] total heating capacity
   #   units = Watts (W)
+  # @todo Add district heating to plant loop heating capacity
   def total_heating_capacity
-  
     # Sum the heating capacity for all heating components
     # on the plant loop.
     total_heating_capacity_w = 0
-    self.supplyComponents.each do |sc|
+    supplyComponents.each do |sc|
       # BoilerHotWater
       if sc.to_BoilerHotWater.is_initialized
         boiler = sc.to_BoilerHotWater.get
@@ -488,34 +550,61 @@ lcnwt_f = lcnwt_10f_approach if lcnwt_10f_approach < 85
         elsif boiler.autosizedNominalCapacity.is_initialized
           total_heating_capacity_w += boiler.autosizedNominalCapacity.get
         else
-          OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.AirLoopHVAC', "For #{self.name} capacity of #{boiler.name} is not available, total cooling capacity of plant loop will be incorrect when applying standard.")
+          OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.PlantLoop', "For #{self.name} capacity of Boiler:HotWater ' #{boiler.name} is not available, total heating capacity of plant loop will be incorrect when applying standard.")
+        end
+      # WaterHeater:Mixed
+      elsif sc.to_WaterHeaterMixed.is_initialized
+        water_heater = sc.to_WaterHeaterMixed.get
+        if water_heater.heaterMaximumCapacity.is_initialized
+          total_heating_capacity_w += water_heater.heaterMaximumCapacity.get
+        elsif water_heater.autosizedHeaterMaximumCapacity.is_initialized
+          total_heating_capacity_w += water_heater.autosizedHeaterMaximumCapacity.get
+        else
+          OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.PlantLoop', "For #{self.name} capacity of WaterHeater:Mixed #{water_heater.name} is not available, total heating capacity of plant loop will be incorrect when applying standard.")
+        end
+      # WaterHeater:Stratified
+      elsif sc.to_WaterHeaterStratified.is_initialized
+        water_heater = sc.to_WaterHeaterStratified.get
+        if water_heater.heater1Capacity.is_initialized
+          total_heating_capacity_w += water_heater.heater1Capacity.get
+        end
+        if water_heater.heater2Capacity.is_initialized
+          total_heating_capacity_w += water_heater.heater2Capacity.get
+        end
+      # DistrictHeating
+      elsif sc.to_DistrictHeating.is_initialized
+        dist_htg = sc.to_DistrictHeating.get
+        if dist_htg.nominalCapacity.is_initialized
+          total_heating_capacity_w += dist_htg.nominalCapacity.get
+        elsif dist_htg.autosizedNominalCapacity.is_initialized
+          total_heating_capacity_w += dist_htg.autosizedNominalCapacity.get
+        else
+          OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.PlantLoop', "For #{self.name} capacity of DistrictHeating #{dist_htg.name} is not available, total heating capacity of plant loop will be incorrect when applying standard.")
         end
       end
-    end
+    end # End loop on supplyComponents
+
+    total_heating_capacity_kbtu_per_hr = OpenStudio.convert(total_heating_capacity_w,'W','kBtu/hr').get
+    OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.PlantLoop', "For #{self.name}, heating capacity is #{total_heating_capacity_kbtu_per_hr.round} kBtu/hr.")
 
-    total_heating_capacity_kbtu_per_hr = OpenStudio.convert(total_heating_capacity_w,'W','tons').get
-    OpenStudio::logFree(OpenStudio::Info, 'openstudio.standards.AirLoopHVAC', "For #{self.name}, heating capacity is #{total_heating_capacity_kbtu_per_hr.round} kBtu/hr.")    
-    
     return total_heating_capacity_w
-  
   end
-  
+
   def total_floor_area_served
-    
-    sizing_plant = self.sizingPlant
+    sizing_plant = sizingPlant
     loop_type = sizing_plant.loopType
-    
+
     # Get all the coils served by this loop
     coils = []
     case loop_type
-    when 'Heating'  
-      self.demandComponents.each do |dc|
+    when 'Heating'
+      demandComponents.each do |dc|
         if dc.to_CoilHeatingWater.is_initialized
           coils << dc.to_CoilHeatingWater.get
         end
       end
     when 'Cooling'
-      self.demandComponents.each do |dc|
+      demandComponents.each do |dc|
         if dc.to_CoilCoolingWater.is_initialized
           coils << dc.to_CoilCoolingWater.get
         end
@@ -523,13 +612,12 @@ lcnwt_f = lcnwt_10f_approach if lcnwt_10f_approach < 85
     else
       return 0.0
     end
-    
+
     # The coil can either be on an airloop (as a main heating coil)
     # in an HVAC Component (like a unitary system on an airloop),
     # or in a Zone HVAC Component (like a fan coil).
     zones_served = []
     coils.each do |coil|
-    
       if coil.airLoopHVAC.is_initialized
         air_loop = coil.airLoopHVAC.get
         zones_served += air_loop.thermalZones
@@ -545,71 +633,68 @@ lcnwt_f = lcnwt_10f_approach if lcnwt_10f_approach < 85
           zones_served << zone_hvac.thermalZone.get
         end
       end
-    
-    end    
-    
+    end
+
     # Add up the area of all zones served.
     # Make sure to only add unique zones in
     # case the same zone is served by multiple
     # coils served by the same loop.  For example,
-    # a HW and Reheat 
+    # a HW and Reheat
     area_served_m2 = 0.0
     zones_served.uniq.each do |zone|
       area_served_m2 += zone.floorArea
     end
-    area_served_ft2 = OpenStudio.convert(area_served_m2,'m^2','ft^2').get
+    area_served_ft2 = OpenStudio.convert(area_served_m2, 'm^2', 'ft^2').get
+
+    OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.AirLoopHVAC', "For #{name}, serves #{area_served_ft2.round} ft^2.")
 
-    OpenStudio::logFree(OpenStudio::Info, 'openstudio.standards.AirLoopHVAC', "For #{self.name}, serves #{area_served_ft2.round} ft^2.")
-  
     return area_served_m2
-  
   end
 
-  def apply_performance_rating_method_baseline_pumping_type(template)
-    
-    sizing_plant = self.sizingPlant
-    loop_type = sizing_plant.loopType    
-    
+  def apply_prm_baseline_pumping_type(template)
+    sizing_plant = sizingPlant
+    loop_type = sizing_plant.loopType
+
     case loop_type
     when 'Heating'
-      
+
       # Hot water systems
-    
+
       # Determine the minimum area to determine
       # pumping type.
       minimum_area_ft2 = nil
       case template
       when '90.1-2004', '90.1-2007', '90.1-2010', '90.1-2013'
-        minimum_area_ft2 = 120000
+        minimum_area_ft2 = 120_000
       end
-    
+
       # Determine the area served
-      area_served_m2 = self.total_floor_area_served
-      area_served_ft2 = OpenStudio.convert(area_served_m2,'m^2','ft^2').get
-    
-      # Determine the pump type 
+      area_served_m2 = total_floor_area_served
+      area_served_ft2 = OpenStudio.convert(area_served_m2, 'm^2', 'ft^2').get
+
+      # Determine the pump type
       control_type = 'Riding Curve'
       if area_served_ft2 > minimum_area_ft2
         control_type = 'VSD No Reset'
       end
-      
+
       # Modify all the primary pumps
-      self.supplyComponents.each do |sc|
+      supplyComponents.each do |sc|
         if sc.to_PumpVariableSpeed.is_initialized
           pump = sc.to_PumpVariableSpeed.get
           pump.set_control_type(control_type)
         end
       end
- 
-       # Report out the pumping type
+
+      # Report out the pumping type
       unless control_type.nil?
-        OpenStudio::logFree(OpenStudio::Info, 'openstudio.standards.AirLoopHVAC', "For #{self.name}, pump type is #{control_type}.")
+        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.AirLoopHVAC', "For #{name}, pump type is #{control_type}.")
       end
 
     when 'Cooling'
 
       # Chilled water systems
-    
+
       # Determine the pumping type.
       # For some templates, this is
       # based on area.  For others, it is built
@@ -619,161 +704,181 @@ lcnwt_f = lcnwt_10f_approach if lcnwt_10f_approach < 85
       case template
       when '90.1-2004'
 
-        minimum_area_ft2 = 120000
-        
+        minimum_area_ft2 = 120_000
+
         # Determine the area served
-        area_served_m2 = self.total_floor_area_served
-        area_served_ft2 = OpenStudio.convert(area_served_m2,'m^2','ft^2').get
-      
-        # Determine the primary pump type 
-        pri_control_type = 'Riding Curve'
-        
+        area_served_m2 = total_floor_area_served
+        area_served_ft2 = OpenStudio.convert(area_served_m2, 'm^2', 'ft^2').get
+
+        # Determine the primary pump type
+        pri_control_type = 'Constant Flow'
+
         # Determine the secondary pump type
         sec_control_type = 'Riding Curve'
         if area_served_ft2 > minimum_area_ft2
           sec_control_type = 'VSD No Reset'
         end
-      
+
       when '90.1-2007', '90.1-2010', '90.1-2013'
-        
+
         minimum_cap_tons = 300
-        
+
         # Determine the capacity
-        cap_w = self.total_cooling_capacity
-        cap_tons = OpenStudio.convert(cap_w,'m^2','ft^2').get
-      
-        # Determine the primary pump type 
-        pri_control_type = 'Riding Curve'
-        
-        # Determine the secondary pump type
-        sec_control_type = 'Riding Curve'
-        if cap_tons > minimum_cap_tons
-          sec_control_type = 'VSD No Reset'
+        cap_w = total_cooling_capacity
+        cap_tons = OpenStudio.convert(cap_w, 'W', 'ton').get
+
+        # Determine if it a district cooling system
+        has_district_cooling = false
+        supplyComponents.each do |sc|
+          if sc.to_DistrictCooling.is_initialized
+            has_district_cooling = true
+          end
+        end
+
+        # Determine the primary and secondary pumping types
+        pri_control_type = nil
+        sec_control_type = nil
+        if has_district_cooling
+          pri_control_type = if cap_tons > minimum_cap_tons
+                               'VSD No Reset'
+                             else
+                               'Riding Curve'
+                             end
+        else
+          pri_control_type = 'Constant Flow'
+          sec_control_type = if cap_tons > minimum_cap_tons
+                               'VSD No Reset'
+                             else
+                               'Riding Curve'
+                             end
         end
-   
       end
-      
+
       # Report out the pumping type
       unless pri_control_type.nil?
-        OpenStudio::logFree(OpenStudio::Info, 'openstudio.standards.AirLoopHVAC', "For #{self.name}, primary pump type is #{pri_control_type}.")
+        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.AirLoopHVAC', "For #{name}, primary pump type is #{pri_control_type}.")
       end
 
       unless sec_control_type.nil?
-        OpenStudio::logFree(OpenStudio::Info, 'openstudio.standards.AirLoopHVAC', "For #{self.name}, secondary pump type is #{sec_control_type}.")
-      end      
-      
+        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.AirLoopHVAC', "For #{name}, secondary pump type is #{sec_control_type}.")
+      end
+
       # Modify all the primary pumps
-      self.supplyComponents.each do |sc|
+      supplyComponents.each do |sc|
         if sc.to_PumpVariableSpeed.is_initialized
           pump = sc.to_PumpVariableSpeed.get
           pump.set_control_type(pri_control_type)
+        elsif sc.to_HeaderedPumpsVariableSpeed.is_initialized
+          pump = sc.to_HeaderedPumpsVariableSpeed.get
+          pump.set_control_type(control_type)        
         end
-      end    
-    
+      end
+
       # Modify all the secondary pumps
-      self.demandComponents.each do |sc|
+      demandComponents.each do |sc|
         if sc.to_PumpVariableSpeed.is_initialized
           pump = sc.to_PumpVariableSpeed.get
           pump.set_control_type(sec_control_type)
+        elsif sc.to_HeaderedPumpsVariableSpeed.is_initialized
+          pump = sc.to_HeaderedPumpsVariableSpeed.get
+          pump.set_control_type(control_type)
         end
-      end      
+      end
 
     when 'Condenser'
-    
+
       # Condenser water systems
-    
+
       # All condenser water loops are constant flow
-      control_type = 'Riding Curve'
+      control_type = 'Constant Flow'
 
       # Report out the pumping type
       unless control_type.nil?
-        OpenStudio::logFree(OpenStudio::Info, 'openstudio.standards.AirLoopHVAC', "For #{self.name}, pump type is #{control_type}.")
+        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.AirLoopHVAC', "For #{name}, pump type is #{control_type}.")
       end
-      
+
       # Modify all primary pumps
-      self.supplyComponents.each do |sc|
+      supplyComponents.each do |sc|
         if sc.to_PumpVariableSpeed.is_initialized
           pump = sc.to_PumpVariableSpeed.get
           pump.set_control_type(control_type)
+        elsif sc.to_HeaderedPumpsVariableSpeed.is_initialized
+          pump = sc.to_HeaderedPumpsVariableSpeed.get
+          pump.set_control_type(control_type)
         end
       end
 
     end
-    
+
     return true
-  
   end
-  
-  def apply_performance_rating_method_number_of_boilers(template)
-    
+
+  def apply_prm_number_of_boilers(template)
     # Skip non-heating plants
-    return true unless self.sizingPlant.loopType == 'Heating'
+    return true unless sizingPlant.loopType == 'Heating'
 
     # Determine the minimum area to determine
     # number of boilers.
     minimum_area_ft2 = nil
     case template
     when '90.1-2004', '90.1-2007', '90.1-2010', '90.1-2013'
-      minimum_area_ft2 = 15000
+      minimum_area_ft2 = 15_000
     end
-  
+
     # Determine the area served
-    area_served_m2 = self.total_floor_area_served
-    area_served_ft2 = OpenStudio.convert(area_served_m2,'m^2','ft^2').get
-  
+    area_served_m2 = total_floor_area_served
+    area_served_ft2 = OpenStudio.convert(area_served_m2, 'm^2', 'ft^2').get
+
     # Do nothing if only one boiler is required
     return true if area_served_ft2 < minimum_area_ft2
 
     # Get all existing boilers
     boilers = []
-    self.supplyComponents.each do |sc|
+    supplyComponents.each do |sc|
       if sc.to_BoilerHotWater.is_initialized
         boilers << sc.to_BoilerHotWater.get
       end
     end
-    
+
     # Ensure there is only 1 boiler to start
     first_boiler = nil
-    if boilers.size == 0
+    if boilers.size.zero?
       return true
     elsif boilers.size > 1
-      OpenStudio::logFree(OpenStudio::Error, 'openstudio.standards.PlantLoop', "For #{self.name}, found #{boilers.size}, cannot split up per performance rating method baseline requirements.")
+      OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.PlantLoop', "For #{name}, found #{boilers.size}, cannot split up per performance rating method baseline requirements.")
     else
       first_boiler = boilers[0]
     end
-    
+
     # Clone the existing boiler and create
     # a new branch for it
-    second_boiler = first_boiler.clone(self.model)
+    second_boiler = first_boiler.clone(model)
     if second_boiler.to_BoilerHotWater.is_initialized
       second_boiler = second_boiler.to_BoilerHotWater.get
     else
-      OpenStudio::logFree(OpenStudio::Error, 'openstudio.standards.PlantLoop', "For #{self.name}, could not clone boiler #{first_boiler.name}, cannot apply the performance rating method number of boilers.")
+      OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.PlantLoop', "For #{name}, could not clone boiler #{first_boiler.name}, cannot apply the performance rating method number of boilers.")
       return false
     end
-    self.addSupplyBranchForComponent(second_boiler)
+    addSupplyBranchForComponent(second_boiler)
     final_boilers = [first_boiler, second_boiler]
-    OpenStudio::logFree(OpenStudio::Info, 'openstudio.standards.PlantLoop', "For #{self.name}, added a second boiler.")
-
+    OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.PlantLoop', "For #{name}, added a second boiler.")
 
     # Set the sizing factor for all boilers evenly and Rename the boilers
-    sizing_factor = (1.0/final_boilers.size).round(2)
+    sizing_factor = (1.0 / final_boilers.size).round(2)
     final_boilers.each_with_index do |boiler, i|
       boiler.setSizingFactor(sizing_factor)
-      boiler.setName("#{first_boiler.name} #{i+1} of #{final_boilers.size}")
+      boiler.setName("#{first_boiler.name} #{i + 1} of #{final_boilers.size}")
     end
-    
+
     # Set the equipment to stage sequentially
-    self.setLoadDistributionScheme('SequentialLoad')
-  
+    setLoadDistributionScheme('SequentialLoad')
+
     return true
-  
   end
 
-  def apply_performance_rating_method_number_of_chillers(template)
-    
+  def apply_prm_number_of_chillers(template)
     # Skip non-cooling plants
-    return true unless self.sizingPlant.loopType == 'Cooling'
+    return true unless sizingPlant.loopType == 'Cooling'
 
     # Determine the number and type of chillers
     num_chillers = nil
@@ -781,11 +886,11 @@ lcnwt_f = lcnwt_10f_approach if lcnwt_10f_approach < 85
     chiller_compressor_type = nil
     case template
     when '90.1-2004', '90.1-2007', '90.1-2010', '90.1-2013'
-      
+
       # Determine the capacity of the loop
-      cap_w = self.total_cooling_capacity
-      cap_tons = OpenStudio.convert(cap_w,'W','ton').get
-    
+      cap_w = total_cooling_capacity
+      cap_tons = OpenStudio.convert(cap_w, 'W', 'ton').get
+
       if cap_tons <= 300
         num_chillers = 1
         chiller_cooling_type = 'WaterCooled'
@@ -797,145 +902,450 @@ lcnwt_f = lcnwt_10f_approach if lcnwt_10f_approach < 85
       else
         # Max capacity of a single chiller
         max_cap_ton = 800.0
-        num_chillers = (cap_tons/max_cap_ton).floor + 1
+        num_chillers = (cap_tons / max_cap_ton).floor + 1
         # Must be at least 2 chillers
-        num_chillers +=1 if num_chillers == 1
+        num_chillers += 1 if num_chillers == 1
         chiller_cooling_type = 'WaterCooled'
-        chiller_compressor_type = 'Centrifugal'        
+        chiller_compressor_type = 'Centrifugal'
       end
-  
+
     end
-    
-    # Get all existing chillers
+
+    # Get all existing chillers and pumps
     chillers = []
-    self.supplyComponents.each do |sc|
+    pumps = []
+    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
-    if chillers.size == 0
+    if chillers.size.zero?
       return true
     elsif chillers.size > 1
-      OpenStudio::logFree(OpenStudio::Error, 'openstudio.standards.PlantLoop', "For #{self.name}, found #{chillers.size} chillers, cannot split up per performance rating method baseline requirements.")
+      OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.PlantLoop', "For #{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, 'openstudio.standards.PlantLoop', "For #{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 #{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)
+    per_chiller_sizing_factor = (1.0 / num_chillers).round(2)
     # This is unused
     per_chiller_cap_tons = cap_tons / 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 = OpenStudio::Model::ChillerElectricEIR.new(self.model)
-      # TODO renable the cloning of the chillers after curves are shared resources
-      # Should be good to go since 1.10.2 (?)
-      new_chiller = first_chiller.clone(self.model)
+    (num_chillers - 1).times do
+      new_chiller = first_chiller.clone(model)
       if new_chiller.to_ChillerElectricEIR.is_initialized
         new_chiller = new_chiller.to_ChillerElectricEIR.get
       else
-        OpenStudio::logFree(OpenStudio::Error, 'openstudio.standards.PlantLoop', "For #{self.name}, could not clone chiller #{first_chiller.name}, cannot apply the performance rating method number of chillers.")
+        OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.PlantLoop', "For #{name}, could not clone chiller #{first_chiller.name}, cannot apply the performance rating method number of chillers.")
         return false
       end
-      self.addSupplyBranchForComponent(new_chiller)
+      # Connect the new chiller to the same CHW loop
+      # as the old chiller.
+      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,
+    # replace the original pump with a headered pump
+    # of the same type and properties.
+    if final_chillers.size > 1
+      num_pumps = final_chillers.size
+      new_pump = nil
+      if orig_pump.to_PumpConstantSpeed.is_initialized
+        new_pump = OpenStudio::Model::HeaderedPumpsConstantSpeed.new(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(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(supplyInletNode)
+    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.setName("#{template} #{chiller_cooling_type} #{chiller_compressor_type} Chiller #{i + 1} of #{final_chillers.size}")
       final_chiller.setSizingFactor(per_chiller_sizing_factor)
       final_chiller.setCondenserType(chiller_cooling_type)
     end
-    OpenStudio::logFree(OpenStudio::Info, 'openstudio.standards.PlantLoop', "For #{self.name}, there are #{final_chillers.size} #{chiller_cooling_type} #{chiller_compressor_type} chillers.")
-    
+    OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.PlantLoop', "For #{name}, there are #{final_chillers.size} #{chiller_cooling_type} #{chiller_compressor_type} chillers.")
+
     # Set the equipment to stage sequentially
-    self.setLoadDistributionScheme('SequentialLoad')
-  
+    setLoadDistributionScheme('SequentialLoad')
+
     return true
-  
   end
 
+  def apply_prm_number_of_cooling_towers(template)
+    # Skip non-cooling plants
+    return true unless sizingPlant.loopType == 'Condenser'
+
+    # Determine the number of chillers
+    # already in the model
+    num_chillers = model.getChillerElectricEIRs.size
+
+    # Get all existing cooling towers and pumps
+    clg_twrs = []
+    pumps = []
+    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 #{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 #{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 #{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)
+
+    # Add a cooling tower for each chiller.
+    # Add an accompanying CW pump for each cooling tower.
+    final_twrs = [orig_twr]
+    new_twr = nil
+    (num_chillers - 1).times do
+      if orig_twr.to_CoolingTowerSingleSpeed.is_initialized
+        new_twr = orig_twr.clone(model)
+        new_twr = new_twr.to_CoolingTowerSingleSpeed.get
+      elsif orig_twr.to_CoolingTowerTwoSpeed.is_initialized
+        new_twr = orig_twr.clone(model)
+        new_twr = new_twr.to_CoolingTowerTwoSpeed.get
+      elsif orig_twr.to_CoolingTowerVariableSpeed.is_initialized
+        # TODO: remove workaround after resolving
+        # https://github.com/NREL/OpenStudio/issues/2212
+        # Workaround is to create a new tower
+        # and replicate all the properties of the first tower.
+        new_twr = OpenStudio::Model::CoolingTowerVariableSpeed.new(model)
+        new_twr.setName(orig_twr.name.get.to_s)
+        new_twr.setDesignInletAirWetBulbTemperature(orig_twr.designInletAirWetBulbTemperature.get)
+        new_twr.setDesignApproachTemperature(orig_twr.designApproachTemperature.get)
+        new_twr.setDesignRangeTemperature(orig_twr.designRangeTemperature.get)
+        new_twr.setFractionofTowerCapacityinFreeConvectionRegime(orig_twr.fractionofTowerCapacityinFreeConvectionRegime.get)
+        if orig_twr.fanPowerRatioFunctionofAirFlowRateRatioCurve.is_initialized
+          new_twr.setFanPowerRatioFunctionofAirFlowRateRatioCurve(orig_twr.fanPowerRatioFunctionofAirFlowRateRatioCurve.get)
+        end
+      else
+        OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.PlantLoop', "For #{name}, could not clone cooling tower #{orig_twr.name}, cannot apply the performance rating method number of cooling towers.")
+        return false
+      end
+
+      # Connect the new cooling tower to the CW loop
+      addSupplyBranchForComponent(new_twr)
+      new_twr_inlet = new_twr.inletModelObject.get.to_Node.get
+
+      final_twrs << new_twr
+    end
+
+    # If there is more than one cooling tower,
+    # replace the original pump with a headered pump
+    # of the same type and properties.
+    if final_twrs.size > 1
+      num_pumps = final_twrs.size
+      new_pump = nil
+      if orig_pump.to_PumpConstantSpeed.is_initialized
+        new_pump = OpenStudio::Model::HeaderedPumpsConstantSpeed.new(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(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(supplyInletNode)
+    end
+
+    # Set the sizing factors
+    final_twrs.each_with_index do |final_cooling_tower, i|
+      final_cooling_tower.setName("#{final_cooling_tower.name} #{i + 1} of #{final_twrs.size}")      
+      final_cooling_tower.setSizingFactor(clg_twr_sizing_factor)
+    end
+    OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.PlantLoop', "For #{name}, there are #{final_twrs.size} cooling towers, one for each chiller.")
+
+    # Set the equipment to stage sequentially
+    setLoadDistributionScheme('SequentialLoad')
+  end
 
   # Determines the total rated watts per GPM of the loop
   #
   # @return [Double] rated power consumption per flow
   #   @units Watts per GPM (W*s/m^3)
-  def total_rated_w_per_gpm()
-    sizing_plant = self.sizingPlant
+  def total_rated_w_per_gpm
+    sizing_plant = sizingPlant
     loop_type = sizing_plant.loopType
 
     # Supply W/GPM
     supply_w_per_gpm = 0
     demand_w_per_gpm = 0
 
-    self.supplyComponents.each do |component|
+    supplyComponents.each do |component|
       if component.to_PumpConstantSpeed.is_initialized
         pump = component.to_PumpConstantSpeed.get
         pump_rated_w_per_gpm = pump.rated_w_per_gpm
-        OpenStudio::logFree(OpenStudio::Info, "openstudio.standards.Pump", "'#{loop_type}' Loop #{self.name} - Primary (Supply) Constant Speed Pump '#{pump.name}' - pump_rated_w_per_gpm #{pump_rated_w_per_gpm} W/GPM")
+        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Pump', "'#{loop_type}' Loop #{name} - Primary (Supply) Constant Speed Pump '#{pump.name}' - pump_rated_w_per_gpm #{pump_rated_w_per_gpm} W/GPM")
         supply_w_per_gpm += pump_rated_w_per_gpm
       elsif component.to_PumpVariableSpeed.is_initialized
         pump = component.to_PumpVariableSpeed.get
         pump_rated_w_per_gpm = pump.rated_w_per_gpm
-        OpenStudio::logFree(OpenStudio::Info, "openstudio.standards.Pump", "'#{loop_type}' Loop #{self.name} - Primary (Supply) VSD Pump '#{pump.name}' - pump_rated_w_per_gpm #{pump_rated_w_per_gpm} W/GPM")
+        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Pump', "'#{loop_type}' Loop #{name} - Primary (Supply) VSD Pump '#{pump.name}' - pump_rated_w_per_gpm #{pump_rated_w_per_gpm} W/GPM")
         supply_w_per_gpm += pump_rated_w_per_gpm
       end
     end
 
     # Determine if primary only or primary-secondary
     # IF there's a pump on the demand side it's primary-secondary
-    demandPumps = self.demandComponents('OS_Pump_VariableSpeed'.to_IddObjectType) + self.demandComponents('OS_Pump_ConstantSpeed'.to_IddObjectType)
-    demandPumps.each do |component|
+    demand_pumps = demandComponents('OS:Pump:VariableSpeed'.to_IddObjectType) + demandComponents('OS:Pump:ConstantSpeed'.to_IddObjectType)
+    demand_pumps.each do |component|
       if component.to_PumpConstantSpeed.is_initialized
         pump = component.to_PumpConstantSpeed.get
         pump_rated_w_per_gpm = pump.rated_w_per_gpm
-        OpenStudio::logFree(OpenStudio::Info, "openstudio.standards.Pump", "'#{loop_type}' Loop #{self.name} - Secondary (Demand) Constant Speed Pump '#{pump.name}' - pump_rated_w_per_gpm #{pump_rated_w_per_gpm} W/GPM")
+        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Pump', "'#{loop_type}' Loop #{name} - Secondary (Demand) Constant Speed Pump '#{pump.name}' - pump_rated_w_per_gpm #{pump_rated_w_per_gpm} W/GPM")
         demand_w_per_gpm += pump_rated_w_per_gpm
       elsif component.to_PumpVariableSpeed.is_initialized
         pump = component.to_PumpVariableSpeed.get
         pump_rated_w_per_gpm = pump.rated_w_per_gpm
-        OpenStudio::logFree(OpenStudio::Info, "openstudio.standards.Pump", "'#{loop_type}' Loop #{self.name} - Secondary (Demand) VSD Pump '#{pump.name}' - pump_rated_w_per_gpm #{pump_rated_w_per_gpm} W/GPM")
+        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Pump', "'#{loop_type}' Loop #{name} - Secondary (Demand) VSD Pump '#{pump.name}' - pump_rated_w_per_gpm #{pump_rated_w_per_gpm} W/GPM")
         demand_w_per_gpm += pump_rated_w_per_gpm
       end
     end
 
-
     total_rated_w_per_gpm = supply_w_per_gpm + demand_w_per_gpm
 
-    OpenStudio::logFree(OpenStudio::Info, "openstudio.standards.Loop", "'#{loop_type}' Loop #{self.name} - Total #{total_rated_w_per_gpm} W/GPM - Supply #{supply_w_per_gpm} W/GPM - Demand #{demand_w_per_gpm} W/GPM")
+    OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.Loop', "'#{loop_type}' Loop #{name} - Total #{total_rated_w_per_gpm} W/GPM - Supply #{supply_w_per_gpm} W/GPM - Demand #{demand_w_per_gpm} W/GPM")
 
     return total_rated_w_per_gpm
-
   end
 
   # find maximum_loop_flow_rate
   #
   # @return [Double]  maximum_loop_flow_rate m^3/s
-  def find_maximum_loop_flow_rate()
-
+  def find_maximum_loop_flow_rate
     # Get the maximum_loop_flow_rate
     maximum_loop_flow_rate = nil
-    if self.maximumLoopFlowRate.is_initialized
-      maximum_loop_flow_rate = self.maximumLoopFlowRate.get
-    elsif self.autosizedMaximumLoopFlowRate.is_initialized
-      maximum_loop_flow_rate = self.autosizedMaximumLoopFlowRate.get
+    if maximumLoopFlowRate.is_initialized
+      maximum_loop_flow_rate = maximumLoopFlowRate.get
+    elsif autosizedMaximumLoopFlowRate.is_initialized
+      maximum_loop_flow_rate = autosizedMaximumLoopFlowRate.get
     else
-      OpenStudio::logFree(OpenStudio::Warn, 'openstudio.standards.PlantLoop', "For #{self.name} maximum loop flow rate is not available.")
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.standards.PlantLoop', "For #{name} maximum loop flow rate is not available.")
     end
 
     return maximum_loop_flow_rate
+  end
+
+  # Determines if the loop is a Service Water Heating loop by checking if there is a WaterUseConnection on the demand side
+  #
+  # @return [Boolean] true if it's indeed a SHW loop, false otherwise
+  def swh_loop?()
+
+    serves_swh = false
+    self.demandComponents.each do |comp|
+      if comp.to_WaterUseConnections.is_initialized
+        serves_swh = true
+        break
+      end
+    end
 
+    return serves_swh
   end
+  
+  # Classifies the service water system and returns information
+  # about fuel types, whether it serves both heating and service water heating,
+  # the water storage volume, and the total heating capacity.
+  #
+  # @return [Array<Array<String>, Bool, Double, Double>] An array of:
+  # fuel types, combination_system (true/false), storage_capacity (m^3), total_heating_capacity (W)
+  def swh_system_type
+    combination_system = true
+    storage_capacity = 0
+    primary_fuels = []
+    secondary_fuels = []
+
+    # @Todo: to work correctly, plantloop.total_heating_capacity requires to have either hardsized capacities or a sizing run.
+    primary_heating_capacity = total_heating_capacity
+    secondary_heating_capacity = 0
+
+    supplyComponents.each do |component|
+
+      # Get the object type
+      obj_type = component.iddObjectType.valueName.to_s
+
+      case obj_type
+      when 'OS_DistrictHeating'
+        primary_fuels << 'DistrictHeating'
+        combination_system = false
+      when 'OS_HeatPump_WaterToWater_EquationFit_Heating'
+        primary_fuels << 'Electricity'
+      when 'OS_SolarCollector_FlatPlate_PhotovoltaicThermal'
+        primary_fuels << 'SolarEnergy'
+      when 'OS_SolarCollector_FlatPlate_Water'
+        primary_fuels << 'SolarEnergy'
+      when 'OS_SolarCollector_IntegralCollectorStorage'
+        primary_fuels << 'SolarEnergy'
+      when 'OS_WaterHeater_HeatPump'
+        primary_fuels << 'Electricity'
+      when 'OS_WaterHeater_Mixed'
+        component = component.to_WaterHeaterMixed.get
+        # Check it it's actually a heater, not just a storage tank
+        if component.heaterMaximumCapacity.empty? || component.heaterMaximumCapacity.get != 0
+          # If it does, we add the heater Fuel Type
+          primary_fuels << component.heaterFuelType
+          # And in this case we'll reuse this object
+          combination_system = false
+        end  # @Todo: not sure about whether it should be an elsif or not
+        # Check the plant loop connection on the source side
+        if component.secondaryPlantLoop.is_initialized
+          source_plant_loop = component.secondaryPlantLoop.get
+          secondary_fuels += plant_loop_heating_fuels(source_plant_loop)
+          secondary_heating_capacity += source_plant_loop.total_heating_capacity
+        end
 
+        # Storage capacity
+        if component.tankVolume.is_initialized
+          storage_capacity = component.tankVolume.get
+        end
 
-end
+      when 'OS_WaterHeater_Stratified'
+        component = component.to_WaterHeaterStratified.get
+
+        # Check if the heater actually has a capacity (otherwise it's simply a Storage Tank)
+        if component.heaterMaximumCapacity.empty? || component.heaterMaximumCapacity.get != 0
+          # If it does, we add the heater Fuel Type
+          primary_fuels << component.heaterFuelType
+          # And in this case we'll reuse this object
+          combination_system = false
+        end # @Todo: not sure about whether it should be an elsif or not
+        # Check the plant loop connection on the source side
+        if component.secondaryPlantLoop.is_initialized
+          source_plant_loop = component.secondaryPlantLoop.get
+          secondary_fuels += plant_loop_heating_fuels(source_plant_loop)
+          secondary_heating_capacity += source_plant_loop.total_heating_capacity
+        end
+
+        # Storage capacity
+        if component.tankVolume.is_initialized
+          storage_capacity = component.tankVolume.get
+        end
+
+      when 'OS_HeatExchanger_FluidToFluid'
+        hx = component.to_HeatExchangerFluidToFluid.get
+        cooling_hx_control_types = ["CoolingSetpointModulated", "CoolingSetpointOnOff", "CoolingDifferentialOnOff", "CoolingSetpointOnOffWithComponentOverride"]
+        cooling_hx_control_types.each {|x| x.downcase!}
+        if !cooling_hx_control_types.include?(hx.controlType.downcase) && hx.secondaryPlantLoop.is_initialized
+          source_plant_loop = hx.secondaryPlantLoop.get
+          secondary_fuels += plant_loop_heating_fuels(source_plant_loop)
+          secondary_heating_capacity += source_plant_loop.total_heating_capacity
+        end
+
+      when 'OS_Node', 'OS_Pump_ConstantSpeed', 'OS_Pump_VariableSpeed', 'OS_Connector_Splitter', 'OS_Connector_Mixer', 'OS_Pipe_Adiabatic'
+        # To avoid extraneous debug messages
+      else
+        #OpenStudio::logFree(OpenStudio::Debug, 'openstudio.sizing.Model', "No heating fuel types found for #{obj_type}")
+      end
+
+    end
 
+    # @Todo: decide how to handle primary and secondary stuff
+    fuels = primary_fuels + secondary_fuels
+    total_heating_capacity = primary_heating_capacity + secondary_heating_capacity
+    # If the primary heating capacity is bigger than secondary, assume the secondary is just a backup and disregard it?
+    # if primary_heating_capacity > secondary_heating_capacity
+    #   total_heating_capacity = primary_heating_capacity
+    #   fuels = primary_fuels
+    # end
+
+    return fuels.uniq.sort, combination_system, storage_capacity, total_heating_capacity
+
+  end # end classify_swh_system_type  
+  
+end