openstudio-standards 0.6.3 → 0.7.0.rc1

data/lib/openstudio-standards/prototypes/common/buildings/Prototype.TallBuilding.rb

@@ -185,16 +185,16 @@ module TallBuilding
           OpenStudio.logFree(OpenStudio::Error, 'openstudio.model.Model', 'No story info in the SWH loop.')
           return false
         end
-        main_swh_loop = model_add_swh_loop(model,
-                                           swh_loop_name,
-                                           nil,
-                                           OpenStudio.convert(prototype_input['main_service_water_temperature'], 'F', 'C').get,
-                                           prototype_input['main_service_water_pump_head'].to_f,
-                                           prototype_input['main_service_water_pump_motor_efficiency'],
-                                           OpenStudio.convert(prototype_input['main_water_heater_capacity'], 'Btu/hr', 'W').get,
-                                           OpenStudio.convert(prototype_input['main_water_heater_volume'], 'gal', 'm^3').get,
-                                           swh_fueltype,
-                                           OpenStudio.convert(prototype_input['main_service_water_parasitic_fuel_consumption_rate'], 'Btu/hr', 'W').get)
+        main_swh_loop = OpenstudioStandards::ServiceWaterHeating.create_service_water_heating_loop(model,
+                                                                                                   system_name: swh_loop_name,
+                                                                                                   service_water_temperature: OpenStudio.convert(prototype_input['main_service_water_temperature'], 'F', 'C').get,
+                                                                                                   service_water_pump_head: prototype_input['main_service_water_pump_head'].to_f,
+                                                                                                   service_water_pump_motor_efficiency: prototype_input['main_service_water_pump_motor_efficiency'],
+                                                                                                   water_heater_capacity: OpenStudio.convert(prototype_input['main_water_heater_capacity'], 'Btu/hr', 'W').get,
+                                                                                                   water_heater_volume: OpenStudio.convert(prototype_input['main_water_heater_volume'], 'gal', 'm^3').get,
+                                                                                                   water_heater_fuel: swh_fueltype,
+                                                                                                   on_cycle_parasitic_fuel_consumption_rate: OpenStudio.convert(prototype_input['main_service_water_parasitic_fuel_consumption_rate'], 'Btu/hr', 'W').get,
+                                                                                                   off_cycle_parasitic_fuel_consumption_rate: OpenStudio.convert(prototype_input['main_service_water_parasitic_fuel_consumption_rate'], 'Btu/hr', 'W').get)
 
         # Attach the end uses based on floor function type
         # Office and retail: add to mechanical room only
@@ -225,11 +225,9 @@ module TallBuilding
             next if data['service_water_heating_peak_flow_rate'].to_f < 0.00001 && data['service_water_heating_peak_flow_per_area'].to_f < 0.00001
 
             # Add a service water use for each space
-            space_multiplier = space.multiplier
             water_fixture = model_add_swh_end_uses_by_space(model,
                                                             main_swh_loop,
-                                                            space,
-                                                            space_multiplier)
+                                                            space)
             unless water_fixture.nil?
               water_fixtures << water_fixture
             end
@@ -246,47 +244,44 @@ module TallBuilding
 
     # Add the booster water loop if there is any hotel floor
     if additional_params[:num_of_floor_hotel].to_i > 0
-      swh_booster_loop = model_add_swh_booster(model,
-                                               hotel_swh_loop,
-                                               OpenStudio.convert(prototype_input['booster_water_heater_capacity'], 'Btu/hr', 'W').get,
-                                               OpenStudio.convert(prototype_input['booster_water_heater_volume'], 'gal', 'm^3').get,
-                                               prototype_input['booster_water_heater_fuel'],
-                                               OpenStudio.convert(prototype_input['booster_water_temperature'], 'F', 'C').get,
-                                               0,
-                                               nil)
-
-      # Attach the end uses
-      model_add_booster_swh_end_uses(model,
-                                     swh_booster_loop,
-                                     OpenStudio.convert(prototype_input['booster_service_water_peak_flowrate'], 'gal/min', 'm^3/s').get,
-                                     prototype_input['booster_service_water_flowrate_schedule'],
-                                     OpenStudio.convert(prototype_input['booster_water_use_temperature'], 'F', 'C').get)
-
+      swh_booster_loop = OpenstudioStandards::ServiceWaterHeating.create_booster_water_heating_loop(model,
+                                                                                                    water_heater_capacity: OpenStudio.convert(prototype_input['booster_water_heater_capacity'], 'Btu/hr', 'W').get,
+                                                                                                    water_heater_volume: OpenStudio.convert(prototype_input['booster_water_heater_volume'], 'gal', 'm^3').get,
+                                                                                                    water_heater_fuel: prototype_input['booster_water_heater_fuel'],
+                                                                                                    service_water_temperature: OpenStudio.convert(prototype_input['booster_water_temperature'], 'F', 'C').get,
+                                                                                                    service_water_loop: hotel_swh_loop)
+
+      # add booster water use
+      OpenstudioStandards::ServiceWaterHeating.create_water_use(model,
+                                                                name: 'Booster',
+                                                                flow_rate: OpenStudio.convert(prototype_input['booster_service_water_peak_flowrate'], 'gal/min', 'm^3/s').get,
+                                                                flow_rate_fraction_schedule: model_add_schedule(model, prototype_input['booster_service_water_flowrate_schedule']),
+                                                                water_use_temperature: OpenStudio.convert(prototype_input['booster_water_use_temperature'], 'F', 'C').get,
+                                                                service_water_loop: swh_booster_loop)
     end
 
     # for tall and super tall buildings, there is laundry only if hotel has more than 1 floors
     # hotel_bot has laundry, if only one floor, doesn't have hotel_bot
     if additional_params[:num_of_floor_hotel].to_i > 1
       # Add the laundry service water heating loop
-      laundry_swh_loop = model_add_swh_loop(model,
-                                            'Laundry Service Water Loop',
-                                            nil,
-                                            OpenStudio.convert(prototype_input['laundry_service_water_temperature'], 'F', 'C').get,
-                                            prototype_input['laundry_service_water_pump_head'].to_f,
-                                            prototype_input['laundry_service_water_pump_motor_efficiency'],
-                                            OpenStudio.convert(prototype_input['laundry_water_heater_capacity'], 'Btu/hr', 'W').get,
-                                            OpenStudio.convert(prototype_input['laundry_water_heater_volume'], 'gal', 'm^3').get,
-                                            prototype_input['laundry_water_heater_fuel'],
-                                            OpenStudio.convert(prototype_input['laundry_service_water_parasitic_fuel_consumption_rate'], 'Btu/hr', 'W').get)
-
-      # Attach the end uses if specified in prototype inputs
-      model_add_swh_end_uses(model,
-                             'Laundry',
-                             laundry_swh_loop,
-                             OpenStudio.convert(prototype_input['laundry_service_water_peak_flowrate'], 'gal/min', 'm^3/s').get,
-                             prototype_input['laundry_service_water_flowrate_schedule'],
-                             OpenStudio.convert(prototype_input['laundry_water_use_temperature'], 'F', 'C').get,
-                             nil)
+      laundry_swh_loop = OpenstudioStandards::ServiceWaterHeating.create_service_water_heating_loop(model,
+                                                                                                    system_name: 'Laundry Service Water Loop',
+                                                                                                    service_water_temperature: OpenStudio.convert(prototype_input['laundry_service_water_temperature'], 'F', 'C').get,
+                                                                                                    service_water_pump_head: prototype_input['laundry_service_water_pump_head'].to_f,
+                                                                                                    service_water_pump_motor_efficiency: prototype_input['laundry_service_water_pump_motor_efficiency'],
+                                                                                                    water_heater_capacity: OpenStudio.convert(prototype_input['laundry_water_heater_capacity'], 'Btu/hr', 'W').get,
+                                                                                                    water_heater_volume: OpenStudio.convert(prototype_input['laundry_water_heater_volume'], 'gal', 'm^3').get,
+                                                                                                    water_heater_fuel: prototype_input['laundry_water_heater_fuel'],
+                                                                                                    on_cycle_parasitic_fuel_consumption_rate: OpenStudio.convert(prototype_input['laundry_service_water_parasitic_fuel_consumption_rate'], 'Btu/hr', 'W').get,
+                                                                                                    off_cycle_parasitic_fuel_consumption_rate: OpenStudio.convert(prototype_input['laundry_service_water_parasitic_fuel_consumption_rate'], 'Btu/hr', 'W').get)
+
+      # add water use
+      OpenstudioStandards::ServiceWaterHeating.create_water_use(model,
+                                                                name: 'Laundry',
+                                                                flow_rate: OpenStudio.convert(prototype_input['laundry_service_water_peak_flowrate'], 'gal/min', 'm^3/s').get,
+                                                                flow_rate_fraction_schedule: model_add_schedule(model, prototype_input['laundry_service_water_flowrate_schedule']),
+                                                                water_use_temperature: OpenStudio.convert(prototype_input['laundry_water_use_temperature'], 'F', 'C').get,
+                                                                service_water_loop: laundry_swh_loop)
     end
     return true
   end

data/lib/openstudio-standards/prototypes/common/objects/Prototype.CentralAirSourceHeatPump.rb

@@ -27,7 +27,7 @@ class Standard
     end
 
     # change equipment name for EMS validity
-    plant_comp.setName(name.gsub(/[ +-.]/, '_'))
+    plant_comp.setName(ems_friendly_name(name))
 
     # set plant component properties
     plant_comp.setPlantLoadingMode('MeetsLoadWithNominalCapacityHiOutLimit')

data/lib/openstudio-standards/prototypes/common/objects/Prototype.hvac_systems.rb

@@ -296,6 +296,10 @@ class Standard
         # Change the chilled water loop to have a two-way common pipes
         chilled_water_loop.setCommonPipeSimulation('CommonPipe')
       elsif pri_sec_config == 'heat_exchanger'
+        # Check number of chillers
+        if num_chillers > 3
+          OpenStudio.logFree(OpenStudio::Error, 'openstudio.standards.PlantLoop', "EMS Code for multiple chiller pump has not been written for greater than 3 chillers. This has #{num_chillers} chillers")
+        end
         # NOTE: PRECONDITIONING for `const_pri_var_sec` pump type is only applicable for PRM routine and only applies to System Type 7 and System Type 8
         # See: model_add_prm_baseline_system under Model object.
         # In this scenario, we will need to create a primary and secondary configuration:
@@ -309,10 +313,15 @@ class Standard
         secondary_chilled_water_loop.setName(secondary_loop_name)
         chw_sizing_control(model, secondary_chilled_water_loop, dsgn_sup_wtr_temp, dsgn_sup_wtr_temp_delt)
         chilled_water_loop.additionalProperties.setFeature('is_primary_loop', true)
+        chilled_water_loop.additionalProperties.setFeature('secondary_loop_name', secondary_chilled_water_loop.name.to_s)
         secondary_chilled_water_loop.additionalProperties.setFeature('is_secondary_loop', true)
-        # primary chilled water pump
+        # primary chilled water pumps are added when adding chillers
         # Add Constant pump, in plant loop, the number of chiller adjustment will assign pump to each chiller
-        pri_chw_pump = OpenStudio::Model::PumpConstantSpeed.new(model)
+        # pri_chw_pump = OpenStudio::Model::PumpConstantSpeed.new(model)
+        pri_chw_pump = OpenStudio::Model::PumpVariableSpeed.new(model)
+        pump_variable_speed_set_control_type(pri_chw_pump, control_type = 'Riding Curve')
+        # This pump name is important for function add_ems_for_multiple_chiller_pumps_w_secondary_plant. If you update
+        # it here, you must update the logic there to account for this
         pri_chw_pump.setName("#{chilled_water_loop.name} Primary Pump")
         # Will need to adjust the pump power after a sizing run
         pri_chw_pump.setRatedPumpHead(OpenStudio.convert(15.0, 'ftH_{2}O', 'Pa').get / num_chillers)
@@ -375,8 +384,23 @@ class Standard
       dist_clg.autosizeNominalCapacity
       chilled_water_loop.addSupplyBranchForComponent(dist_clg)
     else
+
+      # use default efficiency from 90.1-2019
+      # 1.188 kw/ton for a 150 ton AirCooled chiller
+      # 0.66 kw/ton for a 150 ton Water Cooled positive displacement chiller
+      case chiller_cooling_type
+      when 'AirCooled'
+        default_cop = kw_per_ton_to_cop(1.188)
+      when 'WaterCooled'
+        default_cop = kw_per_ton_to_cop(0.66)
+      else
+        default_cop = kw_per_ton_to_cop(0.66)
+      end
+
       # make the correct type of chiller based these properties
       chiller_sizing_factor = (1.0 / num_chillers).round(2)
+
+      # Create chillers and set plant operation scheme
       num_chillers.times do |i|
         chiller = OpenStudio::Model::ChillerElectricEIR.new(model)
         chiller.setName("#{template} #{chiller_cooling_type} #{chiller_condenser_type} #{chiller_compressor_type} Chiller #{i}")
@@ -391,18 +415,6 @@ class Standard
         chiller.setMinimumUnloadingRatio(0.25)
         chiller.setChillerFlowMode('ConstantFlow')
         chiller.setSizingFactor(chiller_sizing_factor)
-
-        # use default efficiency from 90.1-2019
-        # 1.188 kw/ton for a 150 ton AirCooled chiller
-        # 0.66 kw/ton for a 150 ton Water Cooled positive displacement chiller
-        case chiller_cooling_type
-        when 'AirCooled'
-          default_cop = kw_per_ton_to_cop(1.188)
-        when 'WaterCooled'
-          default_cop = kw_per_ton_to_cop(0.66)
-        else
-          default_cop = kw_per_ton_to_cop(0.66)
-        end
         chiller.setReferenceCOP(default_cop)
 
         # connect the chiller to the condenser loop if one was supplied
@@ -668,11 +680,10 @@ class Standard
                   summer_oat_wbs_f << OpenStudio.convert(summer_oat_wb_c, 'C', 'F').get
                 else
                   if dd.wetBulbOrDewPointAtMaximumDryBulb.is_initialized
-                    summer_oat_wb_c = dd.wetBulbOrDewPointAtMaximumDryBulb
+                    summer_oat_wb_c = dd.wetBulbOrDewPointAtMaximumDryBulb.get
                     summer_oat_wbs_f << OpenStudio.convert(summer_oat_wb_c, 'C', 'F').get
                   end
                 end
-
               end
             end
           end
@@ -1020,22 +1031,25 @@ class Standard
     loop_stpt_manager.setName("#{ground_hx_loop.name} Supply Outlet Setpoint")
     loop_stpt_manager.addToNode(ground_hx_loop.supplyOutletNode)
 
+    # edit name to be EMS friendly
+    ground_hx_ems_name = ems_friendly_name(ground_hx.name)
+
     # sensor to read supply inlet temperature
     inlet_temp_sensor = OpenStudio::Model::EnergyManagementSystemSensor.new(model,
                                                                             'System Node Temperature')
-    inlet_temp_sensor.setName("#{ground_hx.name.to_s.gsub(/[ +-.]/, '_')} Inlet Temp Sensor")
+    inlet_temp_sensor.setName("#{ground_hx_ems_name} Inlet Temp Sensor")
     inlet_temp_sensor.setKeyName(ground_hx_loop.supplyInletNode.handle.to_s)
 
     # actuator to set supply outlet temperature
     outlet_temp_actuator = OpenStudio::Model::EnergyManagementSystemActuator.new(hx_temp_sch,
                                                                                  'Schedule:Constant',
                                                                                  'Schedule Value')
-    outlet_temp_actuator.setName("#{ground_hx.name} Outlet Temp Actuator")
+    outlet_temp_actuator.setName("#{ground_hx_ems_name} Outlet Temp Actuator")
 
     # program to control outlet temperature
     # adjusts delta-t based on calculation of slope and intercept from control temperatures
     program = OpenStudio::Model::EnergyManagementSystemProgram.new(model)
-    program.setName("#{ground_hx.name.to_s.gsub(/[ +-.]/, '_')} Temperature Control")
+    program.setName("#{ground_hx_ems_name} Temperature Control")
     program_body = <<-EMS
       SET Tin = #{inlet_temp_sensor.handle}
       SET Tout = #{slope_c_per_c.round(2)} * Tin + #{intercept_c.round(1)}
@@ -1045,7 +1059,7 @@ class Standard
 
     # program calling manager
     pcm = OpenStudio::Model::EnergyManagementSystemProgramCallingManager.new(model)
-    pcm.setName("#{program.name.to_s.gsub(/[ +-.]/, '_')} Calling Manager")
+    pcm.setName("#{program.name} Calling Manager")
     pcm.setCallingPoint('InsideHVACSystemIterationLoop')
     pcm.addProgram(program)
 
@@ -4451,20 +4465,20 @@ class Standard
       # Create a sensor to read the zone load
       zn_load_sensor = OpenStudio::Model::EnergyManagementSystemSensor.new(model,
                                                                            'Zone Predicted Sensible Load to Cooling Setpoint Heat Transfer Rate')
-      zn_load_sensor.setName("#{zone_name_clean.to_s.gsub(/[ +-.]/, '_')} Clg Load Sensor")
+      zn_load_sensor.setName("#{ems_friendly_name(zone_name_clean)} Clg Load Sensor")
       zn_load_sensor.setKeyName(zone.handle.to_s)
 
       # Create an actuator to set the airloop availability
       air_loop_avail_actuator = OpenStudio::Model::EnergyManagementSystemActuator.new(air_loop_avail_sch,
                                                                                       'Schedule:Constant',
                                                                                       'Schedule Value')
-      air_loop_avail_actuator.setName("#{air_loop.name.to_s.gsub(/[ +-.]/, '_')} Availability Actuator")
+      air_loop_avail_actuator.setName("#{ems_friendly_name(air_loop.name)} Availability Actuator")
 
       # Create a program to turn on Evap Cooler if
       # there is a cooling load in the target zone.
       # Load < 0.0 is a cooling load.
       avail_program = OpenStudio::Model::EnergyManagementSystemProgram.new(model)
-      avail_program.setName("#{air_loop.name.to_s.gsub(/[ +-.]/, '_')} Availability Control")
+      avail_program.setName("#{ems_friendly_name(air_loop.name)} Availability Control")
       avail_program_body = <<-EMS
         IF #{zn_load_sensor.handle} < 0.0
           SET #{air_loop_avail_actuator.handle} = 1
@@ -4477,10 +4491,16 @@ class Standard
       programs << avail_program
 
       # Direct Evap Cooler
-      # @todo better assumptions for evap cooler performance and fan pressure rise
+      # @todo better assumptions for fan pressure rise
       evap = OpenStudio::Model::EvaporativeCoolerDirectResearchSpecial.new(model, model.alwaysOnDiscreteSchedule)
       evap.setName("#{zone.name} Evap Media")
+      # assume 90% design effectiveness from https://basc.pnnl.gov/resource-guides/evaporative-cooling-systems#edit-group-description
+      evap.setCoolerDesignEffectiveness(0.90)
       evap.autosizePrimaryAirDesignFlowRate
+      evap.autosizeRecirculatingWaterPumpPowerConsumption
+      # use suggested E+ default values of 90.0 W-s/m^3 for pump sizing factor and 3.0 for blowdown concentration
+      evap.setWaterPumpPowerSizingFactor(90.0)
+      evap.setBlowdownConcentrationRatio(3.0)
       evap.addToNode(air_loop.supplyInletNode)
 
       # Fan (cycling), must be inside unitary system to cycle on airloop

data/lib/openstudio-standards/prototypes/common/objects/Prototype.refrigeration.rb

@@ -612,11 +612,11 @@ class Standard
 
         # Add defrost and dripdown schedules
         defrost_sch = OpenStudio::Model::ScheduleRuleset.new(model)
-        defrost_sch.setName('Refrigeration Defrost Schedule')
-        defrost_sch.defaultDaySchedule.setName("Refrigeration Defrost Schedule Default - #{case_type}")
+        defrost_sch.setName("#{ref_case.name} Defrost")
+        defrost_sch.defaultDaySchedule.setName("#{ref_case.name} Defrost Default")
         dripdown_sch = OpenStudio::Model::ScheduleRuleset.new(model)
-        dripdown_sch.setName('Refrigeration Dripdown Schedule')
-        dripdown_sch.defaultDaySchedule.setName("Refrigeration Dripdown Schedule Default - #{case_type}")
+        dripdown_sch.setName("#{ref_case.name} Dripdown")
+        dripdown_sch.defaultDaySchedule.setName("#{ref_case.name} Dripdown Default")
 
         # Stagger the defrosts for cases by 1 hr
         interval_defrost = (24 / numb_defrosts_per_day).floor # Hour interval between each defrost period
@@ -630,9 +630,9 @@ class Standard
         (1..numb_defrosts_per_day).each do |defrost_of_day|
           def_start_hr = first_def_start_hr + ((1 - defrost_of_day) * interval_defrost)
           defrost_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, def_start_hr, 0, 0), 0)
-          defrost_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, def_start_hr, minutes_defrost.to_int, 0), 0)
+          defrost_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, def_start_hr, minutes_defrost.to_int, 0), 1)
           dripdown_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, def_start_hr, 0, 0), 0) # Dripdown is synced with defrost
-          dripdown_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, def_start_hr, minutes_dripdown.to_int, 0), 0)
+          dripdown_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, def_start_hr, minutes_dripdown.to_int, 0), 1)
         end
         defrost_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, 24, 0, 0), 0)
         dripdown_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, 24, 0, 0), 0)
@@ -698,11 +698,11 @@ class Standard
 
         # Add defrost and dripdown schedules
         defrost_sch_walkin = OpenStudio::Model::ScheduleRuleset.new(model)
-        defrost_sch_walkin.setName('Refrigeration Defrost Schedule')
-        defrost_sch_walkin.defaultDaySchedule.setName("Refrigeration Defrost Schedule Default - #{walkin_type}")
+        defrost_sch_walkin.setName("#{ref_walkin.name} Defrost")
+        defrost_sch_walkin.defaultDaySchedule.setName("#{ref_walkin.name} Defrost Default")
         dripdown_sch_walkin = OpenStudio::Model::ScheduleRuleset.new(model)
-        dripdown_sch_walkin.setName('Refrigeration Dripdown Schedule')
-        dripdown_sch_walkin.defaultDaySchedule.setName("Refrigeration Dripdown Schedule Default - #{walkin_type}")
+        dripdown_sch_walkin.setName("#{ref_walkin.name} Dripdown")
+        dripdown_sch_walkin.defaultDaySchedule.setName("#{ref_walkin.name} Dripdown Default")
 
         # Stagger the defrosts for cases by 1 hr
         interval_defrost = (24 / numb_defrosts_per_day).floor # Hour interval between each defrost period
@@ -716,9 +716,9 @@ class Standard
         (1..numb_defrosts_per_day).each do |defrost_of_day|
           def_start_hr = first_def_start_hr + ((1 - defrost_of_day) * interval_defrost)
           defrost_sch_walkin.defaultDaySchedule.addValue(OpenStudio::Time.new(0, def_start_hr, 0, 0), 0)
-          defrost_sch_walkin.defaultDaySchedule.addValue(OpenStudio::Time.new(0, def_start_hr, minutes_defrost.to_int, 0), 0)
+          defrost_sch_walkin.defaultDaySchedule.addValue(OpenStudio::Time.new(0, def_start_hr, minutes_defrost.to_int, 0), 1)
           dripdown_sch_walkin.defaultDaySchedule.addValue(OpenStudio::Time.new(0, def_start_hr, 0, 0), 0) # Dripdown is synced with defrost
-          dripdown_sch_walkin.defaultDaySchedule.addValue(OpenStudio::Time.new(0, def_start_hr, minutes_dripdown.to_int, 0), 0)
+          dripdown_sch_walkin.defaultDaySchedule.addValue(OpenStudio::Time.new(0, def_start_hr, minutes_dripdown.to_int, 0), 1)
         end
         defrost_sch_walkin.defaultDaySchedule.addValue(OpenStudio::Time.new(0, 24, 0, 0), 0)
         dripdown_sch_walkin.defaultDaySchedule.addValue(OpenStudio::Time.new(0, 24, 0, 0), 0)
@@ -899,22 +899,22 @@ class Standard
       ########################################
       # Defrost schedule
       defrost_sch = OpenStudio::Model::ScheduleRuleset.new(model)
-      defrost_sch.setName('Refrigeration Defrost Schedule')
-      defrost_sch.defaultDaySchedule.setName('Refrigeration Defrost Schedule Default')
+      defrost_sch.setName("#{ref_case.name} Defrost")
+      defrost_sch.defaultDaySchedule.setName("#{ref_case.name} Defrost Default")
       defrost_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, i, 0, 0), 0)
-      defrost_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, i, 59, 0), 0)
+      defrost_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, i, 59, 0), 1)
       defrost_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, 24, 0, 0), 0)
       # Dripdown schedule
       dripdown_sch = OpenStudio::Model::ScheduleRuleset.new(model)
-      dripdown_sch.setName('Refrigeration Defrost Schedule')
-      dripdown_sch.defaultDaySchedule.setName('Refrigeration Defrost Schedule Default')
+      dripdown_sch.setName("#{ref_case.name} Defrost")
+      dripdown_sch.defaultDaySchedule.setName("#{ref_case.name} Defrost Default")
       dripdown_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, i, 0, 0), 0)
-      dripdown_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, i, 59, 0), 0)
+      dripdown_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, i, 59, 0), 1)
       dripdown_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, 24, 0, 0), 0)
       # Case Credit Schedule
       case_credit_sch = OpenStudio::Model::ScheduleRuleset.new(model)
-      case_credit_sch.setName('Refrigeration Case Credit Schedule')
-      case_credit_sch.defaultDaySchedule.setName('Refrigeration Case Credit Schedule Default')
+      case_credit_sch.setName("#{ref_case.name} Case Credit")
+      case_credit_sch.defaultDaySchedule.setName("#{ref_case.name} Case Credit Default")
       case_credit_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, 7, 0, 0), 0.2)
       case_credit_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, 21, 0, 0), 0.4)
       case_credit_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, 24, 0, 0), 0.2)
@@ -937,8 +937,8 @@ class Standard
         ########################################
         # Defrost schedule
         defrost_sch = OpenStudio::Model::ScheduleRuleset.new(model)
-        defrost_sch.setName('Refrigeration Defrost Schedule')
-        defrost_sch.defaultDaySchedule.setName('Refrigeration Defrost Schedule Default')
+        defrost_sch.setName("#{ref_walkin.name} Defrost")
+        defrost_sch.defaultDaySchedule.setName("#{ref_walkin.name} Defrost Default")
         defrost_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, i, 0, 0), 0)
         defrost_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, i, 59, 0), 1)
         defrost_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, i + 10, 0, 0), 0)
@@ -946,8 +946,8 @@ class Standard
         defrost_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, 24, 0, 0), 0)
         # Dripdown schedule
         dripdown_sch = OpenStudio::Model::ScheduleRuleset.new(model)
-        dripdown_sch.setName('Refrigeration Defrost Schedule')
-        dripdown_sch.defaultDaySchedule.setName('Refrigeration Defrost Schedule Default')
+        dripdown_sch.setName("#{ref_walkin.name} Defrost")
+        dripdown_sch.defaultDaySchedule.setName("#{ref_walkin.name} Defrost Default")
         dripdown_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, i, 0, 0), 0)
         dripdown_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, i, 59, 0), 1)
         dripdown_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, i + 10, 0, 0), 0)

data/lib/openstudio-standards/schedules/parametric.rb

@@ -1056,7 +1056,7 @@ module OpenstudioStandards
             remainder = days_to_fill - value[:days_used]
             day_for_rule = days_to_fill - remainder
             if remainder.size < days_to_fill.size
-              autogen_rules[profile_index] = { days_to_fill: day_for_rule, hoo_start: hoo_start, hoo_end: hoo_end}
+              autogen_rules[profile_index] = { days_to_fill: day_for_rule, hoo_start: hoo_start, hoo_end: hoo_end }
             end
             days_to_fill = remainder
           end

data/lib/openstudio-standards/service_water_heating/create_piping_losses.rb

@@ -0,0 +1,152 @@
+module OpenstudioStandards
+  # The ServiceWaterHeating module provides methods to create, modify, and get information about service water heating
+  module ServiceWaterHeating
+    # @!group Create Piping Losses
+    # Methods to add service water heating piping losses
+
+    # Adds piping losses to a service water heating Loop.
+    # Assumes the piping system use insulated 0.75 inch copper piping.
+    # For circulating systems, assume length of piping is proportional to the building floor area and number of stories.
+    # For non-circulating systems, assume that the water heaters are close to the point of use.
+    #
+    # @param model [OpenStudio::Model::Model] OpenStudio model object
+    # @param service_water_loop [OpenStudio::Model::PlantLoop] the service water heating loop
+    # @param circulating [Boolean] use true for circulating systems, false for non-circulating systems
+    # @param pipe_insulation_thickness [Double] the thickness of the pipe insulation, in m. Use 0 for no insulation
+    # @param floor_area [Double] the area of building served by the service water heating loop, in m^2
+    #   If nil, will use the total building floor area. Only used if circulating is true.
+    # @param number_of_stories [Integer] the number of stories served by the service water heating loop
+    #   If nil, will use the total building number of stories. Only used if circulating is true.
+    # @param pipe_length [Double] the length of the pipe in meters. Default is 6.1 m / 20 ft.
+    #   Only used if circulating is false.
+    # @param air_temperature [Double] the temperature of the air surrounding the piping, in C. Default is 21.1 C / 70 F.
+    # @return [Boolean] returns true if successful, false if not
+    def self.create_service_water_heating_piping_losses(model,
+                                                        service_water_loop,
+                                                        circulating: true,
+                                                        pipe_insulation_thickness: 0.0,
+                                                        floor_area: nil,
+                                                        number_of_stories: nil,
+                                                        pipe_length: 6.1,
+                                                        air_temperature: 21.1)
+
+      # Estimate pipe length
+      if circulating
+        # For circulating systems, get pipe length based on the size of the building.
+        # Formula from A.3.1 PrototypeModelEnhancements_2014_0.pdf
+
+        # get the floor area
+        floor_area = model.getBuilding.floorArea if floor_area.nil?
+        floor_area_ft2 = OpenStudio.convert(floor_area, 'm^2', 'ft^2').get
+
+        # get the number of stories
+        number_of_stories = model.getBuilding.buildingStories.size if number_of_stories.nil?
+
+        # calculate the piping length
+        pipe_length_ft = 2.0 * (Math.sqrt(floor_area_ft2 / number_of_stories) + (10.0 * (number_of_stories - 1.0)))
+        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.ServiceWaterHeating', "Pipe length #{pipe_length_ft.round}ft = 2.0 * ( (#{floor_area_ft2.round}ft2 / #{number_of_stories} stories)^0.5 + (10.0ft * (#{number_of_stories} stories - 1.0) ) )")
+      else
+        # For non-circulating systems, assume water heater is close to point of use
+
+        # get pipe length
+        pipe_length_m = pipe_length.nil? ? 6.1 : pipe_length
+
+        pipe_length_ft = OpenStudio.convert(pipe_length_m, 'm', 'ft').get
+        OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.ServiceWaterHeating', "Pipe length #{pipe_length_ft.round}ft. For non-circulating systems, assume water heater is close to point of use.")
+      end
+
+      # For systems whose water heater object represents multiple pieces
+      # of equipment, multiply the piping length by the number of pieces of equipment.
+      service_water_loop.supplyComponents('OS_WaterHeater_Mixed'.to_IddObjectType).each do |sc|
+        next unless sc.to_WaterHeaterMixed.is_initialized
+
+        water_heater = sc.to_WaterHeaterMixed.get
+
+        # get number of water heaters
+        if water_heater.additionalProperties.getFeatureAsInteger('component_quantity').is_initialized
+          comp_qty = water_heater.additionalProperties.getFeatureAsInteger('component_quantity').get
+        else
+          comp_qty = 1
+        end
+
+        # if more than 1 water heater, multiply the pipe length by the number of water heaters,
+        # unless the user has specified a pipe length
+        if comp_qty > 1 && pipe_length.nil?
+          OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.ServiceWaterHeating', "Piping length has been multiplied by #{comp_qty}X because #{water_heater.name} represents #{comp_qty} pieces of equipment.")
+          pipe_length_ft *= comp_qty
+          break
+        end
+      end
+
+      # Service water heating piping heat loss scheduled air temperature
+      air_temperature_f = OpenStudio.convert(air_temperature, 'C', 'F').get
+      swh_piping_air_temp_sch = OpenstudioStandards::Schedules.create_constant_schedule_ruleset(model,
+                                                                                                air_temperature,
+                                                                                                name: "#{service_water_loop.name} Piping Air Temp - #{air_temperature_f.round}F",
+                                                                                                schedule_type_limit: 'Temperature')
+
+      # Service water heating piping heat loss scheduled air velocity
+      swh_piping_air_velocity_m_per_s = 0.3
+      swh_piping_air_velocity_mph = OpenStudio.convert(swh_piping_air_velocity_m_per_s, 'm/s', 'mile/hr').get
+      swh_piping_air_velocity_sch = OpenstudioStandards::Schedules.create_constant_schedule_ruleset(model,
+                                                                                                    swh_piping_air_velocity_m_per_s,
+                                                                                                    name: "#{service_water_loop.name} Piping Air Velocity - #{swh_piping_air_velocity_mph.round(2)}mph")
+
+      # Material for 3/4in type L (heavy duty) copper pipe
+      copper_pipe = OpenStudio::Model::StandardOpaqueMaterial.new(model)
+      copper_pipe.setName('Copper pipe 0.75in type L')
+      copper_pipe.setRoughness('Smooth')
+      copper_pipe.setThickness(OpenStudio.convert(0.045, 'in', 'm').get)
+      copper_pipe.setThermalConductivity(386.0)
+      copper_pipe.setDensity(OpenStudio.convert(556, 'lb/ft^3', 'kg/m^3').get)
+      copper_pipe.setSpecificHeat(OpenStudio.convert(0.092, 'Btu/lb*R', 'J/kg*K').get)
+      copper_pipe.setThermalAbsorptance(0.9) # @todo find reference for property
+      copper_pipe.setSolarAbsorptance(0.7) # @todo find reference for property
+      copper_pipe.setVisibleAbsorptance(0.7) # @todo find reference for property
+
+      # Construction for pipe
+      pipe_construction = OpenStudio::Model::Construction.new(model)
+
+      # Add insulation material to insulated pipe
+      if pipe_insulation_thickness > 0
+        # Material for fiberglass insulation
+        # R-value from Owens-Corning 1/2in fiberglass pipe insulation
+        # https://www.grainger.com/product/OWENS-CORNING-1-2-Thick-40PP22
+        # but modified until simulated heat loss = 17.7 Btu/hr/ft of pipe with 140F water and 70F air
+        pipe_insulation_thickness_in = OpenStudio.convert(pipe_insulation_thickness, 'm', 'in').get
+        insulation = OpenStudio::Model::StandardOpaqueMaterial.new(model)
+        insulation.setName("Fiberglass batt #{pipe_insulation_thickness_in.round(2)}in")
+        insulation.setRoughness('Smooth')
+        insulation.setThickness(OpenStudio.convert(pipe_insulation_thickness_in, 'in', 'm').get)
+        insulation.setThermalConductivity(OpenStudio.convert(0.46, 'Btu*in/hr*ft^2*R', 'W/m*K').get)
+        insulation.setDensity(OpenStudio.convert(0.7, 'lb/ft^3', 'kg/m^3').get)
+        insulation.setSpecificHeat(OpenStudio.convert(0.2, 'Btu/lb*R', 'J/kg*K').get)
+        insulation.setThermalAbsorptance(0.9) # Irrelevant for Pipe:Indoor; no radiation model is used
+        insulation.setSolarAbsorptance(0.7) # Irrelevant for Pipe:Indoor; no radiation model is used
+        insulation.setVisibleAbsorptance(0.7) # Irrelevant for Pipe:Indoor; no radiation model is used
+
+        pipe_construction.setName("Copper pipe 0.75in type L with #{pipe_insulation_thickness_in.round(2)}in fiberglass batt")
+        pipe_construction.setLayers([insulation, copper_pipe])
+      else
+        pipe_construction.setName('Uninsulated copper pipe 0.75in type L')
+        pipe_construction.setLayers([copper_pipe])
+      end
+
+      heat_loss_pipe = OpenStudio::Model::PipeIndoor.new(model)
+      heat_loss_pipe.setName("#{service_water_loop.name} Pipe #{pipe_length_ft.round}ft")
+      heat_loss_pipe.setEnvironmentType('Schedule')
+      heat_loss_pipe.setAmbientTemperatureSchedule(swh_piping_air_temp_sch)
+      heat_loss_pipe.setAmbientAirVelocitySchedule(swh_piping_air_velocity_sch)
+      heat_loss_pipe.setConstruction(pipe_construction)
+      heat_loss_pipe.setPipeInsideDiameter(OpenStudio.convert(0.785, 'in', 'm').get)
+      heat_loss_pipe.setPipeLength(OpenStudio.convert(pipe_length_ft, 'ft', 'm').get)
+
+      heat_loss_pipe.addToNode(service_water_loop.demandInletNode)
+
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.standards.ServiceWaterHeating', "Added #{pipe_length_ft.round}ft of #{pipe_construction.name} losing heat to #{air_temperature_f.round}F air to #{service_water_loop.name}.")
+      return true
+    end
+
+    # @!endgroup Create Piping Losses
+  end
+end