openstudio-standards 0.1.4 → 0.1.5

data/lib/openstudio-standards/prototypes/Prototype.FanVariableVolume.rb

@@ -1,39 +1,39 @@
 
 # open the class to add methods to return sizing values
 class OpenStudio::Model::FanVariableVolume
+  include PrototypeFan
 
   # Sets the fan pressure rise based on the Prototype buildings inputs
   # which are governed by the flow rate coming through the fan
   # and whether the fan lives inside a unit heater, PTAC, etc.
-  def setPrototypeFanPressureRise(building_type, building_vintage, climate_zone)
-    
+  def apply_prototype_fan_pressure_rise(building_type, template, climate_zone)
     # NECB
-    if building_vintage == 'NECB 2011' then
+    if template == 'NECB 2011'
       pressure_rise_pa = 1000.0
-      self.setPressureRise(pressure_rise_pa)
+      setPressureRise(pressure_rise_pa)
       return true
-    end    
-    
+    end
+
     # Get the max flow rate from the fan.
     maximum_flow_rate_m3_per_s = nil
-    if self.maximumFlowRate.is_initialized
-      maximum_flow_rate_m3_per_s = self.maximumFlowRate.get
-    elsif self.autosizedMaximumFlowRate.is_initialized
-      maximum_flow_rate_m3_per_s = self.autosizedMaximumFlowRate.get
+    if maximumFlowRate.is_initialized
+      maximum_flow_rate_m3_per_s = maximumFlowRate.get
+    elsif autosizedMaximumFlowRate.is_initialized
+      maximum_flow_rate_m3_per_s = autosizedMaximumFlowRate.get
     else
-      OpenStudio::logFree(OpenStudio::Warn, "openstudio.prototype.FanVariableVolume", "For #{self.name} max flow rate is not available, cannot apply prototype assumptions.")
+      OpenStudio.logFree(OpenStudio::Warn, 'openstudio.prototype.FanVariableVolume', "For #{name} max flow rate is not available, cannot apply prototype assumptions.")
       return false
     end
-    
+
     # Convert max flow rate to cfm
     maximum_flow_rate_cfm = OpenStudio.convert(maximum_flow_rate_m3_per_s, 'm^3/s', 'cfm').get
-    
-    # Pressure rise will be determined based on the 
+
+    # Pressure rise will be determined based on the
     # following logic.
-    pressure_rise_in_h2o = 0.0  
-    
+    pressure_rise_in_h2o = 0.0
+
     # If the fan lives inside of a zone hvac equipment
-    if self.containingZoneHVACComponent.is_initialized
+    if containingZoneHVACComponent.is_initialized
       zone_hvac = self.ZoneHVACComponent.get
       if zone_hvac.to_ZoneHVACPackagedTerminalAirConditioner.is_initialized
         pressure_rise_in_h2o = 1.33
@@ -44,56 +44,50 @@ class OpenStudio::Model::FanVariableVolume
       else # This type of fan should not exist in the prototype models
         return false
       end
-    end
-    
-    # TODO Inconsistency - Primary School uses CAV pressure rises
-    # even thought it has a VAV system.  CAV system is listed in document,
-    # so assume the system type was updated but forgot to update pressure rises.
-    if building_type == 'PrimarySchool' && (building_vintage == 'DOE Ref Pre-1980' || building_vintage == 'DOE Ref 1980-2004')
-      
-      # If the fan lives on an airloop (From Prototype.FanConstantVolume)
-      if self.airLoopHVAC.is_initialized
-        if maximum_flow_rate_cfm < 7487
-          pressure_rise_in_h2o = 2.5
-        elsif maximum_flow_rate_cfm >= 7487 && maximum_flow_rate_cfm < 20000
-          pressure_rise_in_h2o = 4.46
-        else # Over 20,000 cfm
-          pressure_rise_in_h2o = 4.09
-        end
-      end
-    
-    else
-      
-      # If the fan lives on an airloop
-      if self.airLoopHVAC.is_initialized
-        case building_vintage
+    # If the fan lives on an airloop
+    elsif airLoopHVAC.is_initialized
+
+      # TODO: Inconsistency - Primary School uses CAV pressure rises
+      # even thought it has a VAV system.  CAV system is listed in document,
+      # so assume the system type was updated but forgot to update pressure rises.
+      if building_type == 'PrimarySchool' && (template == 'DOE Ref Pre-1980' || template == 'DOE Ref 1980-2004')
+
+        pressure_rise_in_h2o = if maximum_flow_rate_cfm < 7487
+                                 2.5
+                               elsif maximum_flow_rate_cfm >= 7487 && maximum_flow_rate_cfm < 20_000
+                                 4.46
+                               else # Over 20,000 cfm
+                                 4.09
+                               end
+
+      else
+
+        case template
         when 'DOE Ref Pre-1980', 'DOE Ref 1980-2004', '90.1-2004'
-          if maximum_flow_rate_cfm < 4648
-            pressure_rise_in_h2o = 4.0
-          elsif maximum_flow_rate_cfm >= 4648 && maximum_flow_rate_cfm < 20000
-            pressure_rise_in_h2o = 6.32
-          else # Over 20,000 cfm
-            pressure_rise_in_h2o = 5.58
-          end
+          pressure_rise_in_h2o = if maximum_flow_rate_cfm < 4648
+                                   4.0
+                                 elsif maximum_flow_rate_cfm >= 4648 && maximum_flow_rate_cfm < 20_000
+                                   6.32
+                                 else # Over 20,000 cfm
+                                   5.58
+                                 end
         when '90.1-2007', '90.1-2010', '90.1-2013'
-          if maximum_flow_rate_cfm < 4648
-            pressure_rise_in_h2o = 4.0
-          else # Over 7,437 cfm
-            pressure_rise_in_h2o = 5.58
-          end
+          pressure_rise_in_h2o = if maximum_flow_rate_cfm < 4648
+                                   4.0
+                                 else # Over 7,437 cfm
+                                   5.58
+                                 end
         end
+
       end
-      
     end
-    
+
     # Set the fan pressure rise
-    pressure_rise_pa = OpenStudio.convert(pressure_rise_in_h2o, 'inH_{2}O','Pa').get
-    self.setPressureRise(pressure_rise_pa)  
-    
-    OpenStudio::logFree(OpenStudio::Info, 'openstudio.model.FanVariableVolume', "For Prototype: #{self.name}: #{maximum_flow_rate_cfm.round}cfm; Pressure Rise = #{pressure_rise_in_h2o}in w.c.")
-    
+    pressure_rise_pa = OpenStudio.convert(pressure_rise_in_h2o, 'inH_{2}O', 'Pa').get
+    setPressureRise(pressure_rise_pa)
+
+    OpenStudio.logFree(OpenStudio::Info, 'openstudio.model.FanVariableVolume', "For Prototype: #{name}: #{maximum_flow_rate_cfm.round}cfm; Pressure Rise = #{pressure_rise_in_h2o}in w.c.")
+
     return true
-    
   end
-
 end

data/lib/openstudio-standards/prototypes/Prototype.FanZoneExhaust.rb

@@ -1,22 +1,20 @@
 
 # Reopen the OpenStudio class to add methods to apply standards to this object
 class OpenStudio::Model::FanZoneExhaust
+  include PrototypeFan
 
   # Sets the fan pressure rise based on the Prototype buildings inputs
-  def setPrototypeFanPressureRise
-    
+  def apply_prototype_fan_pressure_rise
     # All exhaust fans are assumed to have a pressure rise of
     # 0.5 in w.c. in the prototype building models.
     pressure_rise_in_h2o = 0.5
-    
+
     # Set the pressure rise
-    pressure_rise_pa = OpenStudio.convert(pressure_rise_in_h2o, 'inH_{2}O','Pa').get
-    self.setPressureRise(pressure_rise_pa)  
-    
-    OpenStudio::logFree(OpenStudio::Info, 'openstudio.model.FanZoneExhaust', "For Prototype: #{self.name}: Pressure Rise = #{pressure_rise_in_h2o}in w.c.")
-    
+    pressure_rise_pa = OpenStudio.convert(pressure_rise_in_h2o, 'inH_{2}O', 'Pa').get
+    setPressureRise(pressure_rise_pa)
+
+    OpenStudio.logFree(OpenStudio::Info, 'openstudio.model.FanZoneExhaust', "For Prototype: #{name}: Pressure Rise = #{pressure_rise_in_h2o}in w.c.")
+
     return true
-    
   end
-
 end

data/lib/openstudio-standards/prototypes/Prototype.HeatExchangerAirToAirSensibleAndLatent.rb

@@ -1,15 +1,13 @@
 
 # Reopen the OpenStudio class to add methods to apply standards to this object
 class OpenStudio::Model::HeatExchangerAirToAirSensibleAndLatent
-
-  def setPrototypeNominalElectricPower
-
+  def apply_prototype_nominal_electric_power
     # Get the nominal supply air flow rate
     supply_air_flow_m3_per_s = nil
-    if self.nominalSupplyAirFlowRate.is_initialized
-      supply_air_flow_m3_per_s = self.nominalSupplyAirFlowRate.get
-    elsif self.autosizedNominalSupplyAirFlowRate.is_initialized
-      supply_air_flow_m3_per_s = self.autosizedNominalSupplyAirFlowRate.get
+    if nominalSupplyAirFlowRate.is_initialized
+      supply_air_flow_m3_per_s = nominalSupplyAirFlowRate.get
+    elsif autosizedNominalSupplyAirFlowRate.is_initialized
+      supply_air_flow_m3_per_s = autosizedNominalSupplyAirFlowRate.get
     else
       # Get the min OA flow rate from the OA
       # system if the ERV was not on the system during sizing.
@@ -17,9 +15,9 @@ class OpenStudio::Model::HeatExchangerAirToAirSensibleAndLatent
       controller_oa = nil
       oa_system = nil
       # Get the air loop
-      air_loop = self.airLoopHVAC
+      air_loop = airLoopHVAC
       if air_loop.empty?
-        OpenStudio::logFree(OpenStudio::Info, "openstudio.prototype.HeatExchangerAirToAirSensibleAndLatent", "For #{self.name}, cannot get the air loop and therefore cannot get the min OA flow.")
+        OpenStudio.logFree(OpenStudio::Info, 'openstudio.prototype.HeatExchangerAirToAirSensibleAndLatent', "For #{name}, cannot get the air loop and therefore cannot get the min OA flow.")
         return false
       end
       air_loop = air_loop.get
@@ -28,38 +26,35 @@ class OpenStudio::Model::HeatExchangerAirToAirSensibleAndLatent
         oa_system = air_loop.airLoopHVACOutdoorAirSystem.get
         controller_oa = oa_system.getControllerOutdoorAir
       else
-        OpenStudio::logFree(OpenStudio::Info, "openstudio.prototype.HeatExchangerAirToAirSensibleAndLatent", "For #{self.name}, cannot find the min OA flow because it has no OA intake.")
+        OpenStudio.logFree(OpenStudio::Info, 'openstudio.prototype.HeatExchangerAirToAirSensibleAndLatent', "For #{name}, cannot find the min OA flow because it has no OA intake.")
         return false
       end
-      # Get the min OA flow rate from the OA      
+      # Get the min OA flow rate from the OA
       if controller_oa.minimumOutdoorAirFlowRate.is_initialized
         supply_air_flow_m3_per_s = controller_oa.minimumOutdoorAirFlowRate.get
       elsif controller_oa.autosizedMinimumOutdoorAirFlowRate.is_initialized
         supply_air_flow_m3_per_s = controller_oa.autosizedMinimumOutdoorAirFlowRate.get
       else
-        OpenStudio::logFree(OpenStudio::Warn, "openstudio.prototype.HeatExchangerAirToAirSensibleAndLatent", "For #{self.name}, ERV minimum OA flow rate is not available, cannot apply prototype nominal power assumption.")
+        OpenStudio.logFree(OpenStudio::Warn, 'openstudio.prototype.HeatExchangerAirToAirSensibleAndLatent', "For #{name}, ERV minimum OA flow rate is not available, cannot apply prototype nominal power assumption.")
         return false
       end
     end
 
     # Convert the flow rate to cfm
-    supply_air_flow_cfm = OpenStudio.convert(supply_air_flow_m3_per_s, "m^3/s", "cfm").get
-    
+    supply_air_flow_cfm = OpenStudio.convert(supply_air_flow_m3_per_s, 'm^3/s', 'cfm').get
+
     # Calculate the motor power for the rotatry wheel per:
     # Power (W) = (Nominal Supply Air Flow Rate (CFM) * 0.3386) + 49.5
     # power = (supply_air_flow_cfm * 0.3386) + 49.5
-    
+
     # Calculate the motor power for the rotatry wheel per:
     # Power (W) = (Minimum Outdoor Air Flow Rate (m^3/s) * 212.5 / 0.5) + (Minimum Outdoor Air Flow Rate (m^3/s) * 162.5 / 0.5) + 50
     power = (supply_air_flow_m3_per_s * 212.5 / 0.5) + (supply_air_flow_m3_per_s * 0.9 * 162.5 / 0.5) + 50
-    OpenStudio::logFree(OpenStudio::Info, "openstudio.prototype.HeatExchangerAirToAirSensibleAndLatent", "For #{self.name}, ERV power is calculated to be #{power.round} W, based on a min OA flow of #{supply_air_flow_cfm.round} cfm.")
+    OpenStudio.logFree(OpenStudio::Info, 'openstudio.prototype.HeatExchangerAirToAirSensibleAndLatent', "For #{name}, ERV power is calculated to be #{power.round} W, based on a min OA flow of #{supply_air_flow_cfm.round} cfm.")
 
     # Set the power for the HX
-    self.setNominalElectricPower(power)
+    setNominalElectricPower(power)
 
     return true
-
   end
-
 end
-  

data/lib/openstudio-standards/prototypes/Prototype.Model.hvac.rb

@@ -1,370 +1,380 @@
 
 # open the class to add methods to size all HVAC equipment
 class OpenStudio::Model::Model
-
-  def add_hvac(building_type, building_vintage, climate_zone, prototype_input)
-
-    OpenStudio::logFree(OpenStudio::Info, 'openstudio.model.Model', 'Started Adding HVAC')
-
-    # Get the list of HVAC systems, as defined
-    # for each building in the Prototype.building_name files.
-    system_to_space_map = define_hvac_system_map(building_type, building_vintage, climate_zone)
-
-    # Add each HVAC system
-    system_to_space_map.each do |system|
-
-    thermal_zones = get_zones_from_spaces_on_system(system)
-
-    return_plenum = get_return_plenum_from_system(system)
-
-      # Add the HVAC systems
-      case system['type']
-      when 'VAV'
-
-        # Retrieve the existing hot water loop
-        # or add a new one if necessary.
-        hot_water_loop = nil
-        if self.getPlantLoopByName('Hot Water Loop').is_initialized
-          hot_water_loop = self.getPlantLoopByName('Hot Water Loop').get
-        else
-          hot_water_loop = self.add_hw_loop('NaturalGas', building_type)
-        end
-
-        # Retrieve the existing chilled water loop
-        # or add a new one if necessary.
-        chilled_water_loop = nil
-        if self.getPlantLoopByName('Chilled Water Loop').is_initialized
-          chilled_water_loop = self.getPlantLoopByName('Chilled Water Loop').get
-        else
-          condenser_water_loop = nil
-          number_cooling_towers = 1
-          num_chillers = 1
-          if building_type == "Hospital" or building_type == "LargeOffice"
-            case building_vintage
+  def add_hvac(building_type, template, climate_zone, prototype_input, epw_file)
+    OpenStudio.logFree(OpenStudio::Info, 'openstudio.model.Model', 'Started Adding HVAC')
+    case template
+    when 'NECB 2011'
+      boiler_fueltype, baseboard_type, mau_type, mau_heating_coil_type, mua_cooling_type, chiller_type, heating_coil_types_sys3, heating_coil_types_sys4, heating_coil_types_sys6, fan_type = BTAP::Environment.get_canadian_system_defaults_by_weatherfile_name(epw_file)
+      BTAP::Compliance::NECB2011.necb_autozone_and_autosystem(self, runner = nil, use_ideal_air_loads = false, boiler_fueltype, mau_type, mau_heating_coil_type, baseboard_type, chiller_type, mua_cooling_type, heating_coil_types_sys3, heating_coil_types_sys4, heating_coil_types_sys6, fan_type)
+    else
+      # Get the list of HVAC systems, as defined
+      # for each building in the Prototype.building_name files.
+      system_to_space_map = define_hvac_system_map(building_type, template, climate_zone)
+
+      # Add each HVAC system
+      system_to_space_map.each do |system|
+        thermal_zones = get_zones_from_spaces_on_system(system)
+
+        return_plenum = get_return_plenum_from_system(system)
+
+        # Add the HVAC systems
+        case system['type']
+        when 'VAV'
+
+          # Retrieve the existing hot water loop
+          # or add a new one if necessary.
+          hot_water_loop = nil
+          hot_water_loop = if getPlantLoopByName('Hot Water Loop').is_initialized
+                             getPlantLoopByName('Hot Water Loop').get
+                           else
+                             add_hw_loop('NaturalGas', building_type)
+                           end
+
+          # Retrieve the existing chilled water loop
+          # or add a new one if necessary.
+          chilled_water_loop = nil
+          if getPlantLoopByName('Chilled Water Loop').is_initialized
+            chilled_water_loop = getPlantLoopByName('Chilled Water Loop').get
+          else
+            condenser_water_loop = nil
+            number_cooling_towers = 1
+            num_chillers = 1
+            if building_type == 'Hospital' || building_type == 'LargeOffice'
+              case template
               when '90.1-2004', '90.1-2007', '90.1-2010', '90.1-2013'
                 number_cooling_towers = 2
                 num_chillers = 2
+              end
+            end
+            if prototype_input['chiller_cooling_type'] == 'WaterCooled'
+              condenser_water_loop = add_cw_loop(template,
+                                                 'Open Cooling Tower',
+                                                 'Centrifugal',
+                                                 'Fan Cycling',
+                                                 2,
+                                                 1,
+                                                 building_type)
             end
-          end
-          if prototype_input['chiller_cooling_type'] == 'WaterCooled'
-            condenser_water_loop = self.add_cw_loop(building_type, building_vintage, number_cooling_towers)
-          end
-          chilled_water_loop = self.add_chw_loop(
-                                  building_vintage,
-                                  prototype_input['chw_pumping_type'],
-                                  prototype_input['chiller_cooling_type'],
-                                  prototype_input['chiller_condenser_type'],
-                                  prototype_input['chiller_compressor_type'],
-                                  prototype_input['chiller_capacity_guess'],
-                                  condenser_water_loop,
-                                  building_type,
-                                  num_chillers
-                                )
-        end
 
-        # Add the VAV
-        self.add_vav_reheat(building_vintage,
-          system['name'],
-          hot_water_loop,
-          chilled_water_loop,
-          thermal_zones,
-          prototype_input['vav_operation_schedule'],
-          prototype_input['vav_oa_damper_schedule'],
-          prototype_input['vav_fan_efficiency'],
-          prototype_input['vav_fan_motor_efficiency'],
-          prototype_input['vav_fan_pressure_rise'],
-          return_plenum,
-          building_type
-        )
-
-
-      when 'CAV'
-
-        # Retrieve the existing hot water loop
-        # or add a new one if necessary.
-        hot_water_loop = nil
-        if self.getPlantLoopByName('Hot Water Loop').is_initialized
-          hot_water_loop = self.getPlantLoopByName('Hot Water Loop').get
-        else
-          hot_water_loop = self.add_hw_loop('NaturalGas',building_type)
-        end
+            chilled_water_loop = add_chw_loop(template,
+                                              prototype_input['chw_pumping_type'],
+                                              prototype_input['chiller_cooling_type'],
+                                              prototype_input['chiller_condenser_type'],
+                                              prototype_input['chiller_compressor_type'],
+                                              'Electricity',
+                                              condenser_water_loop)
 
-        chilled_water_loop = nil
-        if self.getPlantLoopByName('Chilled Water Loop').is_initialized
-          chilled_water_loop = self.getPlantLoopByName('Chilled Water Loop').get
-        elsif building_type == 'Hospital'
-          condenser_water_loop = nil
-          if prototype_input['chiller_cooling_type'] == 'WaterCooled'
-            condenser_water_loop = self.add_cw_loop()
           end
 
-          chilled_water_loop = self.add_chw_loop(building_vintage,
-                                                prototype_input['chw_pumping_type'],
-                                                prototype_input['chiller_cooling_type'],
-                                                prototype_input['chiller_condenser_type'],
-                                                prototype_input['chiller_compressor_type'],
-                                                prototype_input['chiller_capacity_guess'],
-                                                condenser_water_loop)
-        end
-
-        # Add the CAV
-        self.add_cav(building_vintage,
-                    system['name'],
-                    hot_water_loop,
-                    thermal_zones,
-                    prototype_input['vav_operation_schedule'],
-                    prototype_input['vav_oa_damper_schedule'],
-                    prototype_input['vav_fan_efficiency'],
-                    prototype_input['vav_fan_motor_efficiency'],
-                    prototype_input['vav_fan_pressure_rise'],
-                    chilled_water_loop,
-                    building_type)
-
-      when 'PSZ-AC'
-
-        # Special logic to differentiate between operation schedules
-        # that vary even inside of a system type for stripmall.
-        hvac_op_sch = nil
-        oa_sch = nil
-        if system['hvac_op_sch_index'].nil? || system['hvac_op_sch_index'] == 1
-          hvac_op_sch = prototype_input['pszac_operation_schedule']
-          oa_sch = prototype_input['pszac_oa_damper_schedule']
-        elsif system['hvac_op_sch_index'] == 2
-          hvac_op_sch = prototype_input['pszac_operation_schedule_2']
-          oa_sch = prototype_input['pszac_oa_damper_schedule_2']
-        elsif system['hvac_op_sch_index'] == 3
-          hvac_op_sch = prototype_input['pszac_operation_schedule_3']
-          oa_sch = prototype_input['pszac_oa_damper_schedule_3']
-        end
-
-        # Special logic to make unitary heat pumps all blow-through
-        fan_position = 'DrawThrough'
-        if prototype_input['pszac_heating_type'] == 'Single Speed Heat Pump' ||
-          prototype_input['pszac_heating_type'] == 'Water To Air Heat Pump'
-          fan_position = 'BlowThrough'
-        end
+          # Add the VAV
+          add_vav_reheat(template,
+                         system['name'],
+                         hot_water_loop,
+                         chilled_water_loop,
+                         thermal_zones,
+                         prototype_input['vav_operation_schedule'],
+                         prototype_input['vav_oa_damper_schedule'],
+                         prototype_input['vav_fan_efficiency'],
+                         prototype_input['vav_fan_motor_efficiency'],
+                         prototype_input['vav_fan_pressure_rise'],
+                         return_plenum,
+                         electric_reheat = false,
+                         building_type)
+
+        when 'CAV'
+
+          # Retrieve the existing hot water loop
+          # or add a new one if necessary.
+          hot_water_loop = nil
+          hot_water_loop = if getPlantLoopByName('Hot Water Loop').is_initialized
+                             getPlantLoopByName('Hot Water Loop').get
+                           else
+                             add_hw_loop('NaturalGas', building_type)
+                           end
+
+          chilled_water_loop = nil
+          if getPlantLoopByName('Chilled Water Loop').is_initialized
+            chilled_water_loop = getPlantLoopByName('Chilled Water Loop').get
+          elsif building_type == 'Hospital'
+            condenser_water_loop = nil
+            if prototype_input['chiller_cooling_type'] == 'WaterCooled'
+              condenser_water_loop = add_cw_loop
+            end
 
-        # Special logic to make a heat pump loop if necessary
-        heat_pump_loop = nil
-        if prototype_input['pszac_heating_type'] == 'Water To Air Heat Pump'
-          heat_pump_loop = add_hp_loop(building_type)
-        end
+            chilled_water_loop = add_chw_loop(template,
+                                              prototype_input['chw_pumping_type'],
+                                              prototype_input['chiller_cooling_type'],
+                                              prototype_input['chiller_condenser_type'],
+                                              prototype_input['chiller_compressor_type'],
+                                              prototype_input['chiller_capacity_guess'],
+                                              condenser_water_loop)
+          end
 
-        self.add_psz_ac(building_vintage,
-                        system['name'],
-                        heat_pump_loop, # Typically nil unless water source hp
-                        heat_pump_loop, # Typically nil unless water source hp
-                        thermal_zones,
-                        hvac_op_sch,
-                        oa_sch,
-                        fan_position,
-                        prototype_input['pszac_fan_type'],
-                        prototype_input['pszac_heating_type'],
-                        prototype_input['pszac_supplemental_heating_type'],
-                        prototype_input['pszac_cooling_type'],
-                        building_type)
-
-      when 'PVAV'
-
-        # Retrieve the existing hot water loop
-        # or add a new one if necessary.
-        hot_water_loop = nil
-        if self.getPlantLoopByName('Hot Water Loop').is_initialized
-          hot_water_loop = self.getPlantLoopByName('Hot Water Loop').get
-        elsif building_type == 'MediumOffice'
-          hot_water_loop = nil
-        else
-          hot_water_loop = self.add_hw_loop('NaturalGas',building_type)
-        end
+          # Add the CAV
+          add_cav(template,
+                  system['name'],
+                  hot_water_loop,
+                  thermal_zones,
+                  prototype_input['vav_operation_schedule'],
+                  prototype_input['vav_oa_damper_schedule'],
+                  prototype_input['vav_fan_efficiency'],
+                  prototype_input['vav_fan_motor_efficiency'],
+                  prototype_input['vav_fan_pressure_rise'],
+                  chilled_water_loop,
+                  building_type)
+
+        when 'PSZ-AC'
+
+          # Special logic to differentiate between operation schedules
+          # that vary even inside of a system type for stripmall.
+          hvac_op_sch = nil
+          oa_sch = nil
+          if system['hvac_op_sch_index'].nil? || system['hvac_op_sch_index'] == 1
+            hvac_op_sch = prototype_input['pszac_operation_schedule']
+            oa_sch = prototype_input['pszac_oa_damper_schedule']
+          elsif system['hvac_op_sch_index'] == 2
+            hvac_op_sch = prototype_input['pszac_operation_schedule_2']
+            oa_sch = prototype_input['pszac_oa_damper_schedule_2']
+          elsif system['hvac_op_sch_index'] == 3
+            hvac_op_sch = prototype_input['pszac_operation_schedule_3']
+            oa_sch = prototype_input['pszac_oa_damper_schedule_3']
+          end
 
-        self.add_pvav(building_vintage,
-                      system['name'],
-                      thermal_zones,
-                      prototype_input['vav_operation_schedule'],
-                      prototype_input['vav_oa_damper_schedule'],
-                      hot_water_loop,
-                      return_plenum,
-                      building_type)
-
-      when 'DOAS'
-
-        # Retrieve the existing hot water loop
-        # or add a new one if necessary.
-        hot_water_loop = nil
-        if self.getPlantLoopByName('Hot Water Loop').is_initialized
-          hot_water_loop = self.getPlantLoopByName('Hot Water Loop').get
-        else
-          hot_water_loop = self.add_hw_loop('NaturalGas',building_type)
-        end
+          # Special logic to make unitary heat pumps all blow-through
+          fan_position = 'DrawThrough'
+          if prototype_input['pszac_heating_type'] == 'Single Speed Heat Pump' ||
+             prototype_input['pszac_heating_type'] == 'Water To Air Heat Pump'
+            fan_position = 'BlowThrough'
+          end
 
-        # Retrieve the existing chilled water loop
-        # or add a new one if necessary.
-        chilled_water_loop = nil
-        if self.getPlantLoopByName('Chilled Water Loop').is_initialized
-          chilled_water_loop = self.getPlantLoopByName('Chilled Water Loop').get
-        else
-          condenser_water_loop = nil
-          if prototype_input['chiller_cooling_type'] == 'WaterCooled'
-            condenser_water_loop = self.add_cw_loop()
+          # Special logic to make a heat pump loop if necessary
+          heat_pump_loop = nil
+          if prototype_input['pszac_heating_type'] == 'Water To Air Heat Pump'
+            heat_pump_loop = add_hp_loop(building_type)
           end
 
-          chilled_water_loop = self.add_chw_loop(building_vintage,
-                                                prototype_input['chw_pumping_type'],
-                                                prototype_input['chiller_cooling_type'],
-                                                prototype_input['chiller_condenser_type'],
-                                                prototype_input['chiller_compressor_type'],
-                                                prototype_input['chiller_capacity_guess'],
-                                                condenser_water_loop)
-        end
+          add_psz_ac(template,
+                     system['name'],
+                     heat_pump_loop, # Typically nil unless water source hp
+                     heat_pump_loop, # Typically nil unless water source hp
+                     thermal_zones,
+                     hvac_op_sch,
+                     oa_sch,
+                     fan_position,
+                     prototype_input['pszac_fan_type'],
+                     prototype_input['pszac_heating_type'],
+                     prototype_input['pszac_supplemental_heating_type'],
+                     prototype_input['pszac_cooling_type'],
+                     building_type)
+
+        when 'PVAV'
+
+          # Retrieve the existing hot water loop
+          # or add a new one if necessary.
+          hot_water_loop = nil
+          hot_water_loop = if getPlantLoopByName('Hot Water Loop').is_initialized
+                             getPlantLoopByName('Hot Water Loop').get
+                           elsif building_type == 'MediumOffice'
+                             nil
+                           else
+                             add_hw_loop('NaturalGas', building_type)
+                           end
+
+          add_pvav(template,
+                   system['name'],
+                   thermal_zones,
+                   prototype_input['vav_operation_schedule'],
+                   prototype_input['vav_oa_damper_schedule'],
+                   electric_reheat = false,
+                   hot_water_loop,
+                   chilled_water_loop = nil,
+                   return_plenum,
+                   building_type)
+
+        when 'DOAS'
+
+          # Retrieve the existing hot water loop
+          # or add a new one if necessary.
+          hot_water_loop = nil
+          hot_water_loop = if getPlantLoopByName('Hot Water Loop').is_initialized
+                             getPlantLoopByName('Hot Water Loop').get
+                           else
+                             add_hw_loop('NaturalGas', building_type)
+                           end
+
+          # Retrieve the existing chilled water loop
+          # or add a new one if necessary.
+          chilled_water_loop = nil
+          if getPlantLoopByName('Chilled Water Loop').is_initialized
+            chilled_water_loop = getPlantLoopByName('Chilled Water Loop').get
+          else
+            condenser_water_loop = nil
+            if prototype_input['chiller_cooling_type'] == 'WaterCooled'
+              condenser_water_loop = add_cw_loop(template,
+                                                 'Open Cooling Tower',
+                                                 'Centrifugal',
+                                                 'Fan Cycling',
+                                                 2,
+                                                 1,
+                                                 building_type)
+            end
 
-        self.add_doas(building_vintage,
-                    system['name'],
-                    hot_water_loop,
-                    chilled_water_loop,
-                    thermal_zones,
-                    prototype_input['vav_operation_schedule'],
-                    prototype_input['doas_oa_damper_schedule'],
-                    prototype_input['doas_fan_maximum_flow_rate'],
-                    prototype_input['doas_economizer_control_type'],
-                    building_type)
-
-      when 'DC' # Data Center
-
-        # Retrieve the existing hot water loop
-        # or add a new one if necessary.
-        hot_water_loop = nil
-        if self.getPlantLoopByName('Hot Water Loop').is_initialized
-          hot_water_loop = self.getPlantLoopByName('Hot Water Loop').get
-        else
-          hot_water_loop = self.add_hw_loop('NaturalGas',building_type)
-        end
+            chilled_water_loop = add_chw_loop(template,
+                                              prototype_input['chw_pumping_type'],
+                                              prototype_input['chiller_cooling_type'],
+                                              prototype_input['chiller_condenser_type'],
+                                              prototype_input['chiller_compressor_type'],
+                                              'Electricity',
+                                              condenser_water_loop)
+          end
 
-        # Retrieve the existing heat pump loop
-        # or add a new one if necessary.
-        heat_pump_loop = nil
-        if self.getPlantLoopByName('Heat Pump Loop').is_initialized
-          heat_pump_loop = self.getPlantLoopByName('Heat Pump Loop').get
+          add_doas(template,
+                   system['name'],
+                   hot_water_loop,
+                   chilled_water_loop,
+                   thermal_zones,
+                   prototype_input['vav_operation_schedule'],
+                   prototype_input['doas_oa_damper_schedule'],
+                   prototype_input['doas_fan_maximum_flow_rate'],
+                   prototype_input['doas_economizer_control_type'],
+                   building_type)
+
+        when 'DC' # Data Center
+
+          # Retrieve the existing hot water loop
+          # or add a new one if necessary.
+          hot_water_loop = nil
+          hot_water_loop = if getPlantLoopByName('Hot Water Loop').is_initialized
+                             getPlantLoopByName('Hot Water Loop').get
+                           else
+                             add_hw_loop('NaturalGas', building_type)
+                           end
+
+          # Retrieve the existing heat pump loop
+          # or add a new one if necessary.
+          heat_pump_loop = nil
+          heat_pump_loop = if getPlantLoopByName('Heat Pump Loop').is_initialized
+                             getPlantLoopByName('Heat Pump Loop').get
+                           else
+                             add_hp_loop(building_type)
+                           end
+
+          add_data_center_hvac(template,
+                               nil,
+                               hot_water_loop,
+                               heat_pump_loop,
+                               thermal_zones,
+                               prototype_input['flow_fraction_schedule_name'],
+                               prototype_input['flow_fraction_schedule_name'],
+                               system['main_data_center'])
+
+        when 'SAC'
+
+          add_split_ac(template,
+                       nil,
+                       thermal_zones,
+                       prototype_input['sac_operation_schedule'],
+                       prototype_input['sac_operation_schedule_meeting'],
+                       prototype_input['sac_oa_damper_schedule'],
+                       prototype_input['sac_fan_type'],
+                       prototype_input['sac_heating_type'],
+                       prototype_input['sac_heating_type'],
+                       prototype_input['sac_cooling_type'],
+                       building_type)
+
+        when 'UnitHeater'
+
+          add_unitheater(template,
+                         nil,
+                         thermal_zones,
+                         prototype_input['unitheater_operation_schedule'],
+                         prototype_input['unitheater_fan_control_type'],
+                         OpenStudio.convert(prototype_input['unitheater_fan_static_pressure'], 'inH_{2}O', 'Pa').get,
+                         prototype_input['unitheater_heating_type'],
+                         hot_water_loop = nil,
+                         building_type)
+
+        when 'PTAC'
+
+          add_ptac(template,
+                   nil,
+                   nil,
+                   thermal_zones,
+                   prototype_input['ptac_fan_type'],
+                   prototype_input['ptac_heating_type'],
+                   prototype_input['ptac_cooling_type'],
+                   building_type)
+
+        when 'Exhaust Fan'
+
+          add_exhaust_fan(system['availability_sch_name'],
+                          system['flow_rate'],
+                          system['flow_fraction_schedule_name'],
+                          system['balanced_exhaust_fraction_schedule_name'],
+                          thermal_zones)
+
+        when 'Zone Ventilation'
+
+          add_zone_ventilation(system['availability_sch_name'],
+                               system['flow_rate'],
+                               system['ventilation_type'],
+                               thermal_zones)
+
+        when 'Refrigeration'
+
+          add_refrigeration(template,
+                            system['case_type'],
+                            system['cooling_capacity_per_length'],
+                            system['length'],
+                            system['evaporator_fan_pwr_per_length'],
+                            system['lighting_per_length'],
+                            system['lighting_sch_name'],
+                            system['defrost_pwr_per_length'],
+                            system['restocking_sch_name'],
+                            system['cop'],
+                            system['cop_f_of_t_curve_name'],
+                            system['condenser_fan_pwr'],
+                            system['condenser_fan_pwr_curve_name'],
+                            thermal_zones[0])
         else
-          heat_pump_loop = self.add_hp_loop(building_type)
-        end
 
-        self.add_data_center_hvac(building_vintage,
-                                nil,
-                                hot_water_loop,
-                                heat_pump_loop,
-                                thermal_zones,
-                                prototype_input['flow_fraction_schedule_name'],
-                                prototype_input['flow_fraction_schedule_name'],
-                                system['main_data_center'])
-
-      when 'SAC'
-
-        self.add_split_AC(building_vintage,
-                          nil,
-                          thermal_zones,
-                          prototype_input['sac_operation_schedule'],
-                          prototype_input['sac_operation_schedule_meeting'],
-                          prototype_input['sac_oa_damper_schedule'],
-                          prototype_input['sac_fan_type'],
-                          prototype_input['sac_heating_type'],
-                          prototype_input['sac_heating_type'],
-                          prototype_input['sac_cooling_type'],
-                          building_type)
-
-      when 'UnitHeater'
-
-        self.add_unitheater(building_vintage,
-                            nil,
-                            thermal_zones,
-                            prototype_input['unitheater_operation_schedule'],
-                            prototype_input['unitheater_fan_control_type'],
-                            prototype_input['unitheater_fan_static_pressure'],
-                            prototype_input['unitheater_heating_type'],
-                            building_type)
-
-      when 'PTAC'
-
-        self.add_ptac(building_vintage,
-                      nil,
-                      nil,
-                      thermal_zones,
-                      prototype_input['ptac_fan_type'],
-                      prototype_input['ptac_heating_type'],
-                      prototype_input['ptac_cooling_type'],
-                      building_type)
-
-      when 'Exhaust Fan'
-
-        self.add_exhaust_fan(system['availability_sch_name'],
-                            system['flow_rate'],
-                            system['flow_fraction_schedule_name'],
-                            system['balanced_exhaust_fraction_schedule_name'],
-                            thermal_zones)
-
-      when 'Zone Ventilation'
-
-        self.add_zone_ventilation(system['availability_sch_name'],
-                                  system['flow_rate'],
-                                  system['ventilation_type'],
-                                  thermal_zones)
-
-      when 'Refrigeration'
-
-        self.add_refrigeration(building_vintage,
-                              system['case_type'],
-                              system['cooling_capacity_per_length'],
-                              system['length'],
-                              system['evaporator_fan_pwr_per_length'],
-                              system['lighting_per_length'],
-                              system['lighting_sch_name'],
-                              system['defrost_pwr_per_length'],
-                              system['restocking_sch_name'],
-                              system['cop'],
-                              system['cop_f_of_t_curve_name'],
-                              system['condenser_fan_pwr'],
-                              system['condenser_fan_pwr_curve_name'],
-                              thermal_zones[0])
-      else
-
-        OpenStudio::logFree(OpenStudio::Error, 'openstudio.model.Model', "System type #{system['type']} is not recognized.  This system will not be added.")
+          OpenStudio.logFree(OpenStudio::Error, 'openstudio.model.Model', "System type #{system['type']} is not recognized.  This system will not be added.")
 
+        end
       end
 
     end
 
-    OpenStudio::logFree(OpenStudio::Info, 'openstudio.model.Model', 'Finished adding HVAC')
+    OpenStudio.logFree(OpenStudio::Info, 'openstudio.model.Model', 'Finished adding HVAC')
 
     return true
-
-  end #add hvac
+  end # add hvac
 
   private
 
   def get_zones_from_spaces_on_system(system)
-
     # Find all zones associated with these spaces
     thermal_zones = []
     system['space_names'].each do |space_name|
-      space = self.getSpaceByName(space_name)
+      space = getSpaceByName(space_name)
       if space.empty?
-        OpenStudio::logFree(OpenStudio::Error, 'openstudio.model.Model', "No space called #{space_name} was found in the model")
+        OpenStudio.logFree(OpenStudio::Error, 'openstudio.model.Model', "No space called #{space_name} was found in the model")
         next
       end
       space = space.get
       zone = space.thermalZone
       if zone.empty?
-        OpenStudio::logFree(OpenStudio::Error, 'openstudio.model.Model', "Space #{space_name} has no thermal zone; cannot add an HVAC system to this space.")
+        OpenStudio.logFree(OpenStudio::Error, 'openstudio.model.Model', "Space #{space_name} has no thermal zone; cannot add an HVAC system to this space.")
         next
       end
       thermal_zones << zone.get
     end
 
     return thermal_zones
-
   end
 
   def get_return_plenum_from_system(system)
-
     # Find the zone associated with the return plenum space name
     return_plenum = nil
 
@@ -372,9 +382,9 @@ class OpenStudio::Model::Model
     return return_plenum if system['return_plenum'].nil?
 
     # Get the space
-    space = self.getSpaceByName(system['return_plenum'])
+    space = getSpaceByName(system['return_plenum'])
     if space.empty?
-      OpenStudio::logFree(OpenStudio::Error, 'openstudio.model.Model', "No space called #{space_name} was found in the model")
+      OpenStudio.logFree(OpenStudio::Error, 'openstudio.model.Model', "No space called #{space_name} was found in the model")
       return return_plenum
     end
     space = space.get
@@ -382,12 +392,10 @@ class OpenStudio::Model::Model
     # Get the space's zone
     zone = space.thermalZone
     if zone.empty?
-      OpenStudio::logFree(OpenStudio::Error, 'openstudio.model.Model', "Space #{space_name} has no thermal zone; cannot be a return plenum.")
+      OpenStudio.logFree(OpenStudio::Error, 'openstudio.model.Model', "Space #{space_name} has no thermal zone; cannot be a return plenum.")
       return return_plenum
     end
 
     return zone.get
-
   end
-
 end