openstudio-standards 0.8.3 → 0.8.5.rc1

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

@@ -1,590 +0,0 @@
-class Standard
-  # These EnergyPlus objects implement a proportional control for a single thermal zone with a radiant system.
-  # @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_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 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_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,
-                                              switch_over_time: 24.0)
-
-    zone_name = ems_friendly_name(zone.name)
-    zone_timestep = model.getTimestep.numberOfTimestepsPerHour
-
-    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)
-
-    #####
-    # List of schedule objects used to hold calculation results
-    ####
-
-    # 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 = OpenstudioStandards::Schedules.create_constant_schedule_ruleset(model,
-                                                                                               switch_over_time,
-                                                                                               name: 'Radiant System Switchover',
-                                                                                               schedule_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 = OpenstudioStandards::Schedules.create_constant_schedule_ruleset(model,
-                                                                                          26.0,
-                                                                                          name: "#{zone_name}_Sch_Radiant_ClgSetP",
-                                                                                          schedule_type_limit: 'Temperature')
-    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")
-
-    # radiant system heating control actuator
-    sch_radiant_htgsetp = OpenstudioStandards::Schedules.create_constant_schedule_ruleset(model,
-                                                                                          20.0,
-                                                                                          name: "#{zone_name}_Sch_Radiant_HtgSetP",
-                                                                                          schedule_type_limit: 'Temperature')
-    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")
-
-    # Calculated cooling setpoint error. Calculated from upper comfort limit minus setpoint offset and 'measured' controlled zone temperature.
-    sch_csp_error = OpenstudioStandards::Schedules.create_constant_schedule_ruleset(model,
-                                                                                    0.0,
-                                                                                    name: "#{zone_name}_Sch_CSP_Error",
-                                                                                    schedule_type_limit: 'Temperature')
-    cmd_csp_error = OpenStudio::Model::EnergyManagementSystemActuator.new(sch_csp_error,
-                                                                          'Schedule:Year',
-                                                                          'Schedule Value')
-    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 = OpenstudioStandards::Schedules.create_constant_schedule_ruleset(model,
-                                                                                    0.0,
-                                                                                    name: "#{zone_name}_Sch_HSP_Error",
-                                                                                    schedule_type_limit: 'Temperature')
-    cmd_hsp_error = OpenStudio::Model::EnergyManagementSystemActuator.new(sch_hsp_error,
-                                                                          'Schedule:Year',
-                                                                          'Schedule Value')
-    cmd_hsp_error.setName("#{zone_name}_cmd_hsp_error")
-
-    #####
-    # List of global variables used in EMS scripts
-    ####
-
-    # Proportional  gain constant (recommended 0.3 or less).
-    prp_k = model.getEnergyManagementSystemGlobalVariableByName('prp_k')
-    if prp_k.is_initialized
-      prp_k = prp_k.get
-    else
-      prp_k = OpenStudio::Model::EnergyManagementSystemGlobalVariable.new(model, 'prp_k')
-    end
-
-    # 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
-    else
-      upper_slab_sp_lim = OpenStudio::Model::EnergyManagementSystemGlobalVariable.new(model, 'upper_slab_sp_lim')
-    end
-
-    # 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
-    else
-      lower_slab_sp_lim = OpenStudio::Model::EnergyManagementSystemGlobalVariable.new(model, 'lower_slab_sp_lim')
-    end
-
-    # 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
-    else
-      ctrl_temp_offset = OpenStudio::Model::EnergyManagementSystemGlobalVariable.new(model, 'ctrl_temp_offset')
-    end
-
-    # 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.
-    zone_max_ctrl_temp = OpenStudio::Model::EnergyManagementSystemGlobalVariable.new(model, "#{zone_name}_max_ctrl_temp")
-
-    # Minimum 'measured' temperature in zone during occupied times. Default setup uses mean air temperature.
-    # Other possible choices are operative and mean radiant temperature.
-    zone_min_ctrl_temp = OpenStudio::Model::EnergyManagementSystemGlobalVariable.new(model, "#{zone_name}_min_ctrl_temp")
-
-    #####
-    # List of 'sensors' used in the EMS programs
-    ####
-
-    # 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.setKeyName(zone.name.get)
-
-    # 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
-
-    # 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 = OpenstudioStandards::Schedules.create_constant_schedule_ruleset(model,
-                                                                                            20.0,
-                                                                                            name: 'Radiant System Heating Setpoint',
-                                                                                            schedule_type_limit: 'Temperature')
-    end
-
-    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 = OpenstudioStandards::Schedules.create_constant_schedule_ruleset(model,
-                                                                                            26.0,
-                                                                                            name: 'Radiant System Cooling Setpoint',
-                                                                                            schedule_type_limit: 'Temperature')
-    end
-
-    # 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.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.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.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.setKeyName(coil_heating_radiant.to_StraightComponent.get.inletModelObject.get.name.get)
-
-    # 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')
-
-    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 * 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 * 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 = OpenstudioStandards::ThermalZone.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_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.setBody(set_constant_values_prg_body)
-    end
-
-    # Initialize zone specific constant values used in EMS programs.
-    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}_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 = 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 (#{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,
-          ENDIF,
-      ELSE,
-        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)
-
-    # Calculate errors from comfort zone limits and 'measured' controlled temperature in the zone.
-    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 == (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 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
-      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_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)
-
-    #####
-    # List of EMS program manager objects
-    ####
-
-    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')
-      initialize_constant_parameters.setCallingPoint('BeginNewEnvironment')
-      initialize_constant_parameters.addProgram(set_constant_values_prg)
-    end
-
-    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('AfterNewEnvironmentWarmUpIsComplete')
-      initialize_constant_parameters_after_warmup.addProgram(set_constant_values_prg)
-    end
-
-    zone_initialize_constant_parameters = OpenStudio::Model::EnergyManagementSystemProgramCallingManager.new(model)
-    zone_initialize_constant_parameters.setName("#{zone_name}_Initialize_Constant_Parameters")
-    zone_initialize_constant_parameters.setCallingPoint('BeginNewEnvironment')
-    zone_initialize_constant_parameters.addProgram(set_constant_zone_values_prg)
-
-    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('AfterNewEnvironmentWarmUpIsComplete')
-    zone_initialize_constant_parameters_after_warmup.addProgram(set_constant_zone_values_prg)
-
-    average_building_temperature = OpenStudio::Model::EnergyManagementSystemProgramCallingManager.new(model)
-    average_building_temperature.setName("#{zone_name}_Average_Building_Temperature")
-    average_building_temperature.setCallingPoint('EndOfZoneTimestepAfterZoneReporting')
-    average_building_temperature.addProgram(calculate_minmax_ctrl_temp_prg)
-    average_building_temperature.addProgram(calculate_errors_from_comfort_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(calculate_slab_ctrl_setpoint_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")
-  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 = OpenstudioStandards::Schedules.create_constant_schedule_ruleset(model,
-                                                                                               switch_over_time,
-                                                                                               name: 'Radiant System Switchover',
-                                                                                               schedule_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 }
-
-        # convert to timeseries
-        yd = model.getYearDescription
-        start_date = yd.makeDate(1, 1)
-        interval = OpenStudio::Time.new(1.0 / 24.0)
-        time_series = OpenStudio::TimeSeries.new(start_date, interval, OpenStudio.createVector(slab_setpoint), 'C')
-
-        # check for pre-existing schedule in model
-        schedule_interval = model.getScheduleByName('Sch_Radiant_SlabSetP_Based_On_Rolling_Mean_OAT')
-        if schedule_interval.is_initialized && schedule_interval.get.to_ScheduleFixedInterval.is_initialized
-          schedule_interval = schedule_interval.get.to_ScheduleFixedInterval.get
-          schedule_interval.setTimeSeries(time_series)
-        else
-          # create fixed interval schedule for slab setpoint
-          schedule_interval = OpenStudio::Model::ScheduleFixedInterval.new(model)
-          schedule_interval.setName('Sch_Radiant_SlabSetP_Based_On_Rolling_Mean_OAT')
-          schedule_interval.setTimeSeries(time_series)
-          sch_type_limits_obj = OpenstudioStandards::Schedules.create_schedule_type_limits(model, standard_schedule_type_limit: 'Temperature')
-          schedule_interval.setScheduleTypeLimits(sch_type_limits_obj)
-        end
-
-        # assign slab setpoint schedule
-        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 = OpenstudioStandards::Schedules.create_constant_schedule_ruleset(model,
-                                                                                            slab_setpoint + 0.1,
-                                                                                            name: "#{zone_name}_Sch_Radiant_ClgSetP",
-                                                                                            schedule_type_limit: 'Temperature')
-      coil_cooling_radiant.setCoolingControlTemperatureSchedule(sch_radiant_clgsetp)
-
-      # radiant system heating control setpoint
-      sch_radiant_htgsetp = OpenstudioStandards::Schedules.create_constant_schedule_ruleset(model,
-                                                                                            slab_setpoint,
-                                                                                            name: "#{zone_name}_Sch_Radiant_HtgSetP",
-                                                                                            schedule_type_limit: 'Temperature')
-      coil_heating_radiant.setHeatingControlTemperatureSchedule(sch_radiant_htgsetp)
-    end
-  end
-end