openstudio-standards 0.2.12.rc4 → 0.2.12.rc5

data/lib/openstudio-standards/standards/necb/NECB2011/daylighting_control.md

@@ -0,0 +1,70 @@
+# Daylighting Sensor Controls Measure
+This measure adds daylighting sensor controls to a building's spaces where they are daylighted by sidelighting and/or toplighting based on NECB-2011. <br> Some parts of this measure used the existing measure, called "assign_ashrae_9012010_daylighting_controls", in OpenStudio's BCL with some modifications.
+
+## Description
+The workflow of this measure is as follows:
+1. Find all spaces in a building that have the fenestration types of "fixed window", "operable window", and "skylight" on exterior surfaces.
+2. Calculate "Primary Sidelighted Areas" and "Sidelighting Effective Aperture" for the spaces that have fixed and/or operable window(s), as per NECB-2011's Article 4.2.2.9. and Article 4.2.2.10. See Notes #1 and 2 below.
+3. Calculate "Daylighted Area Under Skylights" and "Skylight Effective Aperture" for the spaces that have skylight(s), as per NECB-2011's Article 4.2.2.5. and 4.2.2.7. See Notes #3 and 4 below.
+4. Exclude the daylighted spaces where the NECB-2011's required conditions are not met for either "Primary Sidelighted Areas", "Sidelighting Effective Aperture", "Daylighted Area Under Skylights", or "Skylight Effective Aperture". See Note #5 below for the NECB-2011's required conditions.
+5. However, include all daylighted office spaces larger than 25 m<sup>2</sup> even if they do not meet NECB-2011's required conditions for either "Primary Sidelighted Areas", "Sidelighting Effective Aperture", "Daylighted Area Under Skylights", or "Skylight Effective Aperture". This approach is based on NECB-2011's Article 4.2.2.2. 
+6. Create daylighting sensor(s) (one or two) for the daylighted spaces that should have daylighting sensors controls. See Note #6 below for number of sensors.
+
+##### Note #1:
+* The Primary Sidelighted Area is calculated as follows: (See NECB-2011 Figure A-4.2.2.9.)
+  * Primary Sidelighted Area’s width = window width + min(0.6 m, distance to any vertical obstruction that is 1.5 m or more in height) on each side of the window.
+  * Primary Sidelighted Area’s depth = min(window head height, perpendicular distance of any vertical obstruction that is 1.5 m or more in height from the window).
+  * Primary Sidelighted Area = its width x its depth
+  
+##### Note #2:
+* The Sidelighting Effective Aperture is calculated as follows:
+  * Sidelighting Effective Aperture = sum(glazing area of window) x area-weighted visible transmittance of glazing / Primary Sidelighted Area
+
+##### Note #3:
+* The Daylighted Area Under Skylight is calculated as follows: (See NECB-2011 Figure A-4.2.2.5.(2))
+  * Daylighted Area Under Skylight = Area of the skylight’s projection onto the floor + the horizontal distances extending from the projection in each direction to min(0.7 * ceiling height, distance to any primary daylighted area, distance to any vertical obstruction where the obstruction is farther than 70% of the distance between the top of the obstruction and the ceiling).
+
+##### Note #4:
+* The Skylight Effective Aperture is calculated as follows:
+  * Skylight Effective Aperture = 0.85 x (total glazing area of skylights) x (area-weighted VT of skylight glazing) x (WF) / Daylighted Area Under Skylight
+  * WF is the area-weighted average well factor (see NECB-2011: 4.2.2.7.).
+  
+##### Note #5:
+* Which daylighted spaces should have daylighting sensor controls as per NECB-2011:
+  * Primary Sidelighted Areas > 100 m<sup>2</sup>
+  * Sidelighting Effective Aperture > 0.1 (10%)
+  * Daylighted Area Under Skylights > 400 m<sup>2</sup>
+  * Skylight Effective Aperture > 0.006 (0.6%)
+  
+##### Note #6:
+* Energyplus allows for maximum two daylighting sensor controls in each thermal zone.
+* Considering the above limitation in EnergyPlus and NECB-2011's Article 4.2.2.2., this measure determines whether one or two daylighting sensors are needed for a daylighted space as below:
+  * If the daylighted space area <= 250 m<sup>2</sup>: put one sensor at the center of the space at the height of 0.8 m above the floor.
+  * Otherwise, divide the space into two equal parts and put one sensor at the center of each of them at the height of 0.8 m above the floor.
+
+## Approach
+This measure has some assumptions and limitations:
+1. It does not consider rooftop monitors regarding toplighting.
+2. It does not exclude overlapped daylighted areas regarding wide windows in spaces daylighted by sidelighting.
+3. It assumes that skylight(s) are in parallel to roof(s) edges.
+4. It assumes that skylight(s) are flush with ceiling(s).
+5. It assumes that skylight(s) is(are) rectangular in shape.
+6. In the calculation of extension of skylight(s)' projection onto the floor, the window head height is subtracted from the associated vertical distance of skylight projection to the exterior wall once (even if the exterior wall has multiple windows).
+7. It does not consider space types (see NECB-2011's 4.2.2.8.) regarding whether they should or should not have daylighting sensor controls.
+8. It does not consider this clause from NECB-2011: 4.2.2.4.: "enclosed space > 800 m<sup>2</sup> in buildings located above the 55˚N latitude" regarding toplighting.
+  
+## Testing Plan
+* This measure has been called in the **model_apply_standard** function after the **apply_loop_pump_power** function (in necb_2011.rb).
+  * Note that since the **apply_auto_zoning** function removes any assigned thermal zones (hence, removes daylighting sensors), 
+the **model_add_daylighting_controls** function was removed from the **apply_fdwr_srr_daylighting** function.
+* This measure was tested for two NECB 2011 archetypes: (1) full service restaurant, (2) warehouse. <br> 
+The full service restaurant archetype has sidelighting. Since none of spaces of this archetype met the NECB-2011's requirements to have daylighting sensor control(s), daylighting sensor controls were created for none of the spaces of this archetype. <br>
+The warehouse archetype has both sidelighting and skylights. One space out of three daylighted spaces met the NECB-2011's requirements to have daylighting sensor control(s). One of the two other daylighted spaces is an office space larger than 25 m<sup>2</sup>; hence, a daylighting sensor control was created for this space although it did not meet the NECB-2011's requirements.
+![Warehouse](/home/osdev/openstudio-standards/lib/openstudio-standards/standards/necb/NECB2011/Warehouse_daylightingSensor.png)
+
+## Files Added/Modified
+ * Files have been modified:
+   * **necb_2011.rb**
+ * Files have been added:
+   * **daylighting_control.md**
+   * **Warehouse_daylightingSensor.png**

data/lib/openstudio-standards/standards/necb/NECB2011/demand_controlled_ventilation.md

@@ -0,0 +1,46 @@
+# Demand Controlled Ventilation Measure
+This measure enables or disables demand controlled ventilation (DCV) in air-based HVAC systems of a model. 
+Enabling DCV can be based on occupancy or CO<sub>2</sub> concentration in spaces.
+<br> Some parts of this measure used the existing measure, called "enable_demand_controlled_ventilation", in OpenStudio's BCL with some modifications. 
+
+# Description
+The workflow of this measure is as follows:
+1. Create indoor CO<sub>2</sub> availability and setpoint and outdoor CO<sub>2</sub> schedules. 
+(This is required for CO<sub>2</sub>-based DCV)
+2. Set outdoor airflow rate per person for each zone. (This is required for occupancy-based DCV)
+3. Set a contaminant controller in each zone to control the zone to the specified CO<sub>2</sub> 
+level based on the indoor CO<sub>2</sub> availability and setpoint schedules.
+(This is required for CO<sub>2</sub>-based DCV)
+4. Loop through all air loops to:
+    1. Find the outdoor air system for each air loop.
+    2. Get the outdoor air controller from the outdoor air system.
+    3. Get the mechanical ventilation controller from the outdoor air controller.
+    4. Set DCV of the the mechanical ventilation controller to Yes or No based on whether DCV is enabled or not.
+    5. Set the system outdoor air method based on the DCV type (i.e. occupancy/CO<sub>2</sub>-based DCV)
+
+# Approach
+This measure has defined simple schedules for indoor CO<sub>2</sub> availability and setpoint and outdoor CO<sub>2</sub> schedules.
+However, more detailed schedules can be defined in the future.
+
+# Testing Plan
+* This measure has been called in the **apply_systems** function (in autozone.rb).
+* This measure was tested for NECB 2011 full service restaurant archetype.
+Note that since setting the outdoor airflow rate per person is upon another BTAP task, 
+the outdoor airflow rate per person values were set manually for each space that was served by an air-based HVAC system using OpenStudio.
+
+# Waiting On
+Two parts of this measure are upon other BTAP tasks as follows:
+1. Regarding setting the outdoor airflow rate per person, the associated values for each space type should be entered for 
+"ventilation_per_person" in "lib/openstudio-standards/standards/necb/NECB2011/data/space_types.json"
+    * Note #1: NBC-2010, Division B, Article 6.2.2.1. refers to ANSI/ASHRAE 62 “Ventilation for Acceptable Indoor Air Quality” for the required ventilation, 
+except for storage garages.
+    * Note #2: Regaridng ventilation of storage garages, see NBC-2010, Division B, Article 6.2.2.3. which says "provide, during operating hours, a continuous supply of outdoor air at a rate of not less than 3.9 L/s for each square metre of floor area."
+2. This measure created a function called **get_any_number_ppm** as a ScheduleTypeLimits to input CO<sub>2</sub> concentration levels.
+This function can be added to "btap/schedules.rb > module StandardScheduleTypeLimits".
+
+# Files Added/Modified
+* Files have been modified:
+  * **necb_2011.rb**
+  * **autozone.rb**
+* Files have been added: 
+  * **demand_controlled_ventilation.md**

data/lib/openstudio-standards/standards/necb/NECB2011/hvac_system_1_multi_speed.rb

@@ -1,13 +1,47 @@
 class NECB2011
-# sys1_unitary_ac_baseboard_heating
 
+  # At this point the only way to implement multi-stage cooling and heating in OS is through the use
+  # of object "AirLoopHVACUnitaryHeatPumpAirToAirMultiSpeed". This component uses as an argument a control
+  # zone and then it responds to a call for heating or cooling for that control zone. This aspect of this
+  # component makes it incompatible with how a system_1 make up air unit works where a constant supply air
+  # temperature is delivered to the spaces. It is therefore not recommended to use this method and to use
+  # the single speed implementation of systems_1.
   def add_sys1_unitary_ac_baseboard_heating_multi_speed(model:,
                                                         zones:,
-                                                        mau:,
+                                                        mau_type:,
                                                         mau_heating_coil_type:,
                                                         baseboard_type:,
                                                         hw_loop:)
-    raise("System 1 multi is not working right now. Please do not invoke!!!!")
+
+    # Keep all data and assumptions for both systems on the top here for easy reference.
+    system_data = Hash.new
+    system_data[:name] = 'Sys_1_Make-up air unit'
+    system_data[:PreheatDesignTemperature] = 7.0
+    system_data[:PreheatDesignHumidityRatio] = 0.008
+    system_data[:PrecoolDesignTemperature] = 13.0
+    system_data[:PrecoolDesignHumidityRatio] = 0.008
+    system_data[:SizingOption] = 'NonCoincident'
+    system_data[:CoolingDesignAirFlowMethod] = 'DesignDay'
+    system_data[:CoolingDesignAirFlowRate] = 0.0
+    system_data[:HeatingDesignAirFlowMethod] = 'DesignDay'
+    system_data[:HeatingDesignAirFlowRate] = 0.0
+    system_data[:SystemOutdoorAirMethod] = 'ZoneSum'
+    system_data[:CentralCoolingDesignSupplyAirHumidityRatio] = 0.0085
+    system_data[:CentralHeatingDesignSupplyAirHumidityRatio] = 0.0080
+    system_data[:CentralCoolingDesignSupplyAirTemperature] = 13.0
+    system_data[:CentralHeatingDesignSupplyAirTemperature] = 43.0
+    system_data[:AllOutdoorAirinCooling] = true
+    system_data[:AllOutdoorAirinHeating] = true
+    system_data[:TypeofLoadtoSizeOn] = 'VentilationRequirement'
+    system_data[:MinimumSystemAirFlowRatio] = 1.0
+    system_data[:MinimumOutdoorDryBulbTemperatureforCompressorOperation] = -10.0
+    #Zone data
+    system_data[:system_supply_air_temperature] = 20.0
+    system_data[:ZoneCoolingDesignSupplyAirTemperature] = 13.0
+    system_data[:ZoneHeatingDesignSupplyAirTemperature] = 43.0 #Examine to see if this is a code or assumption. 13.1 maybe need to check
+    system_data[:ZoneCoolingSizingFactor] = 1.1
+    system_data[:ZoneHeatingSizingFactor] = 1.3
+
     # System Type 1: PTAC with no heating (unitary AC)
     # Zone baseboards, electric or hot water depending on argument baseboard_type
     # baseboard_type choices are "Hot Water" or "Electric"
@@ -30,128 +64,48 @@ class NECB2011
     # define always off schedule for ptac heating coil
     always_off = BTAP::Resources::Schedules::StandardSchedules::ON_OFF.always_off(model)
 
-    # TODO: Heating and cooling temperature set point schedules are set somewhere else
-    # TODO: For now fetch the schedules and use them in setting up the heat pump system
-    # TODO: Later on these schedules need to be passed on to this method
-    htg_temp_sch = nil
-    clg_temp_sch = nil
-    zones.each do |izone|
-      if izone.thermostat.is_initialized
-        zone_thermostat = izone.thermostat.get
-        if zone_thermostat.to_ThermostatSetpointDualSetpoint.is_initialized
-          dual_thermostat = zone_thermostat.to_ThermostatSetpointDualSetpoint.get
-          htg_temp_sch = dual_thermostat.heatingSetpointTemperatureSchedule.get
-          clg_temp_sch = dual_thermostat.coolingSetpointTemperatureSchedule.get
-          break
-        end
-      end
-    end
-
     # Create MAU
     # TO DO: MAU sizing, characteristics (fan operation schedules, temperature setpoints, outdoor air, etc)
 
-    if mau == true
-
-      staged_thermostat = OpenStudio::Model::ZoneControlThermostatStagedDualSetpoint.new(model)
-      staged_thermostat.setHeatingTemperatureSetpointSchedule(htg_temp_sch)
-      staged_thermostat.setNumberofHeatingStages(4)
-      staged_thermostat.setCoolingTemperatureSetpointBaseSchedule(clg_temp_sch)
-      staged_thermostat.setNumberofCoolingStages(4)
-
-      mau_air_loop = OpenStudio::Model::AirLoopHVAC.new(model)
-
-      mau_air_loop.setName('Sys_1_Make-up air unit')
-
-      # When an air_loop is constructed, its constructor creates a sizing:system object
-      # the default sizing:system constructor makes a system:sizing object
-      # appropriate for a multizone VAV system
-      # this systems is a constant volume system with no VAV terminals,
-      # and therfore needs different default settings
-      air_loop_sizing = mau_air_loop.sizingSystem # TODO units
-      air_loop_sizing.setTypeofLoadtoSizeOn('Sensible')
-      air_loop_sizing.autosizeDesignOutdoorAirFlowRate
-      if model.version < OpenStudio::VersionString.new('2.7.0')
-        air_loop_sizing.setMinimumSystemAirFlowRatio(1.0)
-      else
-        air_loop_sizing.setCentralHeatingMaximumSystemAirFlowRatio(1.0)
-      end
-      air_loop_sizing.setPreheatDesignTemperature(7.0)
-      air_loop_sizing.setPreheatDesignHumidityRatio(0.008)
-      air_loop_sizing.setPrecoolDesignTemperature(12.8)
-      air_loop_sizing.setPrecoolDesignHumidityRatio(0.008)
-      air_loop_sizing.setCentralCoolingDesignSupplyAirTemperature(13.0)
-      air_loop_sizing.setCentralHeatingDesignSupplyAirTemperature(43.0)
-      air_loop_sizing.setSizingOption('NonCoincident')
-      air_loop_sizing.setAllOutdoorAirinCooling(false)
-      air_loop_sizing.setAllOutdoorAirinHeating(false)
-      air_loop_sizing.setCentralCoolingDesignSupplyAirHumidityRatio(0.0085)
-      air_loop_sizing.setCentralHeatingDesignSupplyAirHumidityRatio(0.0080)
-      air_loop_sizing.setCoolingDesignAirFlowMethod('DesignDay')
-      air_loop_sizing.setCoolingDesignAirFlowRate(0.0)
-      air_loop_sizing.setHeatingDesignAirFlowMethod('DesignDay')
-      air_loop_sizing.setHeatingDesignAirFlowRate(0.0)
-      air_loop_sizing.setSystemOutdoorAirMethod('ZoneSum')
+    if mau_type == true
 
+      mau_air_loop = common_air_loop(model: model, system_data: system_data)
       mau_fan = OpenStudio::Model::FanConstantVolume.new(model, always_on)
 
-      # Multi-stage gas heating coil
-      if mau_heating_coil_type == 'Electric' || mau_heating_coil_type == 'Hot Water'
-
-        mau_htg_coil = OpenStudio::Model::CoilHeatingGasMultiStage.new(model)
-        mau_htg_stage_1 = OpenStudio::Model::CoilHeatingGasMultiStageStageData.new(model)
-        mau_htg_stage_2 = OpenStudio::Model::CoilHeatingGasMultiStageStageData.new(model)
-        mau_htg_stage_3 = OpenStudio::Model::CoilHeatingGasMultiStageStageData.new(model)
-        mau_htg_stage_4 = OpenStudio::Model::CoilHeatingGasMultiStageStageData.new(model)
-
-        if mau_heating_coil_type == 'Electric'
-
-          mau_supplemental_htg_coil = OpenStudio::Model::CoilHeatingElectric.new(model, always_on)
-
-        elsif mau_heating_coil_type == 'Hot Water'
-
-          mau_supplemental_htg_coil = OpenStudio::Model::CoilHeatingWater.new(model, always_on)
-          hw_loop.addDemandBranchForComponent(mau_supplemental_htg_coil)
-
-        end
-
-        mau_htg_stage_1.setNominalCapacity(0.1)
-        mau_htg_stage_2.setNominalCapacity(0.2)
-        mau_htg_stage_3.setNominalCapacity(0.3)
-        mau_htg_stage_4.setNominalCapacity(0.4)
-
-      end
-
-      # Add stages to heating coil
-      mau_htg_coil.addStage(mau_htg_stage_1)
-      mau_htg_coil.addStage(mau_htg_stage_2)
-      mau_htg_coil.addStage(mau_htg_stage_3)
-      mau_htg_coil.addStage(mau_htg_stage_4)
-
-      # TODO: other fuel-fired heating coil types? (not available in OpenStudio/E+ - may need to play with efficiency to mimic other fuel types)
-
-      # Set up DX cooling coil
+      # Setup heating and cooling coils
       mau_clg_coil = OpenStudio::Model::CoilCoolingDXMultiSpeed.new(model)
       mau_clg_coil.setFuelType('Electricity')
       mau_clg_stage_1 = OpenStudio::Model::CoilCoolingDXMultiSpeedStageData.new(model)
       mau_clg_stage_2 = OpenStudio::Model::CoilCoolingDXMultiSpeedStageData.new(model)
-      mau_clg_stage_3 = OpenStudio::Model::CoilCoolingDXMultiSpeedStageData.new(model)
-      mau_clg_stage_4 = OpenStudio::Model::CoilCoolingDXMultiSpeedStageData.new(model)
       mau_clg_coil.addStage(mau_clg_stage_1)
       mau_clg_coil.addStage(mau_clg_stage_2)
-      mau_clg_coil.addStage(mau_clg_stage_3)
-      mau_clg_coil.addStage(mau_clg_stage_4)
+      mau_clg_coil.setApplyPartLoadFractiontoSpeedsGreaterthan1(false)
+      mau_htg_coil = OpenStudio::Model::CoilHeatingGasMultiStage.new(model)
+      mau_htg_stage_1 = OpenStudio::Model::CoilHeatingGasMultiStageStageData.new(model)
+      mau_htg_coil.addStage(mau_htg_stage_1)
+      mau_htg_stage_1.setNominalCapacity(0.001)
+      if mau_heating_coil_type == 'Electric'
+        mau_supplemental_htg_coil = OpenStudio::Model::CoilHeatingElectric.new(model, always_on)
+      elsif mau_heating_coil_type == 'Hot Water'
+        mau_supplemental_htg_coil = OpenStudio::Model::CoilHeatingWater.new(model, always_on)
+        hw_loop.addDemandBranchForComponent(mau_supplemental_htg_coil)
+      else
+        raise("#{mau_heating_coil_type} is not a valid heating coil type.)")
+      end
+
+      # TODO: other fuel-fired heating coil types? (not available in OpenStudio/E+ - may need to play with efficiency to mimic other fuel types)
 
       air_to_air_heatpump = OpenStudio::Model::AirLoopHVACUnitaryHeatPumpAirToAirMultiSpeed.new(model, mau_fan, mau_htg_coil, mau_clg_coil, mau_supplemental_htg_coil)
-      #              air_to_air_heatpump.setName("#{zone.name} ASHP")
-      air_to_air_heatpump.setControllingZoneorThermostatLocation(zones[1])
+      air_to_air_heatpump.setName("#{zones[0].name} ASHP")
+      air_to_air_heatpump.setMinimumOutdoorDryBulbTemperatureforCompressorOperation(system_data[:MinimumOutdoorDryBulbTemperatureforCompressorOperation])
+      air_to_air_heatpump.setControllingZoneorThermostatLocation(zones[0])
       air_to_air_heatpump.setSupplyAirFanOperatingModeSchedule(always_on)
-      air_to_air_heatpump.setNumberofSpeedsforHeating(4)
-      air_to_air_heatpump.setNumberofSpeedsforCooling(4)
+      air_to_air_heatpump.setNumberofSpeedsforHeating(1)
+      air_to_air_heatpump.setNumberofSpeedsforCooling(2)
 
       # oa_controller
       oa_controller = OpenStudio::Model::ControllerOutdoorAir.new(model)
       oa_controller.autosizeMinimumOutdoorAirFlowRate
-      # oa_controller.setEconomizerControlType("DifferentialEnthalpy")
 
       # oa_system
       oa_system = OpenStudio::Model::AirLoopHVACOutdoorAirSystem.new(model, oa_controller)
@@ -162,6 +116,14 @@ class NECB2011
       air_to_air_heatpump.addToNode(supply_inlet_node)
       oa_system.addToNode(supply_inlet_node)
 
+      # Add a setpoint manager to control the supply air temperature
+      sat_sch = OpenStudio::Model::ScheduleRuleset.new(model)
+      sat_sch.setName('Makeup-Air Unit Supply Air Temp')
+      sat_sch.defaultDaySchedule.setName('Makeup Air Unit Supply Air Temp Default')
+      sat_sch.defaultDaySchedule.addValue(OpenStudio::Time.new(0, 24, 0, 0), system_data[:system_supply_air_temperature])
+      setpoint_mgr = OpenStudio::Model::SetpointManagerScheduled.new(model, sat_sch)
+      setpoint_mgr.addToNode(mau_air_loop.supplyOutletNode)
+
     end # Create MAU
 
 
@@ -183,7 +145,7 @@ class NECB2011
       add_zone_baseboards(baseboard_type: baseboard_type, hw_loop: hw_loop, model: model, zone: zone)
 
       #  # Create a diffuser and attach the zone/diffuser pair to the MAU air loop, if applicable
-      if mau == true
+      if mau_type == true
 
         diffuser = OpenStudio::Model::AirTerminalSingleDuctUncontrolled.new(model, always_on)
         mau_air_loop.addBranchForZone(zone, diffuser.to_StraightComponent)

data/lib/openstudio-standards/standards/necb/NECB2011/hvac_system_1_single_speed.rb

@@ -6,7 +6,30 @@ class NECB2011
                                             mau_heating_coil_type:,
                                             baseboard_type:,
                                             hw_loop:,
-                                            multi_speed: false)
+                                            multispeed: false)
+    if multispeed
+      add_sys1_unitary_ac_baseboard_heating_multi_speed(model: model,
+                                                        zones: zones,
+                                                        mau_type: mau_type,
+                                                        mau_heating_coil_type: mau_heating_coil_type,
+                                                        baseboard_type: baseboard_type,
+                                                        hw_loop: hw_loop)
+    else
+      add_sys1_unitary_ac_baseboard_heating_single_speed(model: model,
+                                                         zones: zones,
+                                                         mau_type: mau_type,
+                                                         mau_heating_coil_type: mau_heating_coil_type,
+                                                         baseboard_type: baseboard_type,
+                                                         hw_loop: hw_loop)
+    end
+  end
+
+  def add_sys1_unitary_ac_baseboard_heating_single_speed(model:,
+                                            zones:,
+                                            mau_type:,
+                                            mau_heating_coil_type:,
+                                            baseboard_type:,
+                                            hw_loop:)
 
     # Keep all data and assumptions for both systems on the top here for easy reference.
     system_data = Hash.new

data/lib/openstudio-standards/standards/necb/NECB2011/hvac_system_3_and_8_multi_speed.rb

@@ -1,11 +1,83 @@
 class NECB2011
-  def add_sys3and8_single_zone_packaged_rooftop_unit_with_baseboard_heating_multi_speed(model,
-                                                                                        zones,
-                                                                                        boiler_fueltype,
-                                                                                        heating_coil_type,
-                                                                                        baseboard_type,
-                                                                                        hw_loop)
-    raise("System 3 multi is not working right now. Please do not invoke!!!!!")
+
+  # Some tests still require a simple way to set up a system without sizing.. so we are keeping the auto_zoner flag for this  method.
+
+  def add_sys3and8_single_zone_packaged_rooftop_unit_with_baseboard_heating_multi_speed(model:,
+                                                                                        zones:,
+                                                                                        heating_coil_type:,
+                                                                                        baseboard_type:,
+                                                                                        hw_loop:,
+                                                                                        new_auto_zoner: true)
+    system_data = Hash.new
+    system_data[:name] = 'Sys_3_PSZ'
+    system_data[:CentralCoolingDesignSupplyAirTemperature] = 13.0
+    system_data[:CentralHeatingDesignSupplyAirTemperature] = 43.0
+    system_data[:AllOutdoorAirinCooling] = false
+    system_data[:AllOutdoorAirinHeating] = false
+    system_data[:TypeofLoadtoSizeOn] = 'Sensible'
+    system_data[:MinimumSystemAirFlowRatio] = 1.0
+
+    system_data[:PreheatDesignTemperature] = 7.0
+    system_data[:PreheatDesignHumidityRatio] = 0.008
+    system_data[:PrecoolDesignTemperature] = 13.0
+    system_data[:PrecoolDesignHumidityRatio] = 0.008
+    system_data[:SizingOption] = 'NonCoincident'
+    system_data[:CoolingDesignAirFlowMethod] = 'DesignDay'
+    system_data[:CoolingDesignAirFlowRate] = 0.0
+    system_data[:HeatingDesignAirFlowMethod] = 'DesignDay'
+    system_data[:HeatingDesignAirFlowRate] = 0.0
+    system_data[:SystemOutdoorAirMethod] = 'ZoneSum'
+    system_data[:CentralCoolingDesignSupplyAirHumidityRatio] = 0.0085
+    system_data[:CentralHeatingDesignSupplyAirHumidityRatio] = 0.0080
+
+    #System 3 Zone data
+    system_data[:ZoneCoolingDesignSupplyAirTemperature] = 13.0
+    system_data[:ZoneHeatingDesignSupplyAirTemperature] = 43.0
+    system_data[:SetpointManagerSingleZoneReheatSupplyTempMin] = 13.0
+    system_data[:SetpointManagerSingleZoneReheatSupplyTempMax] = 43.0
+    system_data[:ZoneDXCoolingSizingFactor] = 1.0
+    system_data[:ZoneDXHeatingSizingFactor] = 1.3
+    system_data[:ZoneCoolingSizingFactor] = 1.1
+    system_data[:ZoneHeatingSizingFactor] = 1.3
+    system_data[:MinimumOutdoorDryBulbTemperatureforCompressorOperation] = -10.0
+
+    if new_auto_zoner == true
+      # Create system airloop
+
+      # Add Air Loop
+      air_loop = add_system_3_and_8_airloop_multi_speed(heating_coil_type,
+                                            model,
+                                            system_data,
+                                            determine_control_zone(zones))
+      # Add Zone equipment
+      zones.each do |zone| # Zone sizing temperature
+        sizing_zone = zone.sizingZone
+        sizing_zone.setZoneCoolingDesignSupplyAirTemperature(system_data[:ZoneCoolingDesignSupplyAirTemperature])
+        sizing_zone.setZoneHeatingDesignSupplyAirTemperature(system_data[:ZoneHeatingDesignSupplyAirTemperature])
+        sizing_zone.setZoneCoolingSizingFactor(system_data[:ZoneCoolingSizingFactor])
+        sizing_zone.setZoneHeatingSizingFactor(system_data[:ZoneHeatingSizingFactor])
+        add_sys3_and_8_zone_equip(air_loop,
+                                  baseboard_type,
+                                  hw_loop,
+                                  model,
+                                  zone)
+
+      end
+      return true
+    else
+      zones.each do |zone|
+        air_loop = add_system_3_and_8_airloop_multi_speed(heating_coil_type, model, system_data, zone)
+        add_sys3_and_8_zone_equip(air_loop,
+                                  baseboard_type,
+                                  hw_loop,
+                                  model,
+                                  zone)
+      end
+      return true
+    end
+  end
+
+  def add_system_3_and_8_airloop_multi_speed(heating_coil_type, model, system_data, control_zone)
     # System Type 3: PSZ-AC
     # This measure creates:
     # -a constant volume packaged single-zone A/C unit
@@ -18,157 +90,83 @@ class NECB2011
     # "NaturalGas","Electricity","PropaneGas","FuelOilNo1","FuelOilNo2","Coal","Diesel","Gasoline","OtherFuel1"
 
     always_on = model.alwaysOnDiscreteSchedule
+    air_loop = common_air_loop(model: model, system_data: system_data)
+    air_loop.setName("#{system_data[:name]} #{control_zone.name}")
 
-    # TODO: Heating and cooling temperature set point schedules are set somewhere else
-    # TODO: For now fetch the schedules and use them in setting up the heat pump system
-    # TODO: Later on these schedules need to be passed on to this method
-    htg_temp_sch = nil
-    clg_temp_sch = nil
-    zones.each do |izone|
-      if izone.thermostat.is_initialized
-        zone_thermostat = izone.thermostat.get
-        if zone_thermostat.to_ThermostatSetpointDualSetpoint.is_initialized
-          dual_thermostat = zone_thermostat.to_ThermostatSetpointDualSetpoint.get
-          htg_temp_sch = dual_thermostat.heatingSetpointTemperatureSchedule.get
-          clg_temp_sch = dual_thermostat.coolingSetpointTemperatureSchedule.get
-          break
-        end
-      end
-    end
+    # Zone sizing temperature
+    sizing_zone = control_zone.sizingZone
+    sizing_zone.setZoneCoolingDesignSupplyAirTemperature(system_data[:ZoneCoolingDesignSupplyAirTemperature])
+    sizing_zone.setZoneHeatingDesignSupplyAirTemperature(system_data[:ZoneHeatingDesignSupplyAirTemperature])
+    sizing_zone.setZoneCoolingSizingFactor(system_data[:ZoneCoolingSizingFactor])
+    sizing_zone.setZoneHeatingSizingFactor(system_data[:ZoneHeatingSizingFactor])
 
-    zones.each do |zone|
-      air_loop = OpenStudio::Model::AirLoopHVAC.new(model)
-
-      air_loop.setName("Sys_3_PSZ_#{zone.name}")
-
-      # When an air_loop is constructed, its constructor creates a sizing:system object
-      # the default sizing:system constructor makes a system:sizing object
-      # appropriate for a multizone VAV system
-      # this systems is a constant volume system with no VAV terminals,
-      # and therfore needs different default settings
-      air_loop_sizing = air_loop.sizingSystem # TODO units
-      air_loop_sizing.setTypeofLoadtoSizeOn('Sensible')
-      air_loop_sizing.autosizeDesignOutdoorAirFlowRate
-      if model.version < OpenStudio::VersionString.new('2.7.0')
-        air_loop_sizing.setMinimumSystemAirFlowRatio(1.0)
-      else
-        air_loop_sizing.setCentralHeatingMaximumSystemAirFlowRatio(1.0)
-      end
-      air_loop_sizing.setPreheatDesignTemperature(7.0)
-      air_loop_sizing.setPreheatDesignHumidityRatio(0.008)
-      air_loop_sizing.setPrecoolDesignTemperature(13.0)
-      air_loop_sizing.setPrecoolDesignHumidityRatio(0.008)
-      air_loop_sizing.setCentralCoolingDesignSupplyAirTemperature(13.0)
-      air_loop_sizing.setCentralHeatingDesignSupplyAirTemperature(43.0)
-      air_loop_sizing.setSizingOption('NonCoincident')
-      air_loop_sizing.setAllOutdoorAirinCooling(false)
-      air_loop_sizing.setAllOutdoorAirinHeating(false)
-      air_loop_sizing.setCentralCoolingDesignSupplyAirHumidityRatio(0.0085)
-      air_loop_sizing.setCentralHeatingDesignSupplyAirHumidityRatio(0.0080)
-      air_loop_sizing.setCoolingDesignAirFlowMethod('DesignDay')
-      air_loop_sizing.setCoolingDesignAirFlowRate(0.0)
-      air_loop_sizing.setHeatingDesignAirFlowMethod('DesignDay')
-      air_loop_sizing.setHeatingDesignAirFlowRate(0.0)
-      air_loop_sizing.setSystemOutdoorAirMethod('ZoneSum')
-
-      # Zone sizing temperature
-      sizing_zone = zone.sizingZone
-      sizing_zone.setZoneCoolingDesignSupplyAirTemperature(13.0)
-      sizing_zone.setZoneHeatingDesignSupplyAirTemperature(43.0)
-      sizing_zone.setZoneCoolingSizingFactor(1.1)
-      sizing_zone.setZoneHeatingSizingFactor(1.3)
-
-      fan = OpenStudio::Model::FanConstantVolume.new(model, always_on)
-
-      staged_thermostat = OpenStudio::Model::ZoneControlThermostatStagedDualSetpoint.new(model)
-      staged_thermostat.setHeatingTemperatureSetpointSchedule(htg_temp_sch)
-      staged_thermostat.setNumberofHeatingStages(4)
-      staged_thermostat.setCoolingTemperatureSetpointBaseSchedule(clg_temp_sch)
-      staged_thermostat.setNumberofCoolingStages(4)
-      zone.setThermostat(staged_thermostat)
-
-      # Multi-stage gas heating coil
-      if heating_coil_type == 'Gas' || heating_coil_type == 'Electric'
-        htg_coil = OpenStudio::Model::CoilHeatingGasMultiStage.new(model)
-        htg_stage_1 = OpenStudio::Model::CoilHeatingGasMultiStageStageData.new(model)
-        htg_stage_2 = OpenStudio::Model::CoilHeatingGasMultiStageStageData.new(model)
-        htg_stage_3 = OpenStudio::Model::CoilHeatingGasMultiStageStageData.new(model)
-        htg_stage_4 = OpenStudio::Model::CoilHeatingGasMultiStageStageData.new(model)
-        if heating_coil_type == 'Gas'
-          supplemental_htg_coil = OpenStudio::Model::CoilHeatingGas.new(model, always_on)
-        elsif heating_coil_type == 'Electric'
-          supplemental_htg_coil = OpenStudio::Model::CoilHeatingElectric.new(model, always_on)
-          htg_stage_1.setNominalCapacity(0.1)
-          htg_stage_2.setNominalCapacity(0.2)
-          htg_stage_3.setNominalCapacity(0.3)
-          htg_stage_4.setNominalCapacity(0.4)
-        end
-
-        # Multi-Stage DX or Electric heating coil
-      elsif heating_coil_type == 'DX'
-        htg_coil = OpenStudio::Model::CoilHeatingDXMultiSpeed.new(model)
-        htg_stage_1 = OpenStudio::Model::CoilHeatingDXMultiSpeedStageData.new(model)
-        htg_stage_2 = OpenStudio::Model::CoilHeatingDXMultiSpeedStageData.new(model)
-        htg_stage_3 = OpenStudio::Model::CoilHeatingDXMultiSpeedStageData.new(model)
-        htg_stage_4 = OpenStudio::Model::CoilHeatingDXMultiSpeedStageData.new(model)
-        supplemental_htg_coil = OpenStudio::Model::CoilHeatingElectric.new(model, always_on)
-        sizing_zone.setZoneHeatingSizingFactor(1.3)
-        sizing_zone.setZoneCoolingSizingFactor(1.0)
-      else
-        raise("#{heating_coil_type} is not a valid heating coil type.)")
-      end
-
-      # Add stages to heating coil
-      htg_coil.addStage(htg_stage_1)
-      htg_coil.addStage(htg_stage_2)
-      htg_coil.addStage(htg_stage_3)
-      htg_coil.addStage(htg_stage_4)
+    fan = OpenStudio::Model::FanConstantVolume.new(model, always_on)
 
-      # TODO: other fuel-fired heating coil types? (not available in OpenStudio/E+ - may need to play with efficiency to mimic other fuel types)
-
-      # Set up DX cooling coil
+    # Setup heating and cooling coils
+    if(heating_coil_type == 'Gas') || (heating_coil_type == 'Electric')
       clg_coil = OpenStudio::Model::CoilCoolingDXMultiSpeed.new(model)
       clg_coil.setFuelType('Electricity')
       clg_stage_1 = OpenStudio::Model::CoilCoolingDXMultiSpeedStageData.new(model)
       clg_stage_2 = OpenStudio::Model::CoilCoolingDXMultiSpeedStageData.new(model)
-      clg_stage_3 = OpenStudio::Model::CoilCoolingDXMultiSpeedStageData.new(model)
-      clg_stage_4 = OpenStudio::Model::CoilCoolingDXMultiSpeedStageData.new(model)
       clg_coil.addStage(clg_stage_1)
       clg_coil.addStage(clg_stage_2)
-      clg_coil.addStage(clg_stage_3)
-      clg_coil.addStage(clg_stage_4)
+      clg_coil.setApplyPartLoadFractiontoSpeedsGreaterthan1(false)
+      htg_coil = OpenStudio::Model::CoilHeatingGasMultiStage.new(model)
+      htg_stage_1 = OpenStudio::Model::CoilHeatingGasMultiStageStageData.new(model)
+      htg_coil.addStage(htg_stage_1)
+      if heating_coil_type == 'Gas'
+        supplemental_htg_coil = OpenStudio::Model::CoilHeatingGas.new(model, always_on)
+        supplemental_htg_coil.setNominalCapacity(0.001)
+      elsif heating_coil_type == 'Electric'
+        supplemental_htg_coil = OpenStudio::Model::CoilHeatingElectric.new(model, always_on)
+        htg_stage_1.setNominalCapacity(0.001)
+      end
+    # Single stage DX and Electric heating
+    elsif(heating_coil_type == 'DX')
+      clg_coil = OpenStudio::Model::CoilCoolingDXSingleSpeed.new(model)
+      clg_coil.setMinimumOutdoorDryBulbTemperatureforCompressorOperation(system_data[:MinimumOutdoorDryBulbTemperatureforCompressorOperation])
+      htg_coil = OpenStudio::Model::CoilHeatingDXSingleSpeed.new(model)
+      supplemental_htg_coil = OpenStudio::Model::CoilHeatingElectric.new(model, always_on)
+    else
+      raise("#{heating_coil_type} is not a valid heating coil type.)")
+    end
 
-      # oa_controller
-      oa_controller = OpenStudio::Model::ControllerOutdoorAir.new(model)
-      oa_controller.autosizeMinimumOutdoorAirFlowRate
+    # oa_controller
+    oa_controller = OpenStudio::Model::ControllerOutdoorAir.new(model)
+    oa_controller.autosizeMinimumOutdoorAirFlowRate
 
-      # oa_system
-      oa_system = OpenStudio::Model::AirLoopHVACOutdoorAirSystem.new(model, oa_controller)
+    # oa_system
+    oa_system = OpenStudio::Model::AirLoopHVACOutdoorAirSystem.new(model, oa_controller)
 
-      # Add the components to the air loop
-      # in order from closest to zone to furthest from zone
-      supply_inlet_node = air_loop.supplyInletNode
+    # Add the components to the air loop
+    # in order from closest to zone to furthest from zone
+    supply_inlet_node = air_loop.supplyInletNode
 
+    if(heating_coil_type == "Gas") || (heating_coil_type == "Electric")
       air_to_air_heatpump = OpenStudio::Model::AirLoopHVACUnitaryHeatPumpAirToAirMultiSpeed.new(model, fan, htg_coil, clg_coil, supplemental_htg_coil)
-      air_to_air_heatpump.setName("#{zone.name} ASHP")
-      air_to_air_heatpump.setControllingZoneorThermostatLocation(zone)
-      air_to_air_heatpump.setSupplyAirFanOperatingModeSchedule(always_on)
-      air_to_air_heatpump.addToNode(supply_inlet_node)
-      air_to_air_heatpump.setNumberofSpeedsforHeating(4)
-      air_to_air_heatpump.setNumberofSpeedsforCooling(4)
-
-      oa_system.addToNode(supply_inlet_node)
+      air_to_air_heatpump.setControllingZoneorThermostatLocation(control_zone)
+      air_to_air_heatpump.setNumberofSpeedsforHeating(1)
+      air_to_air_heatpump.setNumberofSpeedsforCooling(2)
+      air_to_air_heatpump.setMinimumOutdoorDryBulbTemperatureforCompressorOperation(system_data[:MinimumOutdoorDryBulbTemperatureforCompressorOperation])
+    elsif(heating_coil_type == 'DX')
+      air_to_air_heatpump = OpenStudio::Model::AirLoopHVACUnitaryHeatPumpAirToAir.new(model, always_on, fan, htg_coil, clg_coil, supplemental_htg_coil)
+      air_to_air_heatpump.setControllingZone(zone)
+    end
+    air_to_air_heatpump.setName("#{control_zone.name} ASHP")
+    air_to_air_heatpump.setSupplyAirFanOperatingModeSchedule(always_on)
+    air_to_air_heatpump.addToNode(supply_inlet_node)
 
-      # Create a diffuser and attach the zone/diffuser pair to the air loop
-      # diffuser = OpenStudio::Model::AirTerminalSingleDuctUncontrolled.new(model,always_on)
-      diffuser = OpenStudio::Model::AirTerminalSingleDuctUncontrolled.new(model, always_on)
-      air_loop.addBranchForZone(zone, diffuser.to_StraightComponent)
+    oa_system.addToNode(supply_inlet_node)
 
-      add_zone_baseboards(baseboard_type: baseboard_type, hw_loop: hw_loop, model: model, zone: zone)
-    end # zone loop
+    # Add a setpoint manager single zone reheat to control the
+    # supply air temperature based on the needs of this zone
+    setpoint_mgr_single_zone_reheat = OpenStudio::Model::SetpointManagerSingleZoneReheat.new(model)
+    setpoint_mgr_single_zone_reheat.setControlZone(control_zone)
+    setpoint_mgr_single_zone_reheat.setMinimumSupplyAirTemperature(system_data[:SetpointManagerSingleZoneReheatSupplyTempMin])
+    setpoint_mgr_single_zone_reheat.setMaximumSupplyAirTemperature(system_data[:SetpointManagerSingleZoneReheatSupplyTempMax])
+    setpoint_mgr_single_zone_reheat.addToNode(air_loop.supplyOutletNode)
 
-    return true
+    return air_loop
   end
 
-# end add_sys3_single_zone_packaged_rooftop_unit_with_baseboard_heating_multi_speed
 end