openstudio-standards 0.4.0 → 0.5.0.rc1

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

@@ -3,27 +3,29 @@ class Standard
   # @ref [References::CBERadiantSystems]
   # @param zone [OpenStudio::Model::ThermalZone>] zone to add radiant controls
   # @param radiant_loop [OpenStudio::Model::ZoneHVACLowTempRadiantVarFlow>] radiant loop in thermal zone
-  # @param radiant_type [String] determines the surface of the radiant system for surface temperature output reporting
-  #   options are 'floor' and 'ceiling'
-  # @param model_occ_hr_start [Double] Starting hour of building occupancy
-  # @param model_occ_hr_end [Double] Ending hour of building occupancy
+  # @param radiant_temperature_control_type [String] determines the controlled temperature for the radiant system
+  #   options are 'SurfaceFaceTemperature', 'SurfaceInteriorTemperature'
+  # @param use_zone_occupancy_for_control [Boolean] Set to true if radiant system is to use specific zone occupancy objects
+  #   for CBE control strategy. If false, then it will use values in model_occ_hr_start and model_occ_hr_end
+  #   for all radiant zones. default to true.
+  # @param occupied_percentage_threshold [Double] the minimum fraction (0 to 1) that counts as occupied
+  #   if this parameter is set, the returned ScheduleRuleset will be 0 = unoccupied, 1 = occupied
+  #   otherwise the ScheduleRuleset will be the weighted fractional occupancy schedule
+  # @param model_occ_hr_start [Double] Starting decimal hour of whole building occupancy
+  # @param model_occ_hr_end [Double] Ending decimal hour of whole building occupancy
   # @todo model_occ_hr_start and model_occ_hr_end from zone occupancy schedules
   # @param proportional_gain [Double] Proportional gain constant (recommended 0.3 or less).
-  # @param minimum_operation [Double] Minimum number of hours of operation for radiant system before it shuts off.
-  # @param weekend_temperature_reset [Double] Weekend temperature reset for slab temperature setpoint in degree Celsius.
-  # @param early_reset_out_arg [Double] Time at which the weekend temperature reset is removed.
   # @param switch_over_time [Double] Time limitation for when the system can switch between heating and cooling
   def model_add_radiant_proportional_controls(model, zone, radiant_loop,
-                                              radiant_type: 'floor',
+                                              radiant_temperature_control_type: 'SurfaceFaceTemperature',
+                                              use_zone_occupancy_for_control: true,
+                                              occupied_percentage_threshold: 0.10,
                                               model_occ_hr_start: 6.0,
                                               model_occ_hr_end: 18.0,
                                               proportional_gain: 0.3,
-                                              minimum_operation: 1,
-                                              weekend_temperature_reset: 2,
-                                              early_reset_out_arg: 20,
                                               switch_over_time: 24.0)
 
-    zone_name = zone.name.to_s.gsub(/[ +-.]/, '_')
+    zone_name = ems_friendly_name(zone.name)
     zone_timestep = model.getTimestep.numberOfTimestepsPerHour
 
     if model.version < OpenStudio::VersionString.new('3.1.1')
@@ -34,61 +36,56 @@ class Standard
       coil_heating_radiant = radiant_loop.heatingCoil.get.to_CoilHeatingLowTempRadiantVarFlow.get
     end
 
+    #####
+    # Define radiant system parameters
+    ####
+    # set radiant system temperature and setpoint control type
+    unless ['surfacefacetemperature', 'surfaceinteriortemperature'].include? radiant_temperature_control_type.downcase
+      OpenStudio.logFree(OpenStudio::Error, 'openstudio.Model.Model',
+                         "Control sequences not compatible with '#{radiant_temperature_control_type}' radiant system control. Defaulting to 'SurfaceFaceTemperature'.")
+      radiant_temperature_control_type = 'SurfaceFaceTemperature'
+    end
+
+    radiant_loop.setTemperatureControlType(radiant_temperature_control_type)
+
     #####
     # List of schedule objects used to hold calculation results
     ####
 
-    # cold water control actuator
-    # Command to turn ON/OFF the cold water through the radiant system. 0=ON and 100=OFF
-    # Large temperatures are used to ensure that the radiant system valve will fully open and close
+    # get existing switchover time schedule or create one if needed
+    sch_radiant_switchover = model.getScheduleRulesetByName('Radiant System Switchover')
+    if sch_radiant_switchover.is_initialized
+      sch_radiant_switchover = sch_radiant_switchover.get
+    else
+      sch_radiant_switchover = model_add_constant_schedule_ruleset(model,
+                                                                   switch_over_time,
+                                                                   name = 'Radiant System Switchover',
+                                                                   sch_type_limit: 'Dimensionless')
+    end
+
+    # set radiant system switchover schedule
+    radiant_loop.setChangeoverDelayTimePeriodSchedule(sch_radiant_switchover.to_Schedule.get)
+
+    # Calculated active slab heating and cooling temperature setpoint.
+    # radiant system cooling control actuator
     sch_radiant_clgsetp = model_add_constant_schedule_ruleset(model,
-                                                              0.0,
+                                                              26.0,
                                                               name = "#{zone_name}_Sch_Radiant_ClgSetP")
     coil_cooling_radiant.setCoolingControlTemperatureSchedule(sch_radiant_clgsetp)
     cmd_cold_water_ctrl = OpenStudio::Model::EnergyManagementSystemActuator.new(sch_radiant_clgsetp,
                                                                                 'Schedule:Year',
                                                                                 'Schedule Value')
-    cmd_cold_water_ctrl.setName("#{zone_name}_CMD_COLD_WATER_CTRL")
+    cmd_cold_water_ctrl.setName("#{zone_name}_cmd_cold_water_ctrl")
 
-    # hot water control actuator
-    # Command to turn ON/OFF the hot water through the radiant system. 60=ON and -60=OFF.
-    # Large temperatures are used to to ensure that the radiant system valve will fully open and close
+    # radiant system heating control actuator
     sch_radiant_htgsetp = model_add_constant_schedule_ruleset(model,
-                                                              -60.0,
+                                                              20.0,
                                                               name = "#{zone_name}_Sch_Radiant_HtgSetP")
     coil_heating_radiant.setHeatingControlTemperatureSchedule(sch_radiant_htgsetp)
     cmd_hot_water_ctrl = OpenStudio::Model::EnergyManagementSystemActuator.new(sch_radiant_htgsetp,
                                                                                'Schedule:Year',
                                                                                'Schedule Value')
-    cmd_hot_water_ctrl.setName("#{zone_name}_CMD_HOT_WATER_CTRL")
-
-    # set schedule type limits for hot water control
-    hot_water_schedule_type_limits = model.getScheduleTypeLimitsByName('Radiant_Hot_water_Ctrl_Temperature_Limits')
-    if hot_water_schedule_type_limits.is_initialized
-      hot_water_schedule_type_limits = hot_water_schedule_type_limits.get
-    else
-      hot_water_schedule_type_limits = OpenStudio::Model::ScheduleTypeLimits.new(model)
-      hot_water_schedule_type_limits.setName('Radiant_Hot_water_Ctrl_Temperature_Limits')
-      hot_water_schedule_type_limits.setLowerLimitValue(-60.0)
-      hot_water_schedule_type_limits.setUpperLimitValue(100.0)
-      hot_water_schedule_type_limits.setNumericType('Continuous')
-      hot_water_schedule_type_limits.setUnitType('Temperature')
-    end
-    sch_radiant_htgsetp.setScheduleTypeLimits(hot_water_schedule_type_limits)
-
-    # Calculated active slab heating and cooling temperature setpoint. Default temperature is taken at the slab surface.
-    sch_slab_sp = model_add_constant_schedule_ruleset(model,
-                                                      21.0,
-                                                      name = "#{zone_name}_Sch_Slab_SP")
-    cmd_slab_sp = OpenStudio::Model::EnergyManagementSystemActuator.new(sch_slab_sp,
-                                                                        'Schedule:Year',
-                                                                        'Schedule Value')
-    cmd_slab_sp.setName("#{zone_name}_CMD_SLAB_SP")
-
-    # add output variable for slab setpoint temperature
-    var = OpenStudio::Model::OutputVariable.new('Schedule Value', model)
-    var.setKeyValue("#{zone_name}_Sch_Slab_SP")
-    var.setReportingFrequency('Timestep')
+    cmd_hot_water_ctrl.setName("#{zone_name}_cmd_hot_water_ctrl")
 
     # Calculated cooling setpoint error. Calculated from upper comfort limit minus setpoint offset and 'measured' controlled zone temperature.
     sch_csp_error = model_add_constant_schedule_ruleset(model,
@@ -97,7 +94,7 @@ class Standard
     cmd_csp_error = OpenStudio::Model::EnergyManagementSystemActuator.new(sch_csp_error,
                                                                           'Schedule:Year',
                                                                           'Schedule Value')
-    cmd_csp_error.setName("#{zone_name}_CMD_CSP_ERROR")
+    cmd_csp_error.setName("#{zone_name}_cmd_csp_error")
 
     # Calculated heating setpoint error. Calculated from lower comfort limit plus setpoint offset and 'measured' controlled zone temperature.
     sch_hsp_error = model_add_constant_schedule_ruleset(model,
@@ -106,57 +103,12 @@ class Standard
     cmd_hsp_error = OpenStudio::Model::EnergyManagementSystemActuator.new(sch_hsp_error,
                                                                           'Schedule:Year',
                                                                           'Schedule Value')
-    cmd_hsp_error.setName("#{zone_name}_CMD_HSP_ERROR")
-
-    # Averaged radiant slab controlled temperature. Averaged over the last 24 hours.
-    sch_avg_ctrl_temp = model_add_constant_schedule_ruleset(model,
-                                                            20.0,
-                                                            name = "#{zone_name}_Sch_Avg_Ctrl_Temp")
-    cmd_ctrl_temp_running_mean = OpenStudio::Model::EnergyManagementSystemActuator.new(sch_avg_ctrl_temp,
-                                                                                       'Schedule:Year',
-                                                                                       'Schedule Value')
-    cmd_ctrl_temp_running_mean.setName("#{zone_name}_CMD_CTRL_TEMP_RUNNING_MEAN")
-
-    # Averaged outdoor air temperature. Averaged over the last 24 hours.
-    sch_oat_running_mean = model.getScheduleConstantByName('SCH_OAT_RUNNING_MEAN')
-    if sch_oat_running_mean.is_initialized
-      sch_oat_running_mean = sch_oat_running_mean.get
-    else
-      sch_oat_running_mean = model_add_constant_schedule_ruleset(model,
-                                                                 20.0,
-                                                                 name = 'SCH_OAT_RUNNING_MEAN')
-    end
-
-    cmd_oat_running_mean = model.getEnergyManagementSystemActuatorByName('CMD_OAT_RUNNING_MEAN')
-    if cmd_oat_running_mean.is_initialized
-      cmd_oat_running_mean = cmd_oat_running_mean.get
-    else
-      cmd_oat_running_mean = OpenStudio::Model::EnergyManagementSystemActuator.new(sch_oat_running_mean,
-                                                                                   'Schedule:Year',
-                                                                                   'Schedule Value')
-      cmd_oat_running_mean.setName('CMD_OAT_RUNNING_MEAN')
-    end
+    cmd_hsp_error.setName("#{zone_name}_cmd_hsp_error")
 
     #####
     # List of global variables used in EMS scripts
     ####
 
-    # Start of occupied time of zone. Valid from 1-24.
-    occ_hr_start = model.getEnergyManagementSystemGlobalVariableByName('occ_hr_start')
-    if occ_hr_start.is_initialized
-      occ_hr_start = occ_hr_start.get
-    else
-      occ_hr_start = OpenStudio::Model::EnergyManagementSystemGlobalVariable.new(model, 'occ_hr_start')
-    end
-
-    # End of occupied time of zone. Valid from 1-24.
-    occ_hr_end = model.getEnergyManagementSystemGlobalVariableByName('occ_hr_end')
-    if occ_hr_end.is_initialized
-      occ_hr_end = occ_hr_end.get
-    else
-      occ_hr_end = OpenStudio::Model::EnergyManagementSystemGlobalVariable.new(model, 'occ_hr_end')
-    end
-
     # Proportional  gain constant (recommended 0.3 or less).
     prp_k = model.getEnergyManagementSystemGlobalVariableByName('prp_k')
     if prp_k.is_initialized
@@ -165,55 +117,7 @@ class Standard
       prp_k = OpenStudio::Model::EnergyManagementSystemGlobalVariable.new(model, 'prp_k')
     end
 
-    # mean outdoor dry-bulb air temperature
-    mean_oat = model.getEnergyManagementSystemGlobalVariableByName('mean_oat')
-    if mean_oat.is_initialized
-      mean_oat = mean_oat.get
-    else
-      mean_oat = OpenStudio::Model::EnergyManagementSystemGlobalVariable.new(model, 'mean_oat')
-    end
-
-    # Is the day a weekend? 1=Weekend and 0=Not Weekend.
-    weekend = model.getEnergyManagementSystemGlobalVariableByName('weekend')
-    if weekend.is_initialized
-      weekend = weekend.get
-    else
-      weekend = OpenStudio::Model::EnergyManagementSystemGlobalVariable.new(model, 'weekend')
-    end
-
-    # Is the building in unoccupied model? 1=Unoccupied and 0=Not Unoccupied.
-    unoccupied = model.getEnergyManagementSystemGlobalVariableByName('unoccupied')
-    if unoccupied.is_initialized
-      unoccupied = unoccupied.get
-    else
-      unoccupied = OpenStudio::Model::EnergyManagementSystemGlobalVariable.new(model, 'unoccupied')
-    end
-
-    # Minimum number of hours of operation for radiant system before it shuts off.
-    min_oper = model.getEnergyManagementSystemGlobalVariableByName('min_oper')
-    if min_oper.is_initialized
-      min_oper = min_oper.get
-    else
-      min_oper = OpenStudio::Model::EnergyManagementSystemGlobalVariable.new(model, 'min_oper')
-    end
-
-    # Weekend temperature reset for slab temperature setpoint in degree Celsius.
-    wkend_temp_reset = model.getEnergyManagementSystemGlobalVariableByName('wkend_temp_reset')
-    if wkend_temp_reset.is_initialized
-      wkend_temp_reset = wkend_temp_reset.get
-    else
-      wkend_temp_reset = OpenStudio::Model::EnergyManagementSystemGlobalVariable.new(model, 'wkend_temp_reset')
-    end
-
-    # Time at which the weekend temperature reset is removed.
-    early_reset_out = model.getEnergyManagementSystemGlobalVariableByName('early_reset_out')
-    if early_reset_out.is_initialized
-      early_reset_out = early_reset_out.get
-    else
-      early_reset_out = OpenStudio::Model::EnergyManagementSystemGlobalVariable.new(model, 'early_reset_out')
-    end
-
-    # Upper slab temperature setpoint limit
+    # Upper slab temperature setpoint limit (recommended no higher than 29C (84F))
     upper_slab_sp_lim = model.getEnergyManagementSystemGlobalVariableByName('upper_slab_sp_lim')
     if upper_slab_sp_lim.is_initialized
       upper_slab_sp_lim = upper_slab_sp_lim.get
@@ -221,7 +125,7 @@ class Standard
       upper_slab_sp_lim = OpenStudio::Model::EnergyManagementSystemGlobalVariable.new(model, 'upper_slab_sp_lim')
     end
 
-    # Lower slab temperature setpoint limit
+    # Lower slab temperature setpoint limit (recommended no lower than 19C (66F))
     lower_slab_sp_lim = model.getEnergyManagementSystemGlobalVariableByName('lower_slab_sp_lim')
     if lower_slab_sp_lim.is_initialized
       lower_slab_sp_lim = lower_slab_sp_lim.get
@@ -229,7 +133,7 @@ class Standard
       lower_slab_sp_lim = OpenStudio::Model::EnergyManagementSystemGlobalVariable.new(model, 'lower_slab_sp_lim')
     end
 
-    # Temperature offset used to modify.
+    # Temperature offset used as a safety factor for thermal control (recommend 0.5C (1F)).
     ctrl_temp_offset = model.getEnergyManagementSystemGlobalVariableByName('ctrl_temp_offset')
     if ctrl_temp_offset.is_initialized
       ctrl_temp_offset = ctrl_temp_offset.get
@@ -237,7 +141,17 @@ class Standard
       ctrl_temp_offset = OpenStudio::Model::EnergyManagementSystemGlobalVariable.new(model, 'ctrl_temp_offset')
     end
 
-    # zone specific variables
+    # Hour where slab setpoint is to be changed
+    hour_of_slab_sp_change = model.getEnergyManagementSystemGlobalVariableByName('hour_of_slab_sp_change')
+    if hour_of_slab_sp_change.is_initialized
+      hour_of_slab_sp_change = hour_of_slab_sp_change.get
+    else
+      hour_of_slab_sp_change = OpenStudio::Model::EnergyManagementSystemGlobalVariable.new(model, 'hour_of_slab_sp_change')
+    end
+
+    #####
+    # List of zone specific variables used in EMS scripts
+    ####
 
     # Maximum 'measured' temperature in zone during occupied times. Default setup uses mean air temperature.
     # Other possible choices are operative and mean radiant temperature.
@@ -247,246 +161,189 @@ class Standard
     # Other possible choices are operative and mean radiant temperature.
     zone_min_ctrl_temp = OpenStudio::Model::EnergyManagementSystemGlobalVariable.new(model, "#{zone_name}_min_ctrl_temp")
 
-    # mean temperature of control surface
-    zone_mean_ctrl = OpenStudio::Model::EnergyManagementSystemGlobalVariable.new(model, "#{zone_name}_mean_ctrl")
-
-    # Continuous operation where there is no active hydronic heating or cooling in thermal zone in hours.
-    zone_cont_neutral_oper = OpenStudio::Model::EnergyManagementSystemGlobalVariable.new(model, "#{zone_name}_cont_neutral_oper")
-
-    # Zone mode of thermal zone. -1=Heating, 1=Cooling, and 0=Neutral.
-    zone_zone_mode = OpenStudio::Model::EnergyManagementSystemGlobalVariable.new(model, "#{zone_name}_zone_mode")
-
-    # Amount of hours that building needs to be in neutral mode in order to switch over from heating to cooling or from cooling to heating.
-    zone_switch_over_time = OpenStudio::Model::EnergyManagementSystemGlobalVariable.new(model, "#{zone_name}_switch_over_time")
-
-    # Continuous operation when radiant system is active in hours.
-    zone_cont_rad_oper = OpenStudio::Model::EnergyManagementSystemGlobalVariable.new(model, "#{zone_name}_cont_rad_oper")
-
-    # Total time the radiant system was in cooling mode in the last 24 hours.
-    # Calculated at one timestep before the end of occupied time.
-    zone_daily_cool_sum = OpenStudio::Model::EnergyManagementSystemGlobalVariable.new(model, "#{zone_name}_daily_cool_sum")
-
-    # Total time the radiant system was in heating mode in the last 24 hours.
-    # Calculated at one timestep before the end of occupied time.
-    zone_daily_heat_sum = OpenStudio::Model::EnergyManagementSystemGlobalVariable.new(model, "#{zone_name}_daily_heat_sum")
-
-    # Total time the radiant system was in cooling mode for the previous day.
-    zone_daily_cool_sum_one = OpenStudio::Model::EnergyManagementSystemGlobalVariable.new(model, "#{zone_name}_daily_cool_sum_one")
-
-    # Total time the radiant system was in heating mode for the previous day.
-    zone_daily_heat_sum_one = OpenStudio::Model::EnergyManagementSystemGlobalVariable.new(model, "#{zone_name}_daily_heat_sum_one")
-
     #####
     # List of 'sensors' used in the EMS programs
     ####
 
-    # Outdoor air temperature.
-    oat = model.getEnergyManagementSystemSensorByName('OAT')
-    if oat.is_initialized
-      oat = oat.get
-    else
-      oat = OpenStudio::Model::EnergyManagementSystemSensor.new(model, 'Site Outdoor Air Drybulb Temperature')
-      oat.setName('OAT')
-      oat.setKeyName('Environment')
-    end
-
-    # Number of timesteps to average control temperature. (Currently unused)
-    # avg_window_n = model.getEnergyManagementSystemSensorByName('avg_window_n')
-    # if avg_window_n.is_initialized
-    #   avg_window_n = avg_window_n.get
-    # else
-    #   avg_window_n = OpenStudio::Model::EnergyManagementSystemSensor.new(model, 'Schedule Value')
-    #   avg_window_n.setName('avg_window_n')
-    #   avg_window_n.setKeyName('Sch_Slab_Ctrl_Avg_Window_N')
-    # end
-
     # Controlled zone temperature for the zone.
     zone_ctrl_temperature = OpenStudio::Model::EnergyManagementSystemSensor.new(model, 'Zone Air Temperature')
-    zone_ctrl_temperature.setName("#{zone_name}_Ctrl_Temperature")
+    zone_ctrl_temperature.setName("#{zone_name}_ctrl_temperature")
     zone_ctrl_temperature.setKeyName(zone.name.get)
 
-    # Active surface slab temperature. # Use largest surface in zone.
-    surface_type = radiant_type == 'floor' ? 'Floor' : 'RoofCeiling'
-    surfaces = []
-    zone.spaces.each do |space|
-      space.surfaces.each do |surface|
-        surfaces << surface if surface.surfaceType == surface_type
-      end
+    # check for zone thermostat and replace heat/cool schedules for radiant system control
+    # if there is no zone thermostat, then create one
+    zone_thermostat = zone.thermostatSetpointDualSetpoint
+
+    if zone_thermostat.is_initialized
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.Model.Model', "Replacing thermostat schedules in zone #{zone.name} for radiant system control.")
+      zone_thermostat = zone.thermostatSetpointDualSetpoint.get
+    else
+      OpenStudio.logFree(OpenStudio::Info, 'openstudio.Model.Model', "Zone #{zone.name} does not have a thermostat. Creating a thermostat for radiant system control.")
+      zone_thermostat = OpenStudio::Model::ThermostatSetpointDualSetpoint.new(model)
+      zone_thermostat.setName("#{zone_name}_Thermostat_DualSetpoint")
     end
-    if surfaces.empty?
-      OpenStudio.logFree(OpenStudio::Error, 'openstudio.Model.Model', "Zone #{zone.name} does not have floor surfaces; cannot add radiant system.")
-      return false
+
+    # create new heating and cooling schedules to be used with all radiant systems
+    zone_htg_thermostat = model.getScheduleRulesetByName('Radiant System Heating Setpoint')
+    if zone_htg_thermostat.is_initialized
+      zone_htg_thermostat = zone_htg_thermostat.get
+    else
+      zone_htg_thermostat = model_add_constant_schedule_ruleset(model,
+                                                                20.0,
+                                                                name = 'Radiant System Heating Setpoint',
+                                                                sch_type_limit: 'Temperature')
     end
-    zone_floor = surfaces.max_by(&:grossArea)
-    zone_srf_temp = OpenStudio::Model::EnergyManagementSystemSensor.new(model, 'Surface Inside Face Temperature')
-    zone_srf_temp.setName("#{zone_name}_Srf_Temp")
-    zone_srf_temp.setKeyName(zone_floor.name.get)
 
-    # check for zone thermostats
-    zone_thermostat = zone.thermostatSetpointDualSetpoint
-    unless zone_thermostat.is_initialized
-      OpenStudio.logFree(OpenStudio::Error, 'openstudio.Model.Model', "Zone #{zone.name} does not have thermostats.")
-      return false
+    zone_clg_thermostat = model.getScheduleRulesetByName('Radiant System Cooling Setpoint')
+    if zone_clg_thermostat.is_initialized
+      zone_clg_thermostat = zone_clg_thermostat.get
+    else
+      zone_clg_thermostat = model_add_constant_schedule_ruleset(model,
+                                                                26.0,
+                                                                name = 'Radiant System Cooling Setpoint',
+                                                                sch_type_limit: 'Temperature')
     end
-    zone_thermostat = zone.thermostatSetpointDualSetpoint.get
-    zone_clg_thermostat = zone_thermostat.coolingSetpointTemperatureSchedule.get
-    zone_htg_thermostat = zone_thermostat.heatingSetpointTemperatureSchedule.get
+
+    # implement new heating and cooling schedules
+    zone_thermostat.setHeatingSetpointTemperatureSchedule(zone_htg_thermostat)
+    zone_thermostat.setCoolingSetpointTemperatureSchedule(zone_clg_thermostat)
 
     # Upper comfort limit for the zone. Taken from existing thermostat schedules in the zone.
     zone_upper_comfort_limit = OpenStudio::Model::EnergyManagementSystemSensor.new(model, 'Schedule Value')
-    zone_upper_comfort_limit.setName("#{zone_name}_Upper_Comfort_Limit")
+    zone_upper_comfort_limit.setName("#{zone_name}_upper_comfort_limit")
     zone_upper_comfort_limit.setKeyName(zone_clg_thermostat.name.get)
 
     # Lower comfort limit for the zone. Taken from existing thermostat schedules in the zone.
     zone_lower_comfort_limit = OpenStudio::Model::EnergyManagementSystemSensor.new(model, 'Schedule Value')
-    zone_lower_comfort_limit.setName("#{zone_name}_Lower_Comfort_Limit")
+    zone_lower_comfort_limit.setName("#{zone_name}_lower_comfort_limit")
     zone_lower_comfort_limit.setKeyName(zone_htg_thermostat.name.get)
 
     # Radiant system water flow rate used to determine if there is active hydronic cooling in the radiant system.
     zone_rad_cool_operation = OpenStudio::Model::EnergyManagementSystemSensor.new(model, 'System Node Mass Flow Rate')
-    zone_rad_cool_operation.setName("#{zone_name}_Rad_Cool_Operation")
+    zone_rad_cool_operation.setName("#{zone_name}_rad_cool_operation")
     zone_rad_cool_operation.setKeyName(coil_cooling_radiant.to_StraightComponent.get.inletModelObject.get.name.get)
 
     # Radiant system water flow rate used to determine if there is active hydronic heating in the radiant system.
     zone_rad_heat_operation = OpenStudio::Model::EnergyManagementSystemSensor.new(model, 'System Node Mass Flow Rate')
-    zone_rad_heat_operation.setName("#{zone_name}_Rad_Heat_Operation")
+    zone_rad_heat_operation.setName("#{zone_name}_rad_heat_operation")
     zone_rad_heat_operation.setKeyName(coil_heating_radiant.to_StraightComponent.get.inletModelObject.get.name.get)
 
-    # Last 24 hours trend for the outdoor air temperature.
-    oat_trend = model.getEnergyManagementSystemTrendVariableByName('OAT_Trend')
-    if oat_trend.is_initialized
-      oat_trend = oat_trend.get
-    else
-      oat_trend = OpenStudio::Model::EnergyManagementSystemTrendVariable.new(model, oat)
-      oat_trend.setName('OAT_Trend')
-      oat_trend.setNumberOfTimestepsToBeLogged(zone_timestep * 24)
-    end
+    # Radiant system switchover delay time period schedule
+    # used to determine if there is active hydronic cooling/heating in the radiant system.
+    zone_rad_switch_over = model.getEnergyManagementSystemSensorByName('radiant_switch_over_time')
 
-    # Last 24 hours trend for active slab surface temperature.
-    zone_srf_temp_trend = OpenStudio::Model::EnergyManagementSystemTrendVariable.new(model, zone_srf_temp)
-    zone_srf_temp_trend.setName("#{zone_name}_Srf_Temp_Trend")
-    zone_srf_temp_trend.setNumberOfTimestepsToBeLogged(zone_timestep * 24)
+    unless zone_rad_switch_over.is_initialized
+      zone_rad_switch_over = OpenStudio::Model::EnergyManagementSystemSensor.new(model, 'Schedule Value')
+      zone_rad_switch_over.setName('radiant_switch_over_time')
+      zone_rad_switch_over.setKeyName(sch_radiant_switchover.name.get)
+    end
 
     # Last 24 hours trend for radiant system in cooling mode.
     zone_rad_cool_operation_trend = OpenStudio::Model::EnergyManagementSystemTrendVariable.new(model, zone_rad_cool_operation)
-    zone_rad_cool_operation_trend.setName("#{zone_name}_Rad_Cool_Operation_Trend")
-    zone_rad_cool_operation_trend.setNumberOfTimestepsToBeLogged(zone_timestep * 24)
+    zone_rad_cool_operation_trend.setName("#{zone_name}_rad_cool_operation_trend")
+    zone_rad_cool_operation_trend.setNumberOfTimestepsToBeLogged(zone_timestep * 48)
 
     # Last 24 hours trend for radiant system in heating mode.
     zone_rad_heat_operation_trend = OpenStudio::Model::EnergyManagementSystemTrendVariable.new(model, zone_rad_heat_operation)
-    zone_rad_heat_operation_trend.setName("#{zone_name}_Rad_Heat_Operation_Trend")
-    zone_rad_heat_operation_trend.setNumberOfTimestepsToBeLogged(zone_timestep * 24)
+    zone_rad_heat_operation_trend.setName("#{zone_name}_rad_heat_operation_trend")
+    zone_rad_heat_operation_trend.setNumberOfTimestepsToBeLogged(zone_timestep * 48)
+
+    # use zone occupancy objects for radiant system control if selected
+    if use_zone_occupancy_for_control
+
+      # get annual occupancy schedule for zone
+      occ_schedule_ruleset = thermal_zone_get_occupancy_schedule(zone,
+                                                                 sch_name: "#{zone.name} Radiant System Occupied Schedule",
+                                                                 occupied_percentage_threshold: occupied_percentage_threshold)
+    else
+
+      occ_schedule_ruleset = model.getScheduleRulesetByName('Whole Building Radiant System Occupied Schedule')
+      if occ_schedule_ruleset.is_initialized
+        occ_schedule_ruleset = occ_schedule_ruleset.get
+      else
+        # create occupancy schedules
+        occ_schedule_ruleset = OpenStudio::Model::ScheduleRuleset.new(model)
+        occ_schedule_ruleset.setName('Whole Building Radiant System Occupied Schedule')
+
+        start_hour = model_occ_hr_end.to_i
+        start_minute = ((model_occ_hr_end % 1) * 60).to_i
+        end_hour = model_occ_hr_start.to_i
+        end_minute = ((model_occ_hr_start % 1) * 60).to_i
+
+        if end_hour > start_hour
+          occ_schedule_ruleset.defaultDaySchedule.addValue(OpenStudio::Time.new(0, start_hour, start_minute, 0), 1.0)
+          occ_schedule_ruleset.defaultDaySchedule.addValue(OpenStudio::Time.new(0, end_hour, end_minute, 0), 0.0)
+          occ_schedule_ruleset.defaultDaySchedule.addValue(OpenStudio::Time.new(0, 24, 0, 0), 1.0) if end_hour < 24
+        elsif start_hour > end_hour
+          occ_schedule_ruleset.defaultDaySchedule.addValue(OpenStudio::Time.new(0, end_hour, end_minute, 0), 0.0)
+          occ_schedule_ruleset.defaultDaySchedule.addValue(OpenStudio::Time.new(0, start_hour, start_minute, 0), 1.0)
+          occ_schedule_ruleset.defaultDaySchedule.addValue(OpenStudio::Time.new(0, 24, 0, 0), 0.0) if start_hour < 24
+        else
+          occ_schedule_ruleset.defaultDaySchedule.addValue(OpenStudio::Time.new(0, 24, 0, 0), 1.0)
+        end
+      end
+    end
+
+    # create ems sensor for zone occupied status
+    zone_occupied_status = OpenStudio::Model::EnergyManagementSystemSensor.new(model, 'Schedule Value')
+    zone_occupied_status.setName("#{zone_name}_occupied_status")
+    zone_occupied_status.setKeyName(occ_schedule_ruleset.name.get)
+
+    # Last 24 hours trend for zone occupied status
+    zone_occupied_status_trend = OpenStudio::Model::EnergyManagementSystemTrendVariable.new(model, zone_occupied_status)
+    zone_occupied_status_trend.setName("#{zone_name}_occupied_status_trend")
+    zone_occupied_status_trend.setNumberOfTimestepsToBeLogged(zone_timestep * 48)
 
     #####
     # List of EMS programs to implement the proportional control for the radiant system.
     ####
 
     # Initialize global constant values used in EMS programs.
-    set_constant_values_prg = model.getEnergyManagementSystemTrendVariableByName('Set_Constant_Values')
-    unless set_constant_values_prg.is_initialized
+    set_constant_values_prg_body = <<-EMS
+      SET prp_k              = #{proportional_gain},
+      SET ctrl_temp_offset   = 0.5,
+      SET upper_slab_sp_lim  = 29,
+      SET lower_slab_sp_lim  = 19,
+      SET hour_of_slab_sp_change = 18
+    EMS
+
+    set_constant_values_prg = model.getEnergyManagementSystemProgramByName('Set_Constant_Values')
+    if set_constant_values_prg.is_initialized
+      set_constant_values_prg = set_constant_values_prg.get
+    else
       set_constant_values_prg = OpenStudio::Model::EnergyManagementSystemProgram.new(model)
       set_constant_values_prg.setName('Set_Constant_Values')
-      set_constant_values_prg_body = <<-EMS
-        SET occ_hr_start       = #{model_occ_hr_start},
-        SET occ_hr_end         = #{model_occ_hr_end},
-        SET prp_k              = #{proportional_gain},
-        SET min_oper           = #{minimum_operation},
-        SET ctrl_temp_offset   = 0.5,
-        SET wkend_temp_reset   = #{weekend_temperature_reset},
-        SET early_reset_out    = #{early_reset_out_arg},
-        SET upper_slab_sp_lim  = 29,
-        SET lower_slab_sp_lim  = 19
-      EMS
       set_constant_values_prg.setBody(set_constant_values_prg_body)
     end
 
-    # Determine if it is a weekend or not a weekend schedule for the building.
-    determine_weekend_prg = model.getEnergyManagementSystemTrendVariableByName('Determine_Weekend')
-    unless determine_weekend_prg.is_initialized
-      determine_weekend_prg = OpenStudio::Model::EnergyManagementSystemProgram.new(model)
-      determine_weekend_prg.setName('Determine_Weekend')
-      determine_weekend_prg_body = <<-EMS
-        IF (DayOfWeek == 1) || (DayOfWeek == 7),
-            SET weekend = 1,
-        ELSEIF (DayOfWeek == 2) && (CurrentTime < occ_hr_start),
-            SET weekend = 1,
-        ELSEIF (DayOfWeek == 6) && (CurrentTime > occ_hr_end),
-            SET weekend = 1,
-        ELSE,
-            SET weekend = 0,
-        ENDIF
-      EMS
-      determine_weekend_prg.setBody(determine_weekend_prg_body)
-    end
-
-    # Determine if building is in unoccupied mode or not in unoccupied mode.
-    determine_unoccupied_prg = model.getEnergyManagementSystemTrendVariableByName('Determine_Unoccupied')
-    unless determine_unoccupied_prg.is_initialized
-      determine_unoccupied_prg = OpenStudio::Model::EnergyManagementSystemProgram.new(model)
-      determine_unoccupied_prg.setName('Determine_Unoccupied')
-      determine_unoccupied_prg_body = <<-EMS
-        IF (DayOfWeek == 1) || (DayOfWeek == 7),
-            SET unoccupied = 0,
-        ELSEIF (CurrentTime > occ_hr_end) || (CurrentTime < occ_hr_start),
-            IF (DayOfWeek == 2) && (CurrentTime < occ_hr_start),
-                SET unoccupied = 0,
-            ELSEIF (DayOfWeek == 6) && (CurrentTime > occ_hr_end),
-                SET unoccupied = 0,
-            ELSE,
-                SET unoccupied = 1,
-            ENDIF,
-        ELSE,
-            SET unoccupied = 0,
-        ENDIF
-      EMS
-      determine_unoccupied_prg.setBody(determine_unoccupied_prg_body)
-    end
-
     # Initialize zone specific constant values used in EMS programs.
-    set_constant_zone_values_prg = OpenStudio::Model::EnergyManagementSystemProgram.new(model)
-    set_constant_zone_values_prg.setName("#{zone_name}_Set_Constant_Values")
     set_constant_zone_values_prg_body = <<-EMS
-      SET #{zone_name}_max_ctrl_temp      = #{zone_name}_Lower_Comfort_Limit,
-      SET #{zone_name}_min_ctrl_temp      = #{zone_name}_Upper_Comfort_Limit,
-      SET #{zone_name}_cont_neutral_oper  = 0,
-      SET #{zone_name}_zone_mode          = 0,
-      SET #{zone_name}_switch_over_time   = #{switch_over_time},
-      SET #{zone_name}_CMD_CSP_ERROR      = 0,
-      SET #{zone_name}_CMD_HSP_ERROR      = 0,
-      SET #{zone_name}_CMD_SLAB_SP        = #{zone_name}_Lower_Comfort_Limit,
-      SET #{zone_name}_cont_rad_oper      = 0,
-      SET #{zone_name}_daily_cool_sum     = 0,
-      SET #{zone_name}_daily_heat_sum     = 0,
-      SET #{zone_name}_daily_cool_sum_one = 0,
-      SET #{zone_name}_daily_heat_sum_one = 0
+      SET #{zone_name}_max_ctrl_temp      = #{zone_name}_lower_comfort_limit,
+      SET #{zone_name}_min_ctrl_temp      = #{zone_name}_upper_comfort_limit,
+      SET #{zone_name}_cmd_csp_error      = 0,
+      SET #{zone_name}_cmd_hsp_error      = 0,
+      SET #{zone_name}_cmd_cold_water_ctrl = #{zone_name}_upper_comfort_limit,
+      SET #{zone_name}_cmd_hot_water_ctrl  = #{zone_name}_lower_comfort_limit
     EMS
-    set_constant_zone_values_prg.setBody(set_constant_zone_values_prg_body)
 
-    # Calculate temperature averages.
-    calculate_trends_prg = OpenStudio::Model::EnergyManagementSystemProgram.new(model)
-    calculate_trends_prg.setName("#{zone_name}_Calculate_Trends")
-    calculate_trends_prg_body = <<-EMS
-      SET mean_oat                                = @TrendAverage OAT_Trend 24/ZoneTimeStep,
-      SET #{zone_name}_mean_ctrl                  = @TrendAverage #{zone_name}_Srf_Temp_Trend 24/ZoneTimeStep,
-      SET CMD_OAT_RUNNING_MEAN                    = mean_oat + 0,
-      SET #{zone_name}_CMD_CTRL_TEMP_RUNNING_MEAN = #{zone_name}_mean_ctrl + 0
-    EMS
-    calculate_trends_prg.setBody(calculate_trends_prg_body)
+    set_constant_zone_values_prg = OpenStudio::Model::EnergyManagementSystemProgram.new(model)
+    set_constant_zone_values_prg.setName("#{zone_name}_Set_Constant_Values")
+    set_constant_zone_values_prg.setBody(set_constant_zone_values_prg_body)
 
     # Calculate maximum and minimum 'measured' controlled temperature in the zone
     calculate_minmax_ctrl_temp_prg = OpenStudio::Model::EnergyManagementSystemProgram.new(model)
     calculate_minmax_ctrl_temp_prg.setName("#{zone_name}_Calculate_Extremes_In_Zone")
     calculate_minmax_ctrl_temp_prg_body = <<-EMS
-      IF ((CurrentTime >= occ_hr_start) && (CurrentTime <= occ_hr_end)),
-          IF #{zone_name}_Ctrl_Temperature > #{zone_name}_max_ctrl_temp,
-              SET #{zone_name}_max_ctrl_temp = #{zone_name}_Ctrl_Temperature,
+      IF (#{zone_name}_occupied_status == 1),
+          IF #{zone_name}_ctrl_temperature > #{zone_name}_max_ctrl_temp,
+              SET #{zone_name}_max_ctrl_temp = #{zone_name}_ctrl_temperature,
           ENDIF,
-          IF #{zone_name}_Ctrl_Temperature < #{zone_name}_min_ctrl_temp,
-              SET #{zone_name}_min_ctrl_temp = #{zone_name}_Ctrl_Temperature,
+          IF #{zone_name}_ctrl_temperature < #{zone_name}_min_ctrl_temp,
+              SET #{zone_name}_min_ctrl_temp = #{zone_name}_ctrl_temperature,
           ENDIF,
       ELSE,
-        SET #{zone_name}_max_ctrl_temp = #{zone_name}_Lower_Comfort_Limit,
-        SET #{zone_name}_min_ctrl_temp = #{zone_name}_Upper_Comfort_Limit,
+        SET #{zone_name}_max_ctrl_temp = #{zone_name}_lower_comfort_limit,
+        SET #{zone_name}_min_ctrl_temp = #{zone_name}_upper_comfort_limit,
       ENDIF
     EMS
     calculate_minmax_ctrl_temp_prg.setBody(calculate_minmax_ctrl_temp_prg_body)
@@ -495,148 +352,48 @@ class Standard
     calculate_errors_from_comfort_prg = OpenStudio::Model::EnergyManagementSystemProgram.new(model)
     calculate_errors_from_comfort_prg.setName("#{zone_name}_Calculate_Errors_From_Comfort")
     calculate_errors_from_comfort_prg_body = <<-EMS
-      IF (CurrentTime >= (occ_hr_end - ZoneTimeStep)) && (CurrentTime <= (occ_hr_end)),
-          SET #{zone_name}_CMD_CSP_ERROR = (#{zone_name}_Upper_Comfort_Limit - ctrl_temp_offset) - #{zone_name}_max_ctrl_temp,
-          SET #{zone_name}_CMD_HSP_ERROR = (#{zone_name}_Lower_Comfort_Limit + ctrl_temp_offset) - #{zone_name}_min_ctrl_temp,
+      IF (CurrentTime == (hour_of_slab_sp_change - ZoneTimeStep)),
+          SET #{zone_name}_cmd_csp_error = (#{zone_name}_upper_comfort_limit - ctrl_temp_offset) - #{zone_name}_max_ctrl_temp,
+          SET #{zone_name}_cmd_hsp_error = (#{zone_name}_lower_comfort_limit + ctrl_temp_offset) - #{zone_name}_min_ctrl_temp,
       ENDIF
     EMS
     calculate_errors_from_comfort_prg.setBody(calculate_errors_from_comfort_prg_body)
 
-    # Calculate time when there is no active hydronic heating or cooling.
-    calculate_neutral_time_prg = OpenStudio::Model::EnergyManagementSystemProgram.new(model)
-    calculate_neutral_time_prg.setName("#{zone_name}_Calculate_Neutral_Time")
-    calculate_neutral_time_prg_body = <<-EMS
-      IF (#{zone_name}_Rad_Cool_Operation > 0) || (#{zone_name}_Rad_Heat_Operation > 0),
-          SET #{zone_name}_cont_neutral_oper = 0,
-      ELSE,
-          SET #{zone_name}_cont_neutral_oper = #{zone_name}_cont_neutral_oper + ZoneTimeStep,
-      ENDIF
-    EMS
-    calculate_neutral_time_prg.setBody(calculate_neutral_time_prg_body)
-
-    # Calculate time when there is active hydronic heating or cooling in thermal zone.
-    calculate_continuous_radiant_operation_prg = OpenStudio::Model::EnergyManagementSystemProgram.new(model)
-    calculate_continuous_radiant_operation_prg.setName("#{zone_name}_Calculate_Continuous_Radiant_Operation")
-    calculate_continuous_radiant_operation_prg_body = <<-EMS
-      IF (#{zone_name}_Rad_Cool_Operation > 0) || (#{zone_name}_Rad_Heat_Operation > 0),
-          SET #{zone_name}_cont_rad_oper = #{zone_name}_cont_rad_oper + ZoneTimeStep,
-      ELSE,
-          SET #{zone_name}_cont_rad_oper = 0,
-      ENDIF
-    EMS
-    calculate_continuous_radiant_operation_prg.setBody(calculate_continuous_radiant_operation_prg_body)
-
-    # Determine if the zone is in cooling, heating, or neutral mode.
-    determine_zone_mode_prg = OpenStudio::Model::EnergyManagementSystemProgram.new(model)
-    determine_zone_mode_prg.setName("#{zone_name}_Determine_Zone_Mode")
-    determine_zone_mode_prg_body = <<-EMS
-      SET #{zone_name}_cont_cool_oper = @TrendSum #{zone_name}_Rad_Cool_Operation_Trend 24/ZoneTimeStep,
-      SET #{zone_name}_cont_heat_oper = @TrendSum #{zone_name}_Rad_Heat_Operation_Trend 24/ZoneTimeStep,
-      IF (#{zone_name}_zone_mode <> 0) && (#{zone_name}_cont_neutral_oper > #{zone_name}_switch_over_time),
-          SET #{zone_name}_zone_mode = 0,
-      ELSEIF (#{zone_name}_cont_cool_oper > 0) && (#{zone_name}_zone_mode == 0),
-          SET #{zone_name}_zone_mode = 1,
-      ELSEIF (#{zone_name}_cont_heat_oper > 0) && (#{zone_name}_zone_mode == 0),
-          SET #{zone_name}_zone_mode = -1,
-      ELSE,
-          SET #{zone_name}_zone_mode = #{zone_name}_zone_mode,
-      ENDIF
-    EMS
-    determine_zone_mode_prg.setBody(determine_zone_mode_prg_body)
-
-    # Calculate the cumulative time for active hydronic cooling and heating.
-    calculate_cumulative_sum_prg = OpenStudio::Model::EnergyManagementSystemProgram.new(model)
-    calculate_cumulative_sum_prg.setName("#{zone_name}_Calculate_Cumulative_Sum")
-    calculate_cumulative_sum_prg_body = <<-EMS
-      IF (CurrentTime == (occ_hr_end - ZoneTimeStep)),
-          SET #{zone_name}_daily_cool_sum_one = #{zone_name}_daily_cool_sum,
-          SET #{zone_name}_daily_heat_sum_one = #{zone_name}_daily_heat_sum,
-          SET #{zone_name}_daily_cool_sum = @TrendSum #{zone_name}_Rad_Cool_Operation_Trend 24/ZoneTimeStep,
-          SET #{zone_name}_daily_heat_sum = @TrendSum #{zone_name}_Rad_Heat_Operation_Trend 24/ZoneTimeStep,
-      ENDIF
-    EMS
-    calculate_cumulative_sum_prg.setBody(calculate_cumulative_sum_prg_body)
-
     # Calculate the new active slab temperature setpoint for heating and cooling
     calculate_slab_ctrl_setpoint_prg = OpenStudio::Model::EnergyManagementSystemProgram.new(model)
     calculate_slab_ctrl_setpoint_prg.setName("#{zone_name}_Calculate_Slab_Ctrl_Setpoint")
     calculate_slab_ctrl_setpoint_prg_body = <<-EMS
-      IF (#{zone_name}_zone_mode >= 0),
-        SET #{zone_name}_cont_cool_oper = @TrendSum #{zone_name}_Rad_Cool_Operation_Trend 24/ZoneTimeStep,
-        IF (#{zone_name}_cont_cool_oper > 0) && (CurrentTime == occ_hr_end),
-          SET #{zone_name}_CMD_SLAB_SP = #{zone_name}_CMD_SLAB_SP + (#{zone_name}_CMD_CSP_ERROR*prp_k),
-        ENDIF,
-      ELSEIF (#{zone_name}_zone_mode <= 0),
-        SET #{zone_name}_cont_heat_oper = @TrendSum #{zone_name}_Rad_Heat_Operation_Trend 24/ZoneTimeStep,
-        IF (#{zone_name}_cont_heat_oper > 0) && (CurrentTime == occ_hr_end),
-          SET #{zone_name}_CMD_SLAB_SP = #{zone_name}_CMD_SLAB_SP + (#{zone_name}_CMD_HSP_ERROR*prp_k),
-        ENDIF,
+      SET #{zone_name}_cont_cool_oper = @TrendSum #{zone_name}_rad_cool_operation_trend radiant_switch_over_time/ZoneTimeStep,
+      SET #{zone_name}_cont_heat_oper = @TrendSum #{zone_name}_rad_heat_operation_trend radiant_switch_over_time/ZoneTimeStep,
+      SET #{zone_name}_occupied_hours = @TrendSum #{zone_name}_occupied_status_trend 24/ZoneTimeStep,
+      IF (#{zone_name}_cont_cool_oper > 0) && (#{zone_name}_occupied_hours > 0) && (CurrentTime == hour_of_slab_sp_change),
+        SET #{zone_name}_cmd_hot_water_ctrl = #{zone_name}_cmd_hot_water_ctrl + (#{zone_name}_cmd_csp_error*prp_k),
+      ELSEIF (#{zone_name}_cont_heat_oper > 0) && (#{zone_name}_occupied_hours > 0) && (CurrentTime == hour_of_slab_sp_change),
+        SET #{zone_name}_cmd_hot_water_ctrl = #{zone_name}_cmd_hot_water_ctrl + (#{zone_name}_cmd_hsp_error*prp_k),
+      ELSE,
+        SET #{zone_name}_cmd_hot_water_ctrl = #{zone_name}_cmd_hot_water_ctrl,
       ENDIF,
-      IF (#{zone_name}_CMD_SLAB_SP < lower_slab_sp_lim),
-        SET #{zone_name}_CMD_SLAB_SP = lower_slab_sp_lim,
-      ELSEIF (#{zone_name}_CMD_SLAB_SP > upper_slab_sp_lim),
-        SET #{zone_name}_CMD_SLAB_SP = upper_slab_sp_lim,
+      IF (#{zone_name}_cmd_hot_water_ctrl < lower_slab_sp_lim),
+        SET #{zone_name}_cmd_hot_water_ctrl = lower_slab_sp_lim,
+      ELSEIF (#{zone_name}_cmd_hot_water_ctrl > upper_slab_sp_lim),
+        SET #{zone_name}_cmd_hot_water_ctrl = upper_slab_sp_lim,
       ENDIF,
+      SET #{zone_name}_cmd_cold_water_ctrl = #{zone_name}_cmd_hot_water_ctrl + 0.01
     EMS
     calculate_slab_ctrl_setpoint_prg.setBody(calculate_slab_ctrl_setpoint_prg_body)
 
-    # Apply a weekend setback at the start of a weekend and remove the reset at the defined time.
-    implement_setback_prg = OpenStudio::Model::EnergyManagementSystemProgram.new(model)
-    implement_setback_prg.setName("#{zone_name}_Implement_setback")
-    implement_setback_prg_body = <<-EMS
-      IF early_reset_out > occ_hr_start,
-          SET turn_on_day = 1,
-          SET turn_on_hour = 24 - (early_reset_out - occ_hr_start),
-      ELSE,
-          SET turn_on_day = 2,
-          SET turn_on_hour = occ_hr_start - early_reset_out,
-      ENDIF,
-      IF (CurrentTime == occ_hr_end) && (DayOfWeek == 6),
-          SET #{zone_name}_CMD_SLAB_SP = #{zone_name}_CMD_SLAB_SP,
-      ELSEIF (CurrentTime == turn_on_hour) && (DayOfWeek == turn_on_day),
-          SET #{zone_name}_CMD_SLAB_SP = #{zone_name}_CMD_SLAB_SP,
-      ENDIF
-    EMS
-    implement_setback_prg.setBody(implement_setback_prg_body)
-
-    # Get design day size
-    num_design_days = model.getDesignDays.size
-    OpenStudio.logFree(OpenStudio::Warn, 'openstudio.Model.Model', "EMS code for radiant system operation depends on the number of design days being fixed. The model has #{num_design_days}.  Do not change design days now that the model has EMS code dependent on them. ")
-
-    # Turn radiant system ON/OFF for cooling or heating based on calculated setpoints and building mode.
-    determine_radiant_operation_prg = OpenStudio::Model::EnergyManagementSystemProgram.new(model)
-    determine_radiant_operation_prg.setName("#{zone_name}_Determine_Radiant_Operation")
-    determine_radiant_operation_prg_body = <<-EMS
-      IF (CurrentEnvironment) <= #{num_design_days} ! Operation during design days
-          SET #{zone_name}_CMD_COLD_WATER_CTRL = 0,
-          SET #{zone_name}_CMD_HOT_WATER_CTRL = -60,
-      ELSE,                ! Operation during annual simulation
-          IF (#{zone_name}_zone_mode >= 0) && (#{zone_name}_Srf_Temp > #{zone_name}_CMD_SLAB_SP),
-              SET #{zone_name}_CMD_COLD_WATER_CTRL = 0,
-              SET #{zone_name}_CMD_HOT_WATER_CTRL = -60,
-          ELSEIF (#{zone_name}_zone_mode >= 0) && (#{zone_name}_Srf_Temp < #{zone_name}_CMD_SLAB_SP) && (min_oper > #{zone_name}_cont_rad_oper) && (#{zone_name}_cont_rad_oper <> 0),
-              SET #{zone_name}_CMD_COLD_WATER_CTRL = 0,
-              SET #{zone_name}_CMD_HOT_WATER_CTRL = -60,
-          ELSEIF (#{zone_name}_zone_mode <= 0) && (#{zone_name}_Srf_Temp < #{zone_name}_CMD_SLAB_SP),
-              SET #{zone_name}_CMD_COLD_WATER_CTRL = 100,
-              SET #{zone_name}_CMD_HOT_WATER_CTRL = 60,
-          ELSEIF (#{zone_name}_zone_mode <= 0) && (#{zone_name}_Srf_Temp > #{zone_name}_CMD_SLAB_SP) && (min_oper > #{zone_name}_cont_rad_oper) && (#{zone_name}_cont_rad_oper <> 0),
-              SET #{zone_name}_CMD_COLD_WATER_CTRL = 100,
-              SET #{zone_name}_CMD_HOT_WATER_CTRL = 60,
-          ELSE,
-              SET #{zone_name}_CMD_COLD_WATER_CTRL = 60,
-              SET #{zone_name}_CMD_HOT_WATER_CTRL = -60,
-          ENDIF,
-      ENDIF
-    EMS
-    determine_radiant_operation_prg.setBody(determine_radiant_operation_prg_body)
-
     #####
     # List of EMS program manager objects
     ####
-    initialize_constant_parameters = model.getEnergyManagementSystemProgramCallingManagerByName('Set_Constant_Values')
+
+    initialize_constant_parameters = model.getEnergyManagementSystemProgramCallingManagerByName('Initialize_Constant_Parameters')
     if initialize_constant_parameters.is_initialized
       initialize_constant_parameters = initialize_constant_parameters.get
+      # add program if it does not exist in manager
+      existing_program_names = initialize_constant_parameters.programs.collect { |prg| prg.name.get.downcase }
+      unless existing_program_names.include? set_constant_values_prg.name.get.downcase
+        initialize_constant_parameters.addProgram(set_constant_values_prg)
+      end
     else
       initialize_constant_parameters = OpenStudio::Model::EnergyManagementSystemProgramCallingManager.new(model)
       initialize_constant_parameters.setName('Initialize_Constant_Parameters')
@@ -644,13 +401,18 @@ class Standard
       initialize_constant_parameters.addProgram(set_constant_values_prg)
     end
 
-    initialize_constant_parameters_after_warmup = model.getEnergyManagementSystemProgramCallingManagerByName('Set_Constant_Values')
+    initialize_constant_parameters_after_warmup = model.getEnergyManagementSystemProgramCallingManagerByName('Initialize_Constant_Parameters_After_Warmup')
     if initialize_constant_parameters_after_warmup.is_initialized
       initialize_constant_parameters_after_warmup = initialize_constant_parameters_after_warmup.get
+      # add program if it does not exist in manager
+      existing_program_names = initialize_constant_parameters_after_warmup.programs.collect { |prg| prg.name.get.downcase }
+      unless existing_program_names.include? set_constant_values_prg.name.get.downcase
+        initialize_constant_parameters_after_warmup.addProgram(set_constant_values_prg)
+      end
     else
       initialize_constant_parameters_after_warmup = OpenStudio::Model::EnergyManagementSystemProgramCallingManager.new(model)
       initialize_constant_parameters_after_warmup.setName('Initialize_Constant_Parameters_After_Warmup')
-      initialize_constant_parameters_after_warmup.setCallingPoint('BeginNewEnvironment')
+      initialize_constant_parameters_after_warmup.setCallingPoint('AfterNewEnvironmentWarmUpIsComplete')
       initialize_constant_parameters_after_warmup.addProgram(set_constant_values_prg)
     end
 
@@ -661,7 +423,7 @@ class Standard
 
     zone_initialize_constant_parameters_after_warmup = OpenStudio::Model::EnergyManagementSystemProgramCallingManager.new(model)
     zone_initialize_constant_parameters_after_warmup.setName("#{zone_name}_Initialize_Constant_Parameters_After_Warmup")
-    zone_initialize_constant_parameters_after_warmup.setCallingPoint('BeginNewEnvironment')
+    zone_initialize_constant_parameters_after_warmup.setCallingPoint('AfterNewEnvironmentWarmUpIsComplete')
     zone_initialize_constant_parameters_after_warmup.addProgram(set_constant_zone_values_prg)
 
     average_building_temperature = OpenStudio::Model::EnergyManagementSystemProgramCallingManager.new(model)
@@ -669,42 +431,139 @@ class Standard
     average_building_temperature.setCallingPoint('EndOfZoneTimestepAfterZoneReporting')
     average_building_temperature.addProgram(calculate_minmax_ctrl_temp_prg)
     average_building_temperature.addProgram(calculate_errors_from_comfort_prg)
-    average_building_temperature.addProgram(calculate_neutral_time_prg)
-    average_building_temperature.addProgram(determine_zone_mode_prg)
-    average_building_temperature.addProgram(calculate_trends_prg)
-    average_building_temperature.addProgram(calculate_continuous_radiant_operation_prg)
-    average_building_temperature.addProgram(calculate_cumulative_sum_prg)
 
     programs_at_beginning_of_timestep = OpenStudio::Model::EnergyManagementSystemProgramCallingManager.new(model)
     programs_at_beginning_of_timestep.setName("#{zone_name}_Programs_At_Beginning_Of_Timestep")
     programs_at_beginning_of_timestep.setCallingPoint('BeginTimestepBeforePredictor')
-    programs_at_beginning_of_timestep.addProgram(determine_weekend_prg)
-    programs_at_beginning_of_timestep.addProgram(determine_unoccupied_prg)
-    programs_at_beginning_of_timestep.addProgram(determine_zone_mode_prg)
-    programs_at_beginning_of_timestep.addProgram(implement_setback_prg)
     programs_at_beginning_of_timestep.addProgram(calculate_slab_ctrl_setpoint_prg)
-    programs_at_beginning_of_timestep.addProgram(determine_radiant_operation_prg)
 
     #####
     # List of variables for output.
     ####
+
     zone_max_ctrl_temp_output = OpenStudio::Model::EnergyManagementSystemOutputVariable.new(model, zone_max_ctrl_temp)
     zone_max_ctrl_temp_output.setName("#{zone_name} Maximum occupied temperature in zone")
     zone_min_ctrl_temp_output = OpenStudio::Model::EnergyManagementSystemOutputVariable.new(model, zone_min_ctrl_temp)
     zone_min_ctrl_temp_output.setName("#{zone_name} Minimum occupied temperature in zone")
-    zone_zone_mode_output = OpenStudio::Model::EnergyManagementSystemOutputVariable.new(model, zone_zone_mode)
-    zone_zone_mode_output.setName("#{zone_name} Zone Mode of Operation")
-    zone_cont_neutral_oper_output = OpenStudio::Model::EnergyManagementSystemOutputVariable.new(model, zone_cont_neutral_oper)
-    zone_cont_neutral_oper_output.setName("#{zone_name} Number of Hours in Neutral Operation")
-    zone_cont_rad_oper_output = OpenStudio::Model::EnergyManagementSystemOutputVariable.new(model, zone_cont_rad_oper)
-    zone_cont_rad_oper_output.setName("#{zone_name} Number of Hours in Continuous Operation")
-    zone_daily_cool_sum_output = OpenStudio::Model::EnergyManagementSystemOutputVariable.new(model, zone_daily_cool_sum)
-    zone_daily_cool_sum_output.setName("#{zone_name} Daily Building Cool Operation")
-    zone_daily_heat_sum_output = OpenStudio::Model::EnergyManagementSystemOutputVariable.new(model, zone_daily_heat_sum)
-    zone_daily_heat_sum_output.setName("#{zone_name} Daily Building Heat Operation")
-    zone_daily_cool_sum_one_output = OpenStudio::Model::EnergyManagementSystemOutputVariable.new(model, zone_daily_cool_sum_one)
-    zone_daily_cool_sum_one_output.setName("#{zone_name} Daily Building Cool Operation One")
-    zone_daily_heat_sum_one_output = OpenStudio::Model::EnergyManagementSystemOutputVariable.new(model, zone_daily_heat_sum_one)
-    zone_daily_heat_sum_one_output.setName("#{zone_name} Daily Building Heat Operation One")
+  end
+
+  # Native EnergyPlus objects implement a control for a single thermal zone with a radiant system.
+  # @param zone [OpenStudio::Model::ThermalZone>] zone to add radiant controls
+  # @param radiant_loop [OpenStudio::Model::ZoneHVACLowTempRadiantVarFlow>] radiant loop in thermal zone
+  # @param radiant_temperature_control_type [String] determines the controlled temperature for the radiant system
+  #   options are 'SurfaceFaceTemperature', 'SurfaceInteriorTemperature'
+  # @param slab_setpoint_oa_control [Bool] True if slab setpoint is to be varied based on outdoor air temperature
+  # @param switch_over_time [Double] Time limitation for when the system can switch between heating and cooling
+  # @param slab_sp_at_oat_low [Double] radiant slab temperature setpoint, in F, at the outdoor high temperature.
+  # @param slab_oat_low [Double] outdoor drybulb air temperature, in F, for low radiant slab setpoint.
+  # @param slab_sp_at_oat_high [Double] radiant slab temperature setpoint, in F, at the outdoor low temperature.
+  # @param slab_oat_high [Double] outdoor drybulb air temperature, in F, for high radiant slab setpoint.
+  def model_add_radiant_basic_controls(model, zone, radiant_loop,
+                                       radiant_temperature_control_type: 'SurfaceFaceTemperature',
+                                       slab_setpoint_oa_control: false,
+                                       switch_over_time: 24.0,
+                                       slab_sp_at_oat_low: 73,
+                                       slab_oat_low: 65,
+                                       slab_sp_at_oat_high: 68,
+                                       slab_oat_high: 80)
+
+    zone_name = zone.name.to_s.gsub(/[ +-.]/, '_')
+
+    if model.version < OpenStudio::VersionString.new('3.1.1')
+      coil_cooling_radiant = radiant_loop.coolingCoil.to_CoilCoolingLowTempRadiantVarFlow.get
+      coil_heating_radiant = radiant_loop.heatingCoil.to_CoilHeatingLowTempRadiantVarFlow.get
+    else
+      coil_cooling_radiant = radiant_loop.coolingCoil.get.to_CoilCoolingLowTempRadiantVarFlow.get
+      coil_heating_radiant = radiant_loop.heatingCoil.get.to_CoilHeatingLowTempRadiantVarFlow.get
+    end
+
+    #####
+    # Define radiant system parameters
+    ####
+    # set radiant system temperature and setpoint control type
+    unless ['surfacefacetemperature', 'surfaceinteriortemperature'].include? radiant_temperature_control_type.downcase
+      OpenStudio.logFree(OpenStudio::Error, 'openstudio.Model.Model',
+                         "Control sequences not compatible with '#{radiant_temperature_control_type}' radiant system control. Defaulting to 'SurfaceFaceTemperature'.")
+      radiant_temperature_control_type = 'SurfaceFaceTemperature'
+    end
+
+    radiant_loop.setTemperatureControlType(radiant_temperature_control_type)
+
+    # get existing switchover time schedule or create one if needed
+    sch_radiant_switchover = model.getScheduleRulesetByName('Radiant System Switchover')
+    if sch_radiant_switchover.is_initialized
+      sch_radiant_switchover = sch_radiant_switchover.get
+    else
+      sch_radiant_switchover = model_add_constant_schedule_ruleset(model,
+                                                                   switch_over_time,
+                                                                   name = 'Radiant System Switchover',
+                                                                   sch_type_limit: 'Dimensionless')
+    end
+
+    # set radiant system switchover schedule
+    radiant_loop.setChangeoverDelayTimePeriodSchedule(sch_radiant_switchover.to_Schedule.get)
+
+    if slab_setpoint_oa_control
+      # get weather file from model
+      weather_file = model.getWeatherFile
+      if weather_file.initialized
+        # get annual outdoor dry bulb temperature
+        annual_oat = weather_file.file.get.data.collect { |dat| dat.dryBulbTemperature.get }
+
+        # calculate a nhrs rolling average from annual outdoor dry bulb temperature
+        nhrs = 24
+        last_nhrs_oat_in_year = annual_oat.last(nhrs - 1)
+        combined_oat = last_nhrs_oat_in_year + annual_oat
+        oat_rolling_average = combined_oat.each_cons(nhrs).map { |e| e.reduce(&:+).fdiv(nhrs).round(2) }
+
+        # use rolling average to calculate slab setpoint temperature
+
+        # convert temperature from IP to SI units
+        slab_sp_at_oat_low_si = OpenStudio.convert(slab_sp_at_oat_low, 'F', 'C').get
+        slab_oat_low_si = OpenStudio.convert(slab_oat_low, 'F', 'C').get
+        slab_sp_at_oat_high_si = OpenStudio.convert(slab_sp_at_oat_high, 'F', 'C').get
+        slab_oat_high_si = OpenStudio.convert(slab_oat_high, 'F', 'C').get
+
+        # calculate relationship between slab setpoint and slope
+        slope_num = slab_sp_at_oat_high_si - slab_sp_at_oat_low_si
+        slope_den = slab_oat_high_si - slab_oat_low_si
+        sp_and_oat_slope = slope_num.fdiv(slope_den).round(4)
+
+        slab_setpoint = oat_rolling_average.map { |e| (slab_sp_at_oat_low_si + ((e - slab_oat_low_si) * sp_and_oat_slope)).round(1) }
+
+        # input upper limits on slab setpoint
+        slab_sp_upper_limit = [slab_sp_at_oat_high_si, slab_sp_at_oat_low_si].max
+        slab_sp_lower_limit = [slab_sp_at_oat_high_si, slab_sp_at_oat_low_si].min
+        slab_setpoint.map! { |e| e > slab_sp_upper_limit ? slab_sp_upper_limit.round(1) : e }
+
+        # input lower limits on slab setpoint
+        slab_setpoint.map! { |e| e < slab_sp_lower_limit ? slab_sp_lower_limit.round(1) : e }
+
+        # create ruleset for slab setpoint
+        sch_type_limits_obj = model_add_schedule_type_limits(model, standard_sch_type_limit: 'Temperature')
+        sch_radiant_slab_setp = make_ruleset_sched_from_8760(model, slab_setpoint,
+                                                             'Sch_Radiant_SlabSetP_Based_On_Rolling_Mean_OAT',
+                                                             sch_type_limits_obj)
+
+        coil_heating_radiant.setHeatingControlTemperatureSchedule(sch_radiant_slab_setp)
+        coil_cooling_radiant.setCoolingControlTemperatureSchedule(sch_radiant_slab_setp)
+      else
+        OpenStudio.logFree(OpenStudio::Error, 'openstudio.Model.Model',
+                           'Model does not have a weather file associated with it. Define to implement slab setpoint based on outdoor weather.')
+      end
+    else
+      # radiant system cooling control setpoint
+      slab_setpoint = 22
+      sch_radiant_clgsetp = model_add_constant_schedule_ruleset(model,
+                                                                slab_setpoint + 0.1,
+                                                                name = "#{zone_name}_Sch_Radiant_ClgSetP")
+      coil_cooling_radiant.setCoolingControlTemperatureSchedule(sch_radiant_clgsetp)
+
+      # radiant system heating control setpoint
+      sch_radiant_htgsetp = model_add_constant_schedule_ruleset(model,
+                                                                slab_setpoint,
+                                                                name = "#{zone_name}_Sch_Radiant_HtgSetP")
+      coil_heating_radiant.setHeatingControlTemperatureSchedule(sch_radiant_htgsetp)
+    end
   end
 end